Class Buffer

constructor

• new Buffer(
      engine: AbstractEngine,
      data: DataArray | DataBuffer,
      updatable: boolean,
      stride?: number,
      postponeInternalCreation?: boolean,
      instanced?: boolean,
      useBytes?: boolean,
      divisor?: number,
      label?: string,
  ): Buffer

  Constructor

  Parameters

  • engine: AbstractEngine

    the engine

  • data: DataArray | DataBuffer

    the data to use for this buffer

  • updatable: boolean

    whether the data is updatable

  • stride: number = 0

    the stride (optional)

  • postponeInternalCreation: boolean = false

    whether to postpone creating the internal WebGL buffer (optional)

  • instanced: boolean = false

    whether the buffer is instanced (optional)

  • useBytes: boolean = false

    set to true if the stride in in bytes (optional)

  • Optionaldivisor: number

    sets an optional divisor for instances (1 by default)

  • Optionallabel: string

    defines the label of the buffer (for debug purpose)

  Returns Buffer

ReadonlybyteStride

isDisposed

• get isDisposed(): boolean

  Gets a boolean indicating if the Buffer is disposed

  Returns boolean

create

• create(data?: Nullable<DataArray>): void

  Store data into the buffer. Creates the buffer if not used already. If the buffer was already used, it will be updated only if it is updatable, otherwise it will do nothing.

  Parameters

  • data: Nullable<DataArray> = null

    defines the data to store

  Returns void

createVertexBuffer

• createVertexBuffer(
      kind: string,
      offset: number,
      size: number,
      stride?: number,
      instanced?: boolean,
      useBytes?: boolean,
      divisor?: number,
  ): VertexBuffer

  Create a new VertexBuffer based on the current buffer

  Parameters

  • kind: string

    defines the vertex buffer kind (position, normal, etc.)

  • offset: number

    defines offset in the buffer (0 by default)

  • size: number

    defines the size in floats of attributes (position is 3 for instance)

  • Optionalstride: number

    defines the stride size in floats in the buffer (the offset to apply to reach next value when data is interleaved)

  • Optionalinstanced: boolean

    defines if the vertex buffer contains indexed data

  • useBytes: boolean = false

    defines if the offset and stride are in bytes *

  • Optionaldivisor: number

    sets an optional divisor for instances (1 by default)

  Returns VertexBuffer

  the new vertex buffer

dispose

• dispose(): void

  Release all resources

  Returns void

getBuffer

• getBuffer(): Nullable<DataBuffer>

  Gets underlying native buffer

  Returns Nullable<DataBuffer>

  underlying native buffer

getData

• getData(): Nullable<DataArray>

  Gets current buffer's data

  Returns Nullable<DataArray>

  a DataArray or null

getStrideSize

• getStrideSize(): number

  Gets the stride in float32 units (i.e. byte stride / 4). May not be an integer if the byte stride is not divisible by 4.

  Returns number

  the stride in float32 units

  Deprecated

  Please use byteStride instead.

isUpdatable

• isUpdatable(): boolean

  Gets a boolean indicating if the Buffer is updatable?

  Returns boolean

  true if the buffer is updatable

update

• update(data: DataArray): void

  Update current buffer data

  Parameters

  • data: DataArray

    defines the data to store

  Returns void

updateDirectly

• updateDirectly(
      data: DataArray,
      offset: number,
      vertexCount?: number,
      useBytes?: boolean,
  ): void

  Updates the data directly.

  Parameters

  • data: DataArray

    the new data

  • offset: number

    the new offset

  • OptionalvertexCount: number

    the vertex count (optional)

  • useBytes: boolean = false

    set to true if the offset is in bytes

  Returns void