excalibur 0.25.1 → 0.25.2

package/build/dist/Graphics/Context/rectangle-renderer/rectangle-renderer.vert.glsl

@@ -0,0 +1,42 @@
+attribute vec2 a_position;
+
+// UV coordinate
+attribute vec2 a_uv;
+varying vec2 v_uv;
+
+attribute vec2 a_size;
+varying vec2 v_size;
+
+// Opacity 
+attribute float a_opacity;
+varying float v_opacity;
+
+attribute vec4 a_color;
+varying vec4 v_color;
+
+attribute vec4 a_strokeColor;
+varying vec4 v_strokeColor;
+
+attribute float a_strokeThickness;
+varying float v_strokeThickness;
+
+uniform mat4 u_matrix;
+
+
+void main() {
+   // Set the vertex position using the ortho transform matrix
+   gl_Position = u_matrix * vec4(a_position, 0.0, 1.0);
+
+   // Pass through UV coords
+   v_uv = a_uv;
+   // Pass through size
+   v_size = a_size;
+   // Pass through the Opacity to the fragment shader
+   v_opacity = a_opacity;
+   // Pass through the color to the fragment shader
+   v_color = a_color;
+   // Pass through the stroke color to the fragment shader
+   v_strokeColor = a_strokeColor;
+   // Pass through the stroke thickenss to the fragment shader
+   v_strokeThickness = a_strokeThickness;
+}

package/build/dist/Graphics/Context/render-source.d.ts

@@ -0,0 +1,7 @@
+export declare class RenderSource {
+    private _gl;
+    private _texture;
+    constructor(_gl: WebGLRenderingContext, _texture: WebGLTexture);
+    use(): void;
+    disable(): void;
+}

package/build/dist/Graphics/Context/render-target.d.ts

@@ -0,0 +1,26 @@
+import { RenderSource } from './render-source';
+export declare class RenderTarget {
+    width: number;
+    height: number;
+    private _gl;
+    constructor(options: {
+        gl: WebGLRenderingContext;
+        width: number;
+        height: number;
+    });
+    setResolution(width: number, height: number): void;
+    private _frameBuffer;
+    get frameBuffer(): WebGLFramebuffer;
+    private _frameTexture;
+    get frameTexture(): WebGLTexture;
+    private _setupFramebuffer;
+    toRenderSource(): RenderSource;
+    /**
+     * When called, all drawing gets redirected to this render target
+     */
+    use(): void;
+    /**
+     * When called, all drawing is sent back to the canvas
+     */
+    disable(): void;
+}

package/build/dist/Graphics/Context/renderer.d.ts

