@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.10

package/dist/adapter/resources/webgl-transform-feedback.d.ts

@@ -0,0 +1,47 @@
+import type { PrimitiveTopology, ShaderLayout, TransformFeedbackProps } from '@luma.gl/core';
+import { TransformFeedback, Buffer, BufferRange } from '@luma.gl/core';
+import { WebGLDevice } from "../webgl-device.js";
+export declare class WEBGLTransformFeedback extends TransformFeedback {
+    readonly device: WebGLDevice;
+    readonly gl: WebGL2RenderingContext;
+    readonly handle: WebGLTransformFeedback;
+    /**
+     * NOTE: The Model already has this information while drawing, but
+     * TransformFeedback currently needs it internally, to look up
+     * varying information outside of a draw() call.
+     */
+    readonly layout: ShaderLayout;
+    buffers: Record<string, BufferRange>;
+    unusedBuffers: Record<string, Buffer>;
+    /**
+     * Allows us to avoid a Chrome bug where a buffer that is already bound to a
+     * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+     * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346
+     */
+    bindOnUse: boolean;
+    private _bound;
+    constructor(device: WebGLDevice, props: TransformFeedbackProps);
+    destroy(): void;
+    begin(topology?: PrimitiveTopology): void;
+    end(): void;
+    setBuffers(buffers: Record<string, Buffer | BufferRange>): void;
+    setBuffer(locationOrName: string | number, bufferOrRange: Buffer | BufferRange): void;
+    getBuffer(locationOrName: string | number): Buffer | BufferRange | null;
+    bind(funcOrHandle?: WebGLTransformFeedback): unknown;
+    unbind(): void;
+    /** Extract offsets for bindBufferRange */
+    protected _getBufferRange(bufferOrRange: Buffer | {
+        buffer: Buffer;
+        byteOffset?: number;
+        byteLength?: number;
+    }): Required<BufferRange>;
+    protected _getVaryingIndex(locationOrName: string | number): number;
+    /**
+     * Need to avoid chrome bug where buffer that is already bound to a different target
+     * cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+     */
+    protected _bindBuffers(): void;
+    protected _unbindBuffers(): void;
+    protected _bindBuffer(index: number, buffer: Buffer, byteOffset?: number, byteLength?: number): void;
+}
+//# sourceMappingURL=webgl-transform-feedback.d.ts.map

package/dist/adapter/resources/webgl-transform-feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-transform-feedback.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-transform-feedback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAE,YAAY,EAAE,sBAAsB,EAAC,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAM,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1E,OAAO,EAAC,WAAW,EAAC,2BAAwB;AAI5C,qBAAa,sBAAuB,SAAQ,iBAAiB;IAC3D,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,EAAE,EAAE,sBAAsB,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IAExC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAM;IAC1C,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IAC3C;;;;OAIG;IACH,SAAS,UAAQ;IACjB,OAAO,CAAC,MAAM,CAAkB;gBAEpB,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,sBAAsB;IAerD,OAAO,IAAI,IAAI;IAKxB,KAAK,CAAC,QAAQ,GAAE,iBAAgC,GAAG,IAAI;IAQvD,GAAG,IAAI,IAAI;IAUX,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC,GAAG,IAAI;IAW/D,SAAS,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAmBrF,SAAS,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,IAAI;IAQvE,IAAI,CAAC,YAAY,yBAAc;IAqB/B,MAAM;IAMN,0CAA0C;IAC1C,SAAS,CAAC,eAAe,CACvB,aAAa,EAAE,MAAM,GAAG;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAC,GACjF,QAAQ,CAAC,WAAW,CAAC;IAWxB,SAAS,CAAC,gBAAgB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;IAcnE;;;OAGG;IACH,SAAS,CAAC,YAAY,IAAI,IAAI;IAO9B,SAAS,CAAC,cAAc,IAAI,IAAI;IAMhC,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,SAAI,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;CAQhG"}

package/dist/adapter/resources/webgl-transform-feedback.js

