import { BUFFER_TYPE } from '@pixi/constants'; import { Runner } from '@pixi/runner'; import type { GLBuffer } from './GLBuffer'; let UID = 0; /* eslint-disable max-len */ /** * Marks places in PixiJS where you can pass Float32Array, UInt32Array, any typed arrays, and ArrayBuffer * * Same as ArrayBuffer in typescript lib, defined here just for documentation */ // eslint-disable-next-line @typescript-eslint/no-empty-interface export interface IArrayBuffer extends ArrayBuffer { } /** * PixiJS classes use this type instead of ArrayBuffer and typed arrays * to support expressions like `geometry.buffers[0].data[0] = position.x`. * * Gives access to indexing and `length` field * * @popelyshev: If data is actually ArrayBuffer and throws Exception on indexing - its user problem :) */ export interface ITypedArray extends IArrayBuffer { readonly length: number; [index: number]: number; readonly BYTES_PER_ELEMENT: number; } /** * A wrapper for data so that it can be used and uploaded by WebGL * @memberof PIXI */ export class Buffer { /** * The data in the buffer, as a typed array * @type {PIXI.IArrayBuffer} */ public data: ITypedArray; /** * The type of buffer this is, one of: * + ELEMENT_ARRAY_BUFFER - used as an index buffer * + ARRAY_BUFFER - used as an attribute buffer * + UNIFORM_BUFFER - used as a uniform buffer (if available) */ public type: BUFFER_TYPE; public static: boolean; public id: number; disposeRunner: Runner; /** * A map of renderer IDs to webgl buffer * @private * @type {Object} */ _glBuffers: {[key: number]: GLBuffer}; _updateID: number; /** * @param {PIXI.IArrayBuffer} data - the data to store in the buffer. * @param _static - `true` for static buffer * @param index - `true` for index buffer */ constructor(data?: IArrayBuffer, _static = true, index = false) { this.data = (data || new Float32Array(1)) as ITypedArray; this._glBuffers = {}; this._updateID = 0; this.index = index; this.static = _static; this.id = UID++; this.disposeRunner = new Runner('disposeBuffer'); } // TODO could explore flagging only a partial upload? /** * Flags this buffer as requiring an upload to the GPU. * @param {PIXI.IArrayBuffer|number[]} [data] - the data to update in the buffer. */ update(data?: IArrayBuffer | Array): void { if (data instanceof Array) { data = new Float32Array(data); } this.data = (data as ITypedArray) || this.data; this._updateID++; } /** Disposes WebGL resources that are connected to this geometry. */ dispose(): void { this.disposeRunner.emit(this, false); } /** Destroys the buffer. */ destroy(): void { this.dispose(); this.data = null; } /** * Flags whether this is an index buffer. * * Index buffers are of type `ELEMENT_ARRAY_BUFFER`. Note that setting this property to false will make * the buffer of type `ARRAY_BUFFER`. * * For backwards compatibility. */ set index(value: boolean) { this.type = value ? BUFFER_TYPE.ELEMENT_ARRAY_BUFFER : BUFFER_TYPE.ARRAY_BUFFER; } get index(): boolean { return this.type === BUFFER_TYPE.ELEMENT_ARRAY_BUFFER; } /** * Helper function that creates a buffer based on an array or TypedArray * @param {ArrayBufferView | number[]} data - the TypedArray that the buffer will store. If this is a regular Array it will be converted to a Float32Array. * @returns - A new Buffer based on the data provided. */ static from(data: IArrayBuffer | number[]): Buffer { if (data instanceof Array) { data = new Float32Array(data); } return new Buffer(data); } }