Stores per-geometry attributes such as base addresses for vertex, index, and edge index data.

Two texels per geometry, eight u32 slots total:

  • texel 0: (verticesBase, indicesBase, edgeIndicesBase, normalsBase)
  • texel 1: (uvsBase, polylineCumDistBase, reserved, reserved)

Each *Base is 0 when the corresponding attribute isn't allocated for that geometry; the shader only reads a slot when its containing batch was compiled with the matching variant flag (hasNormals, hasUVs, etc.) — so the zero is harmless.

Directly uploads each item into the texture.

Hierarchy (View Summary)

Constructors

Properties

buffer: any

CPU-side backing buffer used to populate this texture.

The concrete type depends on the implementation (e.g., Uint32Array, Float32Array, or a view over an ArrayBuffer). This buffer is uploaded to the GPU when updated.

bufferClass: any

The ArrayBufferView class used for the CPU-side buffer.

bytesPerTexel: number

Size in bytes of a single texel in the data texture.

debugging: boolean = true

Enables internal event emission for this data texture.

description: string = ""

Human-readable description of the data stored in this texture.

Intended for debugging UIs and diagnostics (e.g., displayed above inspectors). Subclasses or owners should populate this with a concise explanation of the layout and semantic meaning (e.g., “mesh matrices (Mat4, row-major), indexed by meshId”).

elementsPerItem: number

Number of individual elements (e.g., floats, uint32s) stored per logical item in this data texture.

elementsPerTexel: number

Number of individual elements (e.g., floats, uint32s) stored per texel in the data texture.

format: number

Texture format (e.g., gl.RGBA, gl.RGBA_INTEGER).

gl: WebGL2RenderingContext

The WebGL2 rendering context.

height: number

Texture height in texels.

internalFormat: number

Texture internal format (e.g., gl.RGBA8, gl.RGBA32UI, gl.RGBA32F).

itemSizeInBytes: number

Size in bytes of a single logical item stored in the data texture.

lastUploadTimeMS: number = 0

Duration (in milliseconds) of the last upload to GPU.

This value is 0 until the first upload occurs.

maxItems: number

Maximum number of logical items that can be stored in this texture.

The value of numItems never exceeds this limit.

onUpdated: EventEmitter<DataTexture, undefined> = ...

Emitted when the CPU-side buffer for this texture has changed and been uploaded to the GPU.

This event is intended for debugging tools and monitoring UIs; it is only emitted when debugging is enabled.

texelsPerItem: number

Number of texels occupied by a single logical item in the data texture.

texture: WebGLTexture

The underlying WebGL texture object.

This is the GPU resource that is bound and sampled/loaded by shaders.

type: number

Texture data type (e.g., gl.UNSIGNED_BYTE, gl.UNSIGNED_INT, gl.FLOAT).

useBuffer: boolean

Whether to use a CPU-side buffer for staging data before uploading to the GPU.

width: number

Texture width in texels.

itemSizeInBytes: 32

Accessors

Methods

  • Sets the attribute data for a specific geometry item.

    Slot layout (linearised — base is itemIndex * elementsPerItem):

    • base + 0 verticesBase
    • base + 1 indicesBase
    • base + 2 edgeIndicesBase
    • base + 3 normalsBase
    • base + 4 uvsBase
    • base + 5 polylineCumDistBase — base offset into the per-batch "./PolylineCumDistTexture".PolylineCumDistTexture for the geometry's per-segment cumulative-model-distance values. 0 for non-LinesPrimitive geometries (and for line geometries whose batch never allocated a polyline-cum-dist texture).
    • base + 6..7 reserved

    Parameters

    • itemIndex: number
    • item: {
          edgeIndicesBase?: number;
          indicesBase?: number;
          normalsBase?: number;
          polylineCumDistBase?: number;
          uvsBase?: number;
          verticesBase?: number;
      }

    Returns void

  • Uploads all dirty items to the GPU as efficiently as possible.

    Internal algorithm:

    • Dirty items are indices of items whose data has changed and needs to be uploaded to the GPU.
    • The method sorts all dirty indices and finds contiguous runs (sequences of adjacent indices).
    • For each run, it uploads the run in chunks, where each chunk fits within a row of the texture.
    • This minimizes the number of WebGL texSubImage2D calls by uploading as large a block as possible per call.
    • After all dirty items are uploaded, the dirty set is cleared, the texture is unbound, and update notifications are sent.

    Returns boolean

    True if any uploads occurred, false otherwise.