@@ -0,0 +1,162 @@
+import { log, TransformFeedback } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
+import { WEBGLBuffer } from "../../index.js";
+import { getGLPrimitive } from "../helpers/webgl-topology-utils.js";
+export class WEBGLTransformFeedback extends TransformFeedback {
+    device;
+    gl;
+    handle;
+    /**
+     * NOTE: The Model already has this information while drawing, but
+     * TransformFeedback currently needs it internally, to look up
+     * varying information outside of a draw() call.
+     */
+    layout;
+    buffers = {};
+    unusedBuffers = {};
+    /**
+     * Allows us to avoid a Chrome bug where a buffer that is already bound to a
+     * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+     * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346
+     */
+    bindOnUse = true;
+    _bound = false;
+    constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        this.gl = device.gl;
+        this.handle = this.props.handle || this.gl.createTransformFeedback();
+        this.layout = this.props.layout;
+        if (props.buffers) {
+            this.setBuffers(props.buffers);
+        }
+        Object.seal(this);
+    }
+    destroy() {
+        this.gl.deleteTransformFeedback(this.handle);
+        super.destroy();
+    }
+    begin(topology = 'point-list') {
+        this.gl.bindTransformFeedback(36386, this.handle);
+        if (this.bindOnUse) {
+            this._bindBuffers();
+        }
+        this.gl.beginTransformFeedback(getGLPrimitive(topology));
+    }
+    end() {
+        this.gl.endTransformFeedback();
+        if (!this.bindOnUse) {
+            this._unbindBuffers();
+        }
+        this.gl.bindTransformFeedback(36386, null);
+    }
+    // SUBCLASS
+    setBuffers(buffers) {
+        this.buffers = {};
+        this.unusedBuffers = {};
+        this.bind(() => {
+            for (const bufferName in buffers) {
+                this.setBuffer(bufferName, buffers[bufferName]);
+            }
+        });
+    }
+    setBuffer(locationOrName, bufferOrRange) {
+        const location = this._getVaryingIndex(locationOrName);
+        const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
+        if (location < 0) {
+            this.unusedBuffers[locationOrName] = buffer;
+            log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+            return;
+        }
+        this.buffers[location] = { buffer, byteLength, byteOffset };
+        // Need to avoid chrome bug where buffer that is already bound to a different target
+        // cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+        if (!this.bindOnUse) {
+            this._bindBuffer(location, buffer, byteOffset, byteLength);
+        }
+    }
+    getBuffer(locationOrName) {
+        if (isIndex(locationOrName)) {
+            return this.buffers[locationOrName] || null;
+        }
+        const location = this._getVaryingIndex(locationOrName);
+        return location >= 0 ? this.buffers[location] : null;
+    }
+    bind(funcOrHandle = this.handle) {
+        if (typeof funcOrHandle !== 'function') {
+            this.gl.bindTransformFeedback(36386, funcOrHandle);
+            return this;
+        }
+        let value;
+        if (!this._bound) {
+            this.gl.bindTransformFeedback(36386, this.handle);
+            this._bound = true;
+            value = funcOrHandle();
+            this._bound = false;
+            this.gl.bindTransformFeedback(36386, null);
+        }
+        else {
+            value = funcOrHandle();
+        }
+        return value;
+    }
+    unbind() {
+        this.bind(null);
+    }
+    // PRIVATE METHODS
+    /** Extract offsets for bindBufferRange */
+    _getBufferRange(bufferOrRange) {
+        if (bufferOrRange instanceof WEBGLBuffer) {
+            return { buffer: bufferOrRange, byteOffset: 0, byteLength: bufferOrRange.byteLength };
+        }
+        // To use bindBufferRange either offset or size must be specified.
+        // @ts-expect-error Must be a BufferRange.
+        const { buffer, byteOffset = 0, byteLength = bufferOrRange.buffer.byteLength } = bufferOrRange;
+        return { buffer, byteOffset, byteLength };
+    }
+    _getVaryingIndex(locationOrName) {
+        if (isIndex(locationOrName)) {
+            return Number(locationOrName);
+        }
+        for (const varying of this.layout.varyings) {
+            if (locationOrName === varying.name) {
+                return varying.location;
+            }
+        }
+        return -1;
+    }
+    /**
+     * Need to avoid chrome bug where buffer that is already bound to a different target
+     * cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
+     */
+    _bindBuffers() {
+        for (const bufferIndex in this.buffers) {
+            const { buffer, byteLength, byteOffset } = this._getBufferRange(this.buffers[bufferIndex]);
+            this._bindBuffer(Number(bufferIndex), buffer, byteOffset, byteLength);
+        }
+    }
+    _unbindBuffers() {
+        for (const bufferIndex in this.buffers) {
+            this.gl.bindBufferBase(35982, Number(bufferIndex), null);
+        }
+    }
+    _bindBuffer(index, buffer, byteOffset = 0, byteLength) {
+        const handle = buffer && buffer.handle;
+        if (!handle || byteLength === undefined) {
+            this.gl.bindBufferBase(35982, index, handle);
+        }
+        else {
+            this.gl.bindBufferRange(35982, index, handle, byteOffset, byteLength);
+        }
+    }
+}
+/**
+ * Returns true if the given value is an integer, or a string that
+ * trivially converts to an integer (only numeric characters).
+ */
+function isIndex(value) {
+    if (typeof value === 'number') {
+        return Number.isInteger(value);
+    }
+    return /^\d+$/.test(value);
+}

