Class QuadCompositor

_onCacheReset

attributes

currentSamplerUnit

currentShader

defaultShader

gl

mode

gl.TRIANGLES
Copy

projectionUniform

renderer

stride

useIndexBuffer

validatedShaders

vertexData

vertexSize

vertexState

viewMatrix

currentTextureUnit

• set currentTextureUnit(unit: number): void

  Parameters

  • unit: number

  Returns void

addAttribute

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

  add vertex attribute property definition to the batcher

  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

addIndices

• addIndices(indices: number[]): void

  Add index values to the index buffer (only for indexed batchers). Indices are rebased relative to the current vertex count.

  Parameters

  • indices: number[]

    array of index values to add

  Returns void

addQuad

• addQuad(
      texture: TextureAtlas,
      x: number,
      y: number,
      w: number,
      h: number,
      u0: number,
      v0: number,
      u1: number,
      v1: number,
      tint: number,
      reupload?: boolean,
  ): 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

  • Optionalreupload: boolean = false

    Force the texture to be reuploaded even if already bound

  Returns void

bind

• bind(): void

  called by the WebGL renderer when a batcher becomes the current one

  Returns void

bindTexture2D

• bindTexture2D(texture: WebGLTexture, unit: number, flush?: boolean): 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

  • flush: boolean = true

  Returns void

blitTexture

• blitTexture(
      source: WebGLTexture,
      x: number,
      y: number,
      width: number,
      height: number,
      shader: any,
  ): void

  Draw a screen-aligned quad with the given raw WebGL texture through the given shader. Binds the texture to unit 0, pushes 4 vertices (Y-flipped UVs), flushes, then unbinds the texture.

  Parameters

  • source: WebGLTexture

    the raw GL texture to blit

  • x: number

    destination x

  • y: number

    destination y

  • width: number

    destination width

  • height: number

    destination height

  • shader: any

    the shader effect to apply

  Returns void

createTexture2D

• createTexture2D(
      unit: number,
      pixels?:
          | ImageData
          | HTMLCanvasElement
          | (new (width?: number, height?: number) => HTMLImageElement)
          | Uint8Array<ArrayBufferLike>[]
          | Float32Array<ArrayBufferLike>[],
      filter: number,
      repeat?: string,
      w?: number,
      h?: number,
      premultipliedAlpha?: boolean,
      mipmap?: boolean,
      texture: any,
      flush?: boolean,
  ): WebGLTexture

  Create a WebGL texture from an image

  Parameters

  • unit: number

    Destination texture unit

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

    Source image

  • filter: number

    gl.LINEAR or gl.NEAREST

  • Optionalrepeat: string = "no-repeat"

    Image repeat behavior

  • Optionalw: number = pixels.width

    Source image width

  • Optionalh: number = pixels.height

    Source image height

  • OptionalpremultipliedAlpha: boolean = true

    Multiplies the alpha channel into the other color channels

  • Optionalmipmap: boolean = true

    Whether mipmap levels should be generated

  • texture: any
  • flush: boolean = true

  Returns WebGLTexture

  a WebGL texture

deleteTexture2D

• deleteTexture2D(texture: WebGLTexture | TextureAtlas): void

  delete the given WebGL texture

  Parameters

  • texture: WebGLTexture | TextureAtlas

    a WebGL texture or TextureAtlas to delete

  Returns void

flush

• flush(mode?: number): void

  Flush batched texture data to the GPU using indexed drawing.

  Parameters

  • Optionalmode: number = ...

    the GL drawing mode

  Returns void

getTexture2D

• getTexture2D(unit: number): 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: Matrix3d): void

  set/change the current projection matrix

  Parameters

  • matrix: Matrix3d

    the new projection matrix

  Returns void

unbind

• unbind(): void

  called by the WebGL renderer when this batcher is being replaced by another. Attribute state no longer needs disabling — it lives in this batcher's vertex-state object and the incoming batcher's bind() replaces the binding wholesale. Kept as a lifecycle hook: subclasses override it to restore mode-specific GL state (see MeshBatcher's blend/depth restore).

  Returns void

unbindTexture2D

• unbindTexture2D(texture?: WebGLTexture, unit?: number): number

  unbind the given WebGL texture, forcing it to be reuploaded

  Parameters

  • Optionaltexture: WebGLTexture

    a WebGL texture

  • Optionalunit: number

    Texture unit to unbind from

  Returns number

  unit the unit number that was associated with the given texture

useShader

• useShader(shader: any): void

  Select the shader to use for compositing. Multi-texture batching is automatically enabled when the default shader is active, and disabled for custom ShaderEffect shaders.

  Parameters

  • shader: any

    a reference to a GLShader or ShaderEffect instance

  Returns void

  See

  • GLShader
  • ShaderEffect