@@ -1,66 +1,35 @@
-import { BatchCommand } from './batch';
-import { Shader } from './shader';
-import { Pool, Poolable } from '../../Util/Pool';
-export interface Renderer {
-    render(): void;
-}
-export interface Ctor<T> {
-    new (): T;
-}
-export interface BatchRendererOptions<T extends Poolable> {
-    gl: WebGLRenderingContext;
+import { ExcaliburGraphicsContextWebGL } from './ExcaliburGraphicsContextWebGL';
+/**
+ * Interface that defines an Excalibur Renderer that can be called with .draw() in the [[ExcaliburGraphicsContext]]
+ */
+export interface RendererPlugin {
     /**
-     * Draw command constructor
+     * Unique type name for this renderer plugin
      */
-    command: Ctor<T>;
+    readonly type: string;
     /**
-     * Number of vertices that are generated per draw command
+     * Render priority tie breaker when drawings are at the same z index
+     * @warning Not yet used by excalibur
      */
-    verticesPerCommand?: number;
-    /**
-     * Maximum commands to batch before drawing
-     */
-    maxCommandsPerBatch?: number;
-    /**
-     * Override the built in command batching mechanism
-     */
-    batchFactory?: () => BatchCommand<T>;
-}
-export declare abstract class BatchRenderer<T extends Poolable> implements Renderer {
     priority: number;
-    private _gl;
-    private _vertices;
-    private _verticesPerCommand;
-    private _buffer;
-    private _maxCommandsPerBatch;
-    shader: Shader;
-    commands: Pool<T>;
-    private _batchPool;
-    private _batches;
-    constructor(options: BatchRendererOptions<T>);
-    /**
-     * Initialize render, builds shader and initialized webgl buffers
-     */
-    init(): void;
-    get vertexSize(): number;
-    addCommand(cmd: T): void;
     /**
-     * Construct or return the Shader to be used in this batch renderer
+     * Initialize your renderer
+     *
      * @param gl
+     * @param context
      */
-    abstract buildShader(gl: WebGLRenderingContext): Shader;
+    initialize(gl: WebGLRenderingContext, context: ExcaliburGraphicsContextWebGL): void;
     /**
-     * Implement populating the vertex buffer, return the number of vertices added to the buffer
-     * @param vertices
-     * @param batch
+     * Issue a draw command to draw something to the screen
+     * @param args
      */
-    abstract buildBatchVertices(vertexBuffer: Float32Array, batch: BatchCommand<T>): number;
+    draw(...args: any[]): void;
     /**
-     * Implement gl draw call to render batch. The vertextBuffer from buildBatchVertices is already bound and the data has been updated.
+     * @returns if there are any pending draws in the renderer
      */
-    abstract renderBatch(gl: WebGLRenderingContext, batch: BatchCommand<T>, vertexCount: number): void;
+    hasPendingDraws(): boolean;
     /**
-     * Build batch geometry, submit to the gpu, and issue draw command to underlying webgl
+     * Flush any pending graphics draws to the screen
      */
-    render(): void;
+    flush(): void;
 }

package/build/dist/Graphics/Context/screen-pass-painter/screen-fragment.glsl

@@ -0,0 +1,11 @@
+precision mediump float;
+
+// Passed in from the vertex shader.
+varying vec2 v_texcoord;
+
+// The texture.
+uniform sampler2D u_texture;
+
+void main() {
+   gl_FragColor = texture2D(u_texture, v_texcoord);
+}

package/build/dist/Graphics/Context/screen-pass-painter/screen-pass-painter.d.ts

@@ -0,0 +1,13 @@
+import { PostProcessor } from '../../PostProcessor/PostProcessor';
+/**
+ * This is responsible for painting the entire screen during the render passes
+ */
+export declare class ScreenPassPainter {
+    private _gl;
+    private _shader;
+    private _buffer;
+    private _layout;
+    constructor(gl: WebGLRenderingContext);
+    renderWithPostProcessor(postprocessor: PostProcessor): void;
+    renderToScreen(): void;
+}

package/build/dist/Graphics/Context/screen-pass-painter/screen-vertex.glsl

@@ -0,0 +1,11 @@
+attribute vec2 a_position;
+
+attribute vec2 a_texcoord;
+varying vec2 v_texcoord;
+
+void main() {
+  gl_Position = vec4(a_position, 0.0, 1.0);
+
+  // Pass the texcoord to the fragment shader.
+  v_texcoord = a_texcoord;
+}

package/build/dist/Graphics/Context/shader.d.ts

@@ -1,81 +1,155 @@
+import { Vector } from '../..';
+import { Matrix } from '../../Math/matrix';
+export declare type UniformTypeNames = 'uniform1f' | 'uniform1i' | 'uniform2f' | 'uniform2i' | 'uniform3f' | 'uniform3i' | 'uniform4f' | 'uniform4i' | 'uniform1fv' | 'uniform1iv' | 'uniform2fv' | 'uniform2iv' | 'uniform3fv' | 'uniform3iv' | 'uniform4fv' | 'uniform4iv' | 'uniformMatrix2fv' | 'uniformMatrix3fv' | 'uniformMatrix4fv';
+declare type RemoveFirstFromTuple<T extends any[]> = T['length'] extends 0 ? undefined : (((...b: T) => void) extends (a: any, ...b: infer I) => void ? I : []);
+declare type UniformParameters<TUniformType extends UniformTypeNames> = RemoveFirstFromTuple<Parameters<WebGLRenderingContext[TUniformType]>>;
+export interface UniformDefinition {
+    name: string;
+    glType: number;
+    location: WebGLUniformLocation;
+}
 export interface VertexAttributeDefinition {
+    /**
+     * string name of the attribute in the shader program, commonly `a_nameofmyvariable`
+     */
     name: string;
+    /**
+     * Number of components for a given attribute
+     * Must be 1, 2, 3, or 4
+     *
+     * For example a vec4 attribute would be `4` floats, so 4
+     */
     size: number;
+    /**
+     * Supported types in webgl 1
+     * * gl.BYTE
+     * * gl.SHORT
+     * * gl.UNSIGNED_BYTE
+     * * gl.UNSIGNED_SHORT
+     * * gl.FLOAT
+     * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer
+     */
     glType: number;
+    /**
+     * Is the attribute normalized between (0-1)
+     */
     normalized: boolean;
+    /**
+     * Location index in the shader program
+     */
     location: number;
 }
-export interface UniformDefinition {
-    name: string;
-    location: WebGLUniformLocation;
-    type: string;
-    data: any;
+export interface ShaderOptions {
+    vertexSource: string;
+    fragmentSource: string;
 }
-/**
- * Create a shader program for the Excalibur WebGL Graphics Context
- */
 export declare class Shader {
+    private static _ACTIVE_SHADER_INSTANCE;
     private _gl;
-    private _vertexSource;
-    private _fragmentSource;
-    program: WebGLProgram | null;
+    program: WebGLProgram;
     uniforms: {
         [variableName: string]: UniformDefinition;
     };
     attributes: {
         [variableName: string]: VertexAttributeDefinition;
     };
-    layout: VertexAttributeDefinition[];
+    private _compiled;
+    readonly vertexSource: string;
+    readonly fragmentSource: string;
+    get compiled(): boolean;
     /**
      * Create a shader program in excalibur
-     * @param _gl WebGL graphics context
-     * @param _vertexSource Vertex shader source as a string
-     * @param _fragmentSource Fragment shader source as a string
+     * @param options specify shader vertex and fragment source
      */
-    constructor(_gl: WebGLRenderingContext, _vertexSource: string, _fragmentSource: string);
-    private _createProgram;
-    private _compileShader;
+    constructor(options?: ShaderOptions);
+    /**
+     * Binds the shader program
+     */
+    use(): void;
+    isCurrentlyBound(): boolean;
     /**
      * Compile the current shader against a webgl context
-     * @param gl WebGL context
      */
-    compile(gl: WebGLRenderingContext): WebGLProgram;
+    compile(): WebGLProgram;
+    getUniforms(): UniformDefinition[];
+    getAttributes(): VertexAttributeDefinition[];
     /**
-     * Add a uniform [[Matrix]] to the shader
-     * @param name Name of the uniform in the shader source
-     * @param data (4x4) matrix in column major order
+     * Set a texture in a gpu texture slot
+     * @param slotNumber
+     * @param texture
      */
-    addUniformMatrix(name: string, data: Float32Array): void;
+    setTexture(slotNumber: number, texture: WebGLTexture): void;
     /**
-     * Add a uniform array of numbers to the shader
-     * @param name Name of the uniform in the shader source
-     * @param data List of numbers
+     * Set an integer uniform for the current shader
+     *
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     *
+     * @param name
+     * @param value
      */
-    addUniformIntegerArray(name: string, data: number[]): void;
+    setUniformInt(name: string, value: number): void;
     /**
-     * Add attributes in the order they appear in the VBO
-     * @param name Name of the attribute in the shader source
-     * @param size The size of the attribute in gl.Type units, for example `vec2 a_pos` would be 2 gl.FLOAT
-     * @param glType The gl.Type of the attribute
+     * Set an integer array uniform for the current shader
+     *
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     *
+     * @param name
+     * @param value
      */
-    addAttribute(name: string, size: number, glType: number, normalized?: boolean): void;
+    setUniformIntArray(name: string, value: number[]): void;
     /**
-     * Number of javascript floats a vertex will take up
+     * Set a boolean uniform for the current shader
+     *
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     *
+     * @param name
+     * @param value
      */
-    get vertexAttributeSize(): number;
+    setUniformBoolean(name: string, value: boolean): void;
     /**
-     * Total number of bytes that the vertex will take up
+     * Set a float uniform for the current shader
+     *
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     *
+     * @param name
+     * @param value
      */
-    get totalVertexSizeBytes(): number;
+    setUniformFloat(name: string, value: number): void;
     /**
-     * Get a previously defined attribute size in bytes
+     * Set a float array uniform for the current shader
+     *
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     *
      * @param name
+     * @param value
      */
-    getAttributeSize(name: string): number;
+    setUniformFloatArray(name: string, value: number[]): void;
     /**
-     * Sets this shader program as the current in the underlying webgl context
+     * Set a [[Vector]] uniform for the current shader
+     *
+     * **Important** Must call ex.Shader.use() before setting a uniform!
      *
-     * **Must** specify all attributes and uniforms before calling this
+     * @param name
+     * @param value
      */
-    use(): void;
+    setUniformFloatVector(name: string, value: Vector): void;
+    /**
+     * Set an [[Matrix]] uniform for the current shader
+     *
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     *
+     * @param name
+     * @param value
+     */
+    setUniformMatrix(name: string, value: Matrix): void;
+    /**
+     * Set any available uniform type in webgl
+     *
+     * For example setUniform('uniformMatrix2fv', 'u_my2x2_mat`, ...);
+     */
+    setUniform<TUniformType extends UniformTypeNames>(uniformType: TUniformType, name: string, ...value: UniformParameters<TUniformType>): void;
+    private _createProgram;
+    private _compileShader;
+    private _processSourceForError;
 }
+export {};

package/build/dist/Graphics/Context/shaders/crt-effect.glsl

@@ -0,0 +1,64 @@
+// https://www.shadertoy.com/view/Ms23DR
+precision mediump float;
+
+// Passed in from the vertex shader.
+varying vec2 v_texcoord;
+
+// The texture.
+uniform sampler2D u_texture;
+
+vec2 curve(vec2 uv)
+{
+	uv = (uv - 0.5) * 2.0;
+	uv *= 1.1;	
+	uv.x *= 1.0 + pow((abs(uv.y) / 5.0), 2.0);
+	uv.y *= 1.0 + pow((abs(uv.x) / 4.0), 2.0);
+	uv  = (uv / 2.0) + 0.5;
+	uv =  uv *0.92 + 0.04;
+	return uv;
+}
+void main()
+{
+    vec2 uv = vec2(v_texcoord.x, v_texcoord.y);
+    uv = curve( uv );
+    vec3 oricol = texture2D(u_texture, uv).xyz;
+    float iTime = 10.0;
+    vec2 iResolution = vec2(1200, 900);
+    vec3 col;
+    float x =  sin(0.3*iTime+uv.y*21.0)*sin(0.7*iTime+uv.y*29.0)*sin(0.3+0.33*iTime+uv.y*31.0)*0.0017;
+
+    col.r = texture2D(u_texture,vec2(x+uv.x+0.001,uv.y+0.001)).x+0.05;
+    col.g = texture2D(u_texture,vec2(x+uv.x+0.000,uv.y-0.002)).y+0.05;
+    col.b = texture2D(u_texture,vec2(x+uv.x-0.002,uv.y+0.000)).z+0.05;
+    col.r += 0.08*texture2D(u_texture,0.75*vec2(x+0.025, -0.027)+vec2(uv.x+0.001,uv.y+0.001)).x;
+    col.g += 0.05*texture2D(u_texture,0.75*vec2(x+-0.022, -0.02)+vec2(uv.x+0.000,uv.y-0.002)).y;
+    col.b += 0.08*texture2D(u_texture,0.75*vec2(x+-0.02, -0.018)+vec2(uv.x-0.002,uv.y+0.000)).z;
+
+    col = clamp(col*0.6+0.4*col*col*1.0,0.0,1.0);
+
+    float vig = (0.0 + 1.0*16.0*uv.x*uv.y*(1.0-uv.x)*(1.0-uv.y));
+    col *= vec3(pow(vig,0.3));
+
+    col *= vec3(0.95,1.05,0.95);
+    col *= 2.8;
+
+    float scans = clamp( 0.35+0.35*sin(3.5*iTime+uv.y*iResolution.y*1.5), 0.0, 1.0);
+	
+	float s = pow(scans,1.7);
+	col = col*vec3( 0.4+0.7*s) ;
+
+    col *= 1.0+0.01*sin(110.0*iTime);
+	if (uv.x < 0.0 || uv.x > 1.0)
+		col *= 0.0;
+	if (uv.y < 0.0 || uv.y > 1.0)
+		col *= 0.0;
+	
+	col*=1.0-0.65*vec3(clamp((mod(gl_FragCoord.x, 2.0)-1.0)*2.0,0.0,1.0));
+	
+    float comp = smoothstep( 0.1, 0.9, sin(iTime) );
+ 
+	// Remove the next line to stop cross-fade between original and postprocess
+//	col = mix( col, oricol, comp );
+
+    gl_FragColor = vec4(col,1.0);
+}

package/build/dist/Graphics/Context/shaders/grayscale-fragment.glsl

@@ -0,0 +1,13 @@
+precision mediump float;
+
+// Passed in from the vertex shader.
+varying vec2 v_texcoord;
+
+// The texture.
+uniform sampler2D u_texture;
+
+void main() {
+  vec4 tex = texture2D(u_texture, vec2(v_texcoord.x, 1.0 - v_texcoord.y));
+  float avg = 0.2126 * tex.r + 0.7152 * tex.g + 0.0722 * tex.b;
+  gl_FragColor = vec4(avg, avg, avg, 1.0);
+}

package/build/dist/Graphics/Context/shaders/invert-fragment.glsl

@@ -0,0 +1,12 @@
+precision mediump float;
+
+// Passed in from the vertex shader.
+varying vec2 v_texcoord;
+
+// The texture.
+uniform sampler2D u_texture;
+
+void main() {
+  vec4 tex = texture2D(u_texture, vec2(v_texcoord.x, 1.0 - v_texcoord.y));
+  gl_FragColor = vec4(vec3(1.0, 1.0, 1.0) - tex.rgb, tex.a);
+}

package/build/dist/Graphics/Context/texture-loader.d.ts

@@ -1,13 +1,18 @@
+import { ImageFiltering } from '../Filtering';
 import { HTMLImageSource } from './ExcaliburGraphicsContext';
 /**
  * Manages loading image sources into webgl textures, a unique id is associated with all sources
  */
 export declare class TextureLoader {
+    /**
+     * Sets the default filtering for the Excalibur texture loader, default [[ImageFiltering.Blended]]
+     */
+    static filtering: ImageFiltering;
     private static _POT_CANVAS;
     private static _POT_CTX;
     private static _GL;
     private static _TEXTURE_MAP;
-    static registerContext(context: WebGLRenderingContext): void;
+    static register(context: WebGLRenderingContext): void;
     /**
      * Get the WebGL Texture from a source image
      * @param image
@@ -21,9 +26,10 @@ export declare class TextureLoader {
     /**
      * Loads a graphic into webgl and returns it's texture info, a webgl context must be previously registered
      * @param image Source graphic
+     * @param filtering {ImageFiltering} The ImageFiltering mode to apply to the loaded texture
      * @param forceUpdate Optionally force a texture to be reloaded, useful if the source graphic has changed
      */
-    static load(image: HTMLImageSource, forceUpdate?: boolean): WebGLTexture;
+    static load(image: HTMLImageSource, filtering?: ImageFiltering, forceUpdate?: boolean): WebGLTexture;
     /**
      * Converts source images into power of two images, WebGL only supports POT images
      * https://www.khronos.org/webgl/wiki/WebGL_and_OpenGL_Differences#Non-Power_of_Two_Texture_Support

package/build/dist/Graphics/Context/vertex-buffer.d.ts

@@ -0,0 +1,49 @@
+export interface VertexBufferOptions {
+    /**
+     * Size in number of floats, so [4.2, 4.0, 2.1] is size = 3
+     *
+     * Ignored if data is passed directly
+     */
+    size?: number;
+    /**
+     * If the vertices never change switching 'static' can be more efficient on the gpu
+     *
+     * Default is 'dynamic'
+     */
+    type?: 'static' | 'dynamic';
+    /**
+     * Optionally pass pre-seeded data, size parameter is ignored
+     */
+    data?: Float32Array;
+}
+/**
+ * Helper around vertex buffer to simplify creating and uploading geometry
+ *
+ * Under the hood uses Float32Array
+ */
+export declare class VertexBuffer {
+    private _gl;
+    /**
+     * Access to the webgl buffer handle
+     */
+    readonly buffer: WebGLBuffer;
+    /**
+     * Access to the raw data of the vertex buffer
+     */
+    readonly bufferData: Float32Array;
+    /**
+     * If the vertices never change switching 'static' can be more efficient on the gpu
+     *
+     * Default is 'dynamic'
+     */
+    type: 'static' | 'dynamic';
+    constructor(options: VertexBufferOptions);
+    /**
+     * Bind this vertex buffer
+     */
+    bind(): void;
+    /**
+     * Upload vertex buffer geometry to the GPU
+     */
+    upload(): void;
+}

package/build/dist/Graphics/Context/vertex-layout.d.ts

@@ -0,0 +1,52 @@
+import { Shader } from './shader';
+import { VertexBuffer } from './vertex-buffer';
+export interface VertexLayoutOptions {
+    /**
+     * Shader that this layout will be for
+     */
+    shader: Shader;
+    /**
+     * Vertex buffer to use for vertex data
+     */
+    vertexBuffer: VertexBuffer;
+    /**
+     * Specify the attributes that will exist in the vertex buffer
+     *
+     * **Important** must specify them in the order that they will be in the vertex buffer!!
+     */
+    attributes: [name: string, numberOfComponents: number][];
+}
+/**
+ * Helper around creating vertex attributes in a given [[VertexBuffer]], this is useful for describing
+ * the memory layout for your vertices inside a particular buffer
+ *
+ * Note: This helper assumes interleaved attributes in one [[VertexBuffer]], not many.
+ *
+ * Working with `gl.vertexAttribPointer` can be tricky, and this attempts to double check you
+ */
+export declare class VertexLayout {
+    private _gl;
+    private _logger;
+    private _shader;
+    private _layout;
+    private _attributes;
+    private _vertexBuffer;
+    get vertexBuffer(): VertexBuffer;
+    get attributes(): readonly [name: string, numberOfComponents: number][];
+    constructor(options: VertexLayoutOptions);
+    private _vertexTotalSizeBytes;
+    /**
+     * Total number of bytes that the vertex will take up
+     */
+    get totalVertexSizeBytes(): number;
+    /**
+     * Layouts need shader locations and must be bound to a shader
+     */
+    initialize(): void;
+    /**
+     * Bind this layout with it's associated vertex buffer
+     *
+     * @param uploadBuffer Optionally indicate you wish to upload the buffer to the GPU associated with this layout
+     */
+    use(uploadBuffer?: boolean): void;
+}

package/build/dist/Graphics/Context/webgl-adapter.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Must be accessed after Engine construction time to ensure the context has been created
+ */
+export declare class ExcaliburWebGLContextAccessor {
+    private static _GL;
+    static clear(): void;
+    static register(gl: WebGLRenderingContext): void;
+    static get gl(): WebGLRenderingContext;
+}

package/build/dist/Graphics/Context/webgl-util.d.ts

@@ -10,3 +10,25 @@ export declare function nextHighestPowerOfTwo(x: number): number;
  * Returns the input number if a power of two, otherwise the next highest power of two
  */
 export declare function ensurePowerOfTwo(x: number): number;
+/**
+ * Return the size of the GlType in bytes
+ * @param gl
+ * @param type
+ */
+export declare function getGlTypeSizeBytes(gl: WebGLRenderingContext, type: number): number;
+/**
+ * Based on the type return the number of attribute components
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer
+ * @param gl
+ * @param type
+ */
+export declare function getAttributeComponentSize(gl: WebGLRenderingContext, type: number): number;
+/**
+ * Based on the attribute return the corresponding supported attrib pointer type
+ * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer
+ *
+ * @param gl
+ * @param type
+ */
+export declare function getAttributePointerType(gl: WebGLRenderingContext, type: number): number;