package/dist/adapter/resources/webgl-vertex-array.d.ts

@@ -0,0 +1,67 @@
+import type { Device, Buffer, VertexArrayProps, TypedArray } from '@luma.gl/core';
+import { VertexArray } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
+import { WebGLDevice } from "../webgl-device.js";
+/** VertexArrayObject wrapper */
+export declare class WEBGLVertexArray extends VertexArray {
+    get [Symbol.toStringTag](): string;
+    readonly device: WebGLDevice;
+    readonly handle: WebGLVertexArrayObject;
+    /** Attribute 0 buffer constant */
+    private buffer;
+    private bufferValue;
+    /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
+    static isConstantAttributeZeroSupported(device: Device): boolean;
+    constructor(device: WebGLDevice, props?: VertexArrayProps);
+    destroy(): void;
+    /**
+    // Set (bind/unbind) an elements buffer, for indexed rendering.
+    // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER or null. Constants not supported
+     *
+     * @param elementBuffer
+     */
+    setIndexBuffer(indexBuffer: Buffer | null): void;
+    /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
+    setBuffer(location: number, attributeBuffer: Buffer): void;
+    /** Set a location in vertex attributes array to a constant value, disables the location */
+    setConstantWebGL(location: number, value: TypedArray): void;
+    init: boolean;
+    bindBeforeRender(): void;
+    unbindAfterRender(): void;
+    /**
+     * Constant attributes need to be reset before every draw call
+     * Any attribute that is disabled in the current vertex array object
+     * is read from the context's global constant value for that attribute location.
+     * @note Constant attributes are only supported in WebGL, not in WebGPU
+     */
+    protected _applyConstantAttributes(): void;
+    /**
+     * Set a location in vertex attributes array to a buffer, enables the location, sets divisor
+     * @note requires vertex array to be bound
+     */
+    /** Get an accessor from the  */
+    protected _getAccessor(location: number): {
+        size: 4 | 1 | 2 | 3;
+        type: GL.BYTE | GL.UNSIGNED_BYTE | GL.SHORT | GL.UNSIGNED_SHORT | GL.INT | GL.UNSIGNED_INT | GL.FLOAT | GL.HALF_FLOAT;
+        stride: number;
+        offset: number;
+        normalized: boolean;
+        integer: boolean;
+        divisor: number;
+    };
+    /**
+     * Enabling an attribute location makes it reference the currently bound buffer
+     * Disabling an attribute location makes it reference the global constant value
+     * TODO - handle single values for size 1 attributes?
+     * TODO - convert classic arrays based on known type?
+     */
+    protected _enable(location: number, enable?: boolean): void;
+    /**
+     * Provide a means to create a buffer that is equivalent to a constant.
+     * NOTE: Desktop OpenGL cannot disable attribute 0.
+     * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-
+     * this-has-significant-performance-penalty
+     */
+    getConstantBuffer(elementCount: number, value: TypedArray): Buffer;
+}
+//# sourceMappingURL=webgl-vertex-array.d.ts.map

