Class QuadCompositor

constructor

• new QuadCompositor(renderer, settings): QuadCompositor

• Parameters

  • renderer: WebGLRenderer

    the current WebGL renderer session

  • settings: {
    attribute: {
    name: string;
    normalized: boolean;
    offset: number;
    size: number;
    type: number;
    }[];
    shader: {
    fragment: string;
    vertex: string;
    };
    }

    additional settings to initialize this compositors

    • attribute: {
      name: string;
      normalized: boolean;
      offset: number;
      size: number;
      type: number;
      }[]

      an array of attributes definition

    • shader: {
      fragment: string;
      vertex: string;
      }

      an array of attributes definition

      • fragment: string

      • vertex: string

  Returns QuadCompositor

attributes

boundTextures

color

currentShader

currentTextureUnit

defaultShader

gl

mode

gl.TRIANGLES
Copy

renderer

vertexByteSize

vertexData

vertexSize

viewMatrix

addAttribute

• addAttribute(name, size, type, normalized, offset): void

• add vertex attribute property definition to the compositor

  Parameters

  • name: string

    name of the attribute in the vertex shader

  • size: number

    number of components per vertex attribute. Must be 1, 2, 3, or 4.

  • type: number

    data type of each component in the array

  • normalized: boolean

    whether integer data values should be normalized into a certain range when being cast to a float

  • offset: number

    offset in bytes of the first component in the vertex attribute array

  Returns void

addQuad

• addQuad(texture, x, y, w, h, u0, v0, u1, v1, tint, reupload?): void

• Add a textured quad

  Parameters

  • texture: TextureAtlas

    Source texture atlas

  • x: number

    Destination x-coordinate

  • y: number

    Destination y-coordinate

  • w: number

    Destination width

  • h: number

    Destination height

  • u0: number

    Texture UV (u0) value.

  • v0: number

    Texture UV (v0) value.

  • u1: number

    Texture UV (u1) value.

  • v1: number

    Texture UV (v1) value.

  • tint: number

    tint color to be applied to the texture in UINT32 (argb) format

  • reupload: boolean = false

    Force the texture to be reuploaded even if already bound

  Returns void

bind

• bind(): void

• called by the WebGL renderer when a compositor become the current one

  Returns void

bindTexture2D

• bindTexture2D(texture, unit): void

• assign the given WebGL texture to the current batch

  Parameters

  • texture: WebGLTexture

    a WebGL texture

  • unit: number

    Texture unit to which the given texture is bound

  Returns void

createTexture2D

• createTexture2D(unit, pixels?, filter, repeat?, w?, h?, premultipliedAlpha?, mipmap?, texture): WebGLTexture

• Create a WebGL texture from an image

  Parameters

  • unit: number

    Destination texture unit

  • Optionalpixels:
    | HTMLCanvasElement
    | ImageData
    | (new (width?: number, height?: number) => HTMLImageElement )
    | Uint8Array[]
    | Float32Array[] = null

    Source image

  • filter: number

    gl.LINEAR or gl.NEAREST

  • Optionalrepeat: string = "no-repeat"

    Image repeat behavior (see ImageLayer#repeat)

  • Optionalw: number = pixels.width

    Source image width (Only use with UInt8Array[] or Float32Array[] source image)

  • Optionalh: number = pixels.height

    Source image height (Only use with UInt8Array[] or Float32Array[] source image)

  • OptionalpremultipliedAlpha: boolean = true

    Multiplies the alpha channel into the other color channels

  • Optionalmipmap: boolean = true

    Whether mipmap levels should be generated for this texture

  • texture: any

  Returns WebGLTexture

  a WebGL texture

deleteTexture2D

• deleteTexture2D(texture?): void

• delete the given WebGL texture

  Parameters

  • Optionaltexture: WebGLTexture

    a WebGL texture to delete

  Returns void

flush

• flush(mode?): void

• Flush batched vertex data to the GPU

  Parameters

  • Optionalmode: number = ...

    the GL drawing mode

  Returns void

getTexture2D

• getTexture2D(unit): WebGLTexture

• returns the WebGL texture associated to the given texture unit

  Parameters

  • unit: number

    Texture unit to which a texture is bound

  Returns WebGLTexture

  texture a WebGL texture

setProjection

• setProjection(matrix): void

• set/change the current projection matrix

  Parameters

  • matrix: Matrix3d

    the new projection matrix

  Returns void

unbindTexture2D

• unbindTexture2D(texture?, unit?): number

• unbind the given WebGL texture, forcing it to be reuploaded

  Parameters

  • Optionaltexture: WebGLTexture

    a WebGL texture

  • Optionalunit: number

    a WebGL texture

  Returns number

  unit the unit number that was associated with the given texture

useShader

• useShader(shader): void

• Select the shader to use for compositing

  Parameters

  • shader: GLShader

    a reference to a GLShader instance

  Returns void

  See

  GLShader