package/dist/adapter/resources/webgl-vertex-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-vertex-array.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-vertex-array.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAc,MAAM,eAAe,CAAC;AAC7F,OAAO,EAAC,WAAW,EAA6B,MAAM,eAAe,CAAC;AACtE,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AAGtC,OAAO,EAAC,WAAW,EAAC,2BAAwB;AAO5C,gCAAgC;AAChC,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,IAAa,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAE1C;IAED,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IAExC,kCAAkC;IAClC,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,WAAW,CAAQ;IAE3B,6EAA6E;IAC7E,MAAM,CAAC,gCAAgC,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;gBAKpD,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,gBAAgB;IAMhD,OAAO,IAAI,IAAI;IAexB;;;;;OAKG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAgBhD,gGAAgG;IAChG,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI;IA6B1D,2FAA2F;IAClF,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI;IAKpE,IAAI,UAAS;IAEJ,gBAAgB,IAAI,IAAI;IAYxB,iBAAiB,IAAI,IAAI;IAUlC;;;;;OAKG;IACH,SAAS,CAAC,wBAAwB,IAAI,IAAI;IAU1C;;;OAGG;IAcH,gCAAgC;IAChC,SAAS,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;IAsBvC;;;;;OAKG;IACH,SAAS,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,UAAO,GAAG,IAAI;IAiBxD;;;;;OAKG;IACH,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM;CA8BnE"}

package/dist/adapter/resources/webgl-vertex-array.js

@@ -0,0 +1,239 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { VertexArray, getScratchArray, fillArray } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
+import { getBrowser } from '@probe.gl/env';
+import { getGLFromVertexType } from "../converters/vertex-formats.js";
+// import {AccessorObject} from '../..';
+// import {getGLFromVertexType} from '../converters/vertex-formats';
+/** VertexArrayObject wrapper */
+export class WEBGLVertexArray extends VertexArray {
+    get [Symbol.toStringTag]() {
+        return 'VertexArray';
+    }
+    device;
+    handle;
+    /** Attribute 0 buffer constant */
+    buffer = null;
+    bufferValue = null;
+    /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
+    static isConstantAttributeZeroSupported(device) {
+        return getBrowser() === 'Chrome';
+    }
+    // Create a VertexArray
+    constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        this.handle = this.device.gl.createVertexArray();
+    }
+    destroy() {
+        super.destroy();
+        if (this.buffer) {
+            this.buffer?.destroy();
+        }
+        if (this.handle) {
+            this.device.gl.deleteVertexArray(this.handle);
+            // @ts-expect-error read-only/undefined
+            this.handle = undefined;
+        }
+        // Auto-delete elements?
+        // return [this.elements];
+    }
+    /**
+    // Set (bind/unbind) an elements buffer, for indexed rendering.
+    // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER or null. Constants not supported
+     *
+     * @param elementBuffer
+     */
+    setIndexBuffer(indexBuffer) {
+        const buffer = indexBuffer;
+        // Explicitly allow `null` to support clearing the index buffer
+        if (buffer && buffer.glTarget !== 34963) {
+            throw new Error('Use .setBuffer()');
+        }
+        // In WebGL The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject
+        this.device.gl.bindVertexArray(this.handle);
+        // TODO - this initial binding does not seem to take effect? see bindBeforeRender()
+        this.device.gl.bindBuffer(34963, buffer ? buffer.handle : null);
+        // log.log(1, 'VertexArray.setIndexBuffer', indexBuffer)();
+        // log.log(1, `Binding vertex array ${this.id}`, buffer?.id)();
+        this.indexBuffer = buffer;
+    }
+    /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
+    setBuffer(location, attributeBuffer) {
+        const buffer = attributeBuffer;
+        // Sanity check target
+        if (buffer.glTarget === 34963) {
+            throw new Error('Use .setIndexBuffer()');
+        }
+        const { size, type, stride, offset, normalized, integer, divisor } = this._getAccessor(location);
+        this.device.gl.bindVertexArray(this.handle);
+        // A non-zero buffer object must be bound to the GL_ARRAY_BUFFER target
+        this.device.gl.bindBuffer(34962, buffer.handle);
+        // WebGL2 supports *integer* data formats, i.e. GPU will see integer values
+        if (integer) {
+            this.device.gl.vertexAttribIPointer(location, size, type, stride, offset);
+        }
+        else {
+            // Attaches ARRAY_BUFFER with specified buffer format to location
+            this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+        }
+        // Mark as non-constant
+        this.device.gl.enableVertexAttribArray(location);
+        // Set the step mode 0=vertex, 1=instance
+        this.device.gl.vertexAttribDivisor(location, divisor || 0);
+        this.attributes[location] = buffer;
+    }
+    /** Set a location in vertex attributes array to a constant value, disables the location */
+    setConstantWebGL(location, value) {
+        this._enable(location, false);
+        this.attributes[location] = value;
+    }
+    init = false;
+    bindBeforeRender() {
+        this.device.gl.bindVertexArray(this.handle);
+        // TODO - the initial bind does not seem to take effect.
+        if (!this.init) {
+            // log.log(1, `Binding vertex array ${this.id}`, this.indexBuffer?.id)();
+            const webglBuffer = this.indexBuffer;
+            this.device.gl.bindBuffer(34963, webglBuffer?.handle || null);
+            this.init = true;
+        }
+        this._applyConstantAttributes();
+    }
+    unbindAfterRender() {
+        // log.log(1, `Unbinding vertex array ${this.id}`)();
+        // TODO technically this is not necessary, but we might be interfacing
+        // with code that does not use vertex array objects
+        this.device.gl.bindVertexArray(null);
+        // this.device.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, null);
+    }
+    // Internal methods
+    /**
+     * Constant attributes need to be reset before every draw call
+     * Any attribute that is disabled in the current vertex array object
+     * is read from the context's global constant value for that attribute location.
+     * @note Constant attributes are only supported in WebGL, not in WebGPU
+     */
+    _applyConstantAttributes() {
+        for (let location = 0; location < this.maxVertexAttributes; ++location) {
+            const constant = this.attributes[location];
+            // A typed array means this is a constant
+            if (ArrayBuffer.isView(constant)) {
+                this.device.setConstantAttributeWebGL(location, constant);
+            }
+        }
+    }
+    /**
+     * Set a location in vertex attributes array to a buffer, enables the location, sets divisor
+     * @note requires vertex array to be bound
+     */
+    // protected _setAttributeLayout(location: number): void {
+    //   const {size, type, stride, offset, normalized, integer, divisor} = this._getAccessor(location);
+    //   // WebGL2 supports *integer* data formats, i.e. GPU will see integer values
+    //   if (integer) {
+    //     this.device.gl.vertexAttribIPointer(location, size, type, stride, offset);
+    //   } else {
+    //     // Attaches ARRAY_BUFFER with specified buffer format to location
+    //     this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+    //   }
+    //   this.device.gl.vertexAttribDivisor(location, divisor || 0);
+    // }
+    /** Get an accessor from the  */
+    _getAccessor(location) {
+        const attributeInfo = this.attributeInfos[location];
+        if (!attributeInfo) {
+            throw new Error(`Unknown attribute location ${location}`);
+        }
+        const glType = getGLFromVertexType(attributeInfo.bufferDataType);
+        return {
+            size: attributeInfo.bufferComponents,
+            type: glType,
+            stride: attributeInfo.byteStride,
+            offset: attributeInfo.byteOffset,
+            normalized: attributeInfo.normalized,
+            // it is the shader attribute declaration, not the vertex memory format,
+            // that determines if the data in the buffer will be treated as integers.
+            //
+            // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
+            // but as far as we can tell, WebGPU does not.
+            integer: attributeInfo.integer,
+            divisor: attributeInfo.stepMode === 'instance' ? 1 : 0
+        };
+    }
+    /**
+     * Enabling an attribute location makes it reference the currently bound buffer
+     * Disabling an attribute location makes it reference the global constant value
+     * TODO - handle single values for size 1 attributes?
+     * TODO - convert classic arrays based on known type?
+     */
+    _enable(location, enable = true) {
+        // Attribute 0 cannot be disabled in most desktop OpenGL based browsers...
+        const canDisableAttributeZero = WEBGLVertexArray.isConstantAttributeZeroSupported(this.device);
+        const canDisableAttribute = canDisableAttributeZero || location !== 0;
+        if (enable || canDisableAttribute) {
+            location = Number(location);
+            this.device.gl.bindVertexArray(this.handle);
+            if (enable) {
+                this.device.gl.enableVertexAttribArray(location);
+            }
+            else {
+                this.device.gl.disableVertexAttribArray(location);
+            }
+            this.device.gl.bindVertexArray(null);
+        }
+    }
+    /**
+     * Provide a means to create a buffer that is equivalent to a constant.
+     * NOTE: Desktop OpenGL cannot disable attribute 0.
+     * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-
+     * this-has-significant-performance-penalty
+     */
+    getConstantBuffer(elementCount, value) {
+        // Create buffer only when needed, and reuse it (avoids inflating buffer creation statistics)
+        const constantValue = normalizeConstantArrayValue(value);
+        const byteLength = constantValue.byteLength * elementCount;
+        const length = constantValue.length * elementCount;
+        if (this.buffer && byteLength !== this.buffer.byteLength) {
+            throw new Error(`Buffer size is immutable, byte length ${byteLength} !== ${this.buffer.byteLength}.`);
+        }
+        let updateNeeded = !this.buffer;
+        this.buffer = this.buffer || this.device.createBuffer({ byteLength });
+        // Reallocate and update contents if needed
+        updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
+        if (updateNeeded) {
+            // Create a typed array that is big enough, and fill it with the required data
+            const typedArray = getScratchArray(value.constructor, length);
+            fillArray({ target: typedArray, source: constantValue, start: 0, count: length });
+            this.buffer.write(typedArray);
+            this.bufferValue = value;
+        }
+        return this.buffer;
+    }
+}
+// HELPER FUNCTIONS
+/**
+ * TODO - convert Arrays based on known type? (read type from accessor, don't assume Float32Array)
+ * TODO - handle single values for size 1 attributes?
+ */
+function normalizeConstantArrayValue(arrayValue) {
+    if (Array.isArray(arrayValue)) {
+        return new Float32Array(arrayValue);
+    }
+    return arrayValue;
+}
+/**
+ *
+ */
+function compareConstantArrayValues(v1, v2) {
+    if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
+        return false;
+    }
+    for (let i = 0; i < v1.length; ++i) {
+        if (v1[i] !== v2[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/adapter/webgl-canvas-context.d.ts

@@ -1,12 +1,11 @@
-import type { CanvasContextProps } from '@luma.gl/api';
-import { CanvasContext } from '@luma.gl/api';
-import WebGLDevice from './webgl-device';
-import WEBGLFramebuffer from './resources/webgl-framebuffer';
+import type { CanvasContextProps } from '@luma.gl/core';
+import { CanvasContext } from '@luma.gl/core';
+import { WebGLDevice } from "./webgl-device.js";
+import { WEBGLFramebuffer } from "./resources/webgl-framebuffer.js";
 /**
- * Holds a WebGL Canvas Context which will handle drawing buffer resizing etc
- * @todo This class is WIP, intended to replace the old gltools-based context size tracking
+ * A WebGL Canvas Context which manages the canvas and handles drawing buffer resizing etc
  */
-export default class WebGLCanvasContext extends CanvasContext {
+export declare class WebGLCanvasContext extends CanvasContext {
     readonly device: WebGLDevice;
     presentationSize: [number, number];
     private _framebuffer;

package/dist/adapter/webgl-canvas-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-canvas-context.d.ts","sourceRoot":"","sources":["../../src/adapter/webgl-canvas-context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,cAAc,CAAC;AACrD,OAAO,EAAC,aAAa,EAAC,MAAM,cAAc,CAAC;AAE3C,OAAO,WAAW,MAAM,gBAAgB,CAAC;AACzC,OAAO,gBAAgB,MAAM,+BAA+B,CAAC;AAE7D;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,aAAa;IAC3D,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,OAAO,CAAC,YAAY,CAAiC;gBAEzC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,kBAAkB;IAQ1D,qBAAqB,IAAI,gBAAgB;IAMzC,sDAAsD;IACtD,MAAM;IAQN;;;;;;;;;;;OAWG;IACF,MAAM,CAAC,OAAO,CAAC,EAAE;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;KAAC,GAAG,IAAI;IAe9F,MAAM;CAOP"}
+{"version":3,"file":"webgl-canvas-context.d.ts","sourceRoot":"","sources":["../../src/adapter/webgl-canvas-context.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,eAAe,CAAC;AACtD,OAAO,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAC,WAAW,EAAC,0BAAuB;AAC3C,OAAO,EAAC,gBAAgB,EAAC,yCAAsC;AAE/D;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,aAAa;IACnD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,OAAO,CAAC,YAAY,CAAiC;gBAEzC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,kBAAkB;IAS1D,qBAAqB,IAAI,gBAAgB;IAOzC,sDAAsD;IACtD,MAAM;IAUN;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;KAAC,GAAG,IAAI;IAW7F,MAAM;CAOP"}

package/dist/adapter/webgl-canvas-context.js

@@ -1,54 +1,65 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { CanvasContext } from '@luma.gl/api';
-import { getDevicePixelRatio, setDevicePixelRatio } from '../context/context/device-pixels';
-import WEBGLFramebuffer from './resources/webgl-framebuffer';
-export default class WebGLCanvasContext extends CanvasContext {
-  constructor(device, props) {
-    super(props);
-
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "presentationSize", void 0);
-
-    _defineProperty(this, "_framebuffer", null);
-
-    this.device = device;
-    this.presentationSize = [-1, -1];
-    this.update();
-  }
-
-  getCurrentFramebuffer() {
-    this.update();
-    this._framebuffer = this._framebuffer || new WEBGLFramebuffer(this.device, {
-      handle: null
-    });
-    return this._framebuffer;
-  }
-
-  update() {
-    const size = this.getPixelSize();
-    const sizeChanged = size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1];
-
-    if (sizeChanged) {
-      this.presentationSize = size;
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { CanvasContext } from '@luma.gl/core';
+import { WEBGLFramebuffer } from "./resources/webgl-framebuffer.js";
+/**
+ * A WebGL Canvas Context which manages the canvas and handles drawing buffer resizing etc
+ */
+export class WebGLCanvasContext extends CanvasContext {
+    device;
+    presentationSize;
+    _framebuffer = null;
+    constructor(device, props) {
+        // Note: Base class creates / looks up the canvas (unless under Node.js)
+        super(props);
+        this.device = device;
+        this.presentationSize = [-1, -1];
+        this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
+        this.update();
     }
-  }
-
-  resize(options) {
-    if (this.canvas) {
-      const devicePixelRatio = getDevicePixelRatio(options === null || options === void 0 ? void 0 : options.useDevicePixels);
-      setDevicePixelRatio(this.device.gl, devicePixelRatio, options);
-      return;
+    getCurrentFramebuffer() {
+        this.update();
+        // Setting handle to null returns a reference to the default framebuffer
+        this._framebuffer = this._framebuffer || new WEBGLFramebuffer(this.device, { handle: null });
+        return this._framebuffer;
     }
-
-    const ext = this.device.gl.getExtension('STACKGL_resize_drawingbuffer');
-
-    if (ext && options && "width" in options && "height" in options) {
-      ext.resize(options.width, options.height);
+    /** Resizes and updates render targets if necessary */
+    update() {
+        const size = this.getPixelSize();
+        const sizeChanged = size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1];
+        if (sizeChanged) {
+            this.presentationSize = size;
+            this.resize();
+        }
+    }
+    /**
+     * Resize the canvas' drawing buffer.
+     *
+     * Can match the canvas CSS size, and optionally also consider devicePixelRatio
+     * Can be called every frame
+     *
+     * Regardless of size, the drawing buffer will always be scaled to the viewport, but
+     * for best visual results, usually set to either:
+     *  canvas CSS width x canvas CSS height
+     *  canvas CSS width * devicePixelRatio x canvas CSS height * devicePixelRatio
+     * See http://webgl2fundamentals.org/webgl/lessons/webgl-resizing-the-canvas.html
+     */
+    resize(options) {
+        if (!this.device.gl)
+            return;
+        // Resize browser context .
+        if (this.canvas) {
+            const devicePixelRatio = this.getDevicePixelRatio(options?.useDevicePixels);
+            this.setDevicePixelRatio(devicePixelRatio, options);
+            return;
+        }
+    }
+    commit() {
+        // gl.commit was ultimately removed from the WebGL standard??
+        // if (this.offScreen && this.gl.commit) {
+        //   // @ts-expect-error gl.commit is not officially part of WebGL2RenderingContext
+        //   this.gl.commit();
+        // }
     }
-  }
-
-  commit() {}
-
 }
-//# sourceMappingURL=webgl-canvas-context.js.map