@luma.gl/webgl 9.0.0-alpha.26 → 9.0.0-alpha.27

package/dist/dist.dev.js

@@ -1851,6 +1851,7 @@ var __exports__ = (() => {
   };
   /** Set attributes (stored on pipeline and set before each call) */
   /** Set attributes (stored on pipeline and set before each call) */
+  /** Set constant attributes (WebGL only) */
   /** Set bindings (stored on pipeline and set before each call) */
   /** Uniforms (only supported on WebGL devices. Reset before each call to enable pipeline sharing) */
   /** Draw call */
@@ -2256,6 +2257,43 @@ var __exports__ = (() => {
     });
   }
 
+  // ../api/src/lib/utils/array-utils-flat.ts
+  var arrayBuffer;
+  function getScratchArrayBuffer(byteLength) {
+    if (!arrayBuffer || arrayBuffer.byteLength < byteLength) {
+      arrayBuffer = new ArrayBuffer(byteLength);
+    }
+    return arrayBuffer;
+  }
+  function getScratchArray(Type, length) {
+    const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
+    return new Type(scratchArrayBuffer, 0, length);
+  }
+  function fillArray(options) {
+    const {
+      target,
+      source,
+      start = 0,
+      count = 1
+    } = options;
+    const length = source.length;
+    const total = count * length;
+    let copied = 0;
+    for (let i = start; copied < length; copied++) {
+      target[i++] = source[copied];
+    }
+    while (copied < total) {
+      if (copied < total - copied) {
+        target.copyWithin(start + copied, start, start + copied);
+        copied *= 2;
+      } else {
+        target.copyWithin(start + copied, start, start + total - copied);
+        copied = total;
+      }
+    }
+    return options.target;
+  }
+
   // src/context/polyfill/polyfill-vertex-array-object.ts
   var glErrorShadow = {};
   function error(msg) {
@@ -8646,8 +8684,25 @@ ${formattedLog}`)();
     get [Symbol.toStringTag]() {
       return "BaseVertexArrayObject";
     }
+    /** Buffer constant */
+    buffer = null;
+    bufferValue = null;
+    static isConstantAttributeZeroSupported(device) {
+      return device.info.type === "webgl2" || getBrowser() === "Chrome";
+    }
+    // Create a VertexArray
     constructor(device, props) {
-      super(device, props, {});
+      super(device, props, {
+        ...Resource.defaultProps,
+        constantAttributeZero: false
+      });
+      Object.seal(this);
+    }
+    destroy() {
+      super.destroy();
+      if (this.buffer) {
+        this.buffer?.destroy();
+      }
     }
     _createHandle() {
       return this.gl2.createVertexArray();
@@ -8659,6 +8714,20 @@ ${formattedLog}`)();
     _bindHandle(handle) {
       this.gl2.bindVertexArray(handle);
     }
+    /**
+     * 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, enable2 = true) {
+      const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === "Chrome";
+      const canDisableAttribute = canDisableAttributeZero || location !== 0;
+      if (enable2 || canDisableAttribute) {
+        location = Number(location);
+        this.bind(() => enable2 ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location));
+      }
+    }
     // Set (bind) an elements buffer, for indexed rendering.
     // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
     setElementBuffer(elementBuffer = null, opts = {}) {
@@ -8666,12 +8735,12 @@ ${formattedLog}`)();
       this.bind(() => {
         this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
       });
-      return this;
     }
     /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
     setBuffer(location, buffer, accessor) {
       if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {
-        return this.setElementBuffer(buffer, accessor);
+        this.setElementBuffer(buffer, accessor);
+        return;
       }
       const {
         size,
@@ -8698,24 +8767,106 @@ ${formattedLog}`)();
         gl2.enableVertexAttribArray(location);
         gl22.vertexAttribDivisor(location, divisor || 0);
       });
-      return this;
     }
     /**
-     * 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?
+     * Set an attribute to a constant value
+     * @param device
+     * @param location
+     * @param array
+     * 
+     * @note Constants are stored globally on the WebGL context, not the VAO
+     * so they need to be updated before every render
+     * @todo - use known type (in configuration or passed in) to allow non-typed arrays?
+     * @todo - remember/cache values to avoid setting them unnecessarily?
      */
-    enable(location, enable2 = true) {
-      const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === "Chrome";
-      const canDisableAttribute = canDisableAttributeZero || location !== 0;
-      if (enable2 || canDisableAttribute) {
-        location = Number(location);
-        this.bind(() => enable2 ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location));
+    setConstant(location, array) {
+      switch (array.constructor) {
+        case Float32Array:
+          setConstantFloatArray(this.device, location, array);
+          break;
+        case Int32Array:
+          setConstantIntArray(this.device, location, array);
+          break;
+        case Uint32Array:
+          setConstantUintArray(this.device, location, array);
+          break;
+        default:
+          assert2(false);
       }
-      return this;
+    }
+    /**
+     * 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) {
+      const constantValue = normalizeConstantArrayValue(value);
+      const byteLength = constantValue.byteLength * elementCount;
+      const length = constantValue.length * elementCount;
+      let updateNeeded = !this.buffer;
+      this.buffer = this.buffer || this.device.createBuffer({
+        byteLength
+      });
+      updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
+      updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
+      if (updateNeeded) {
+        const typedArray = getScratchArray(value.constructor, length);
+        fillArray({
+          target: typedArray,
+          source: constantValue,
+          start: 0,
+          count: length
+        });
+        this.buffer.subData(typedArray);
+        this.bufferValue = value;
+      }
+      return this.buffer;
     }
   };
+  function setConstantFloatArray(device, location, array) {
+    switch (array.length) {
+      case 1:
+        device.gl.vertexAttrib1fv(location, array);
+        break;
+      case 2:
+        device.gl.vertexAttrib2fv(location, array);
+        break;
+      case 3:
+        device.gl.vertexAttrib3fv(location, array);
+        break;
+      case 4:
+        device.gl.vertexAttrib4fv(location, array);
+        break;
+      default:
+        assert2(false);
+    }
+  }
+  function setConstantIntArray(device, location, array) {
+    device.assertWebGL2();
+    device.gl2?.vertexAttribI4iv(location, array);
+  }
+  function setConstantUintArray(device, location, array) {
+    device.assertWebGL2();
+    device.gl2?.vertexAttribI4uiv(location, array);
+  }
+  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;
+  }
 
   // src/adapter/resources/webgl-render-pipeline.ts
   var LOG_PROGRAM_PERF_PRIORITY = 4;
@@ -8793,7 +8944,26 @@ ${formattedLog}`)();
         });
       }
     }
-    /** @todo needed for portable model */
+    /**
+     * Constant attributes are only supported in WebGL, not in WebGPU
+     * Any attribute that is disabled in the current vertex array object
+     * is read from the context's global constant value for that attribute location.
+     * @param attributes 
+     */
+    setConstantAttributes(attributes) {
+      for (const [name, value] of Object.entries(attributes)) {
+        const attribute = getAttributeLayout(this.layout, name);
+        if (!attribute) {
+          log.warn(`Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`)();
+          continue;
+        }
+        this.vertexArrayObject.setConstant(attribute.location, value);
+      }
+    }
+    /** 
+     * Bindings include: textures, samplers and uniform buffers
+     * @todo needed for portable model 
+     */
     setBindings(bindings) {
       for (const [name, value] of Object.entries(bindings)) {
         const binding = this.layout.bindings.find((binding2) => binding2.name === name);

package/dist/index.cjs

@@ -5236,11 +5236,26 @@ var import_constants24 = require("@luma.gl/constants");
 var import_env = require("@probe.gl/env");
 var ERR_ELEMENTS = "elements must be GL.ELEMENT_ARRAY_BUFFER";
 var WEBGLVertexArrayObject = class extends WebGLResource {
+  // Create a VertexArray
+  constructor(device, props) {
+    super(device, props, __spreadProps(__spreadValues({}, import_api22.Resource.defaultProps), { constantAttributeZero: false }));
+    /** Buffer constant */
+    this.buffer = null;
+    this.bufferValue = null;
+    Object.seal(this);
+  }
   get [Symbol.toStringTag]() {
     return "BaseVertexArrayObject";
   }
-  constructor(device, props) {
-    super(device, props, {});
+  static isConstantAttributeZeroSupported(device) {
+    return device.info.type === "webgl2" || (0, import_env.getBrowser)() === "Chrome";
+  }
+  destroy() {
+    var _a;
+    super.destroy();
+    if (this.buffer) {
+      (_a = this.buffer) == null ? void 0 : _a.destroy();
+    }
   }
   _createHandle() {
     return this.gl2.createVertexArray();
@@ -5252,6 +5267,22 @@ var WEBGLVertexArrayObject = class extends WebGLResource {
   _bindHandle(handle) {
     this.gl2.bindVertexArray(handle);
   }
+  /**
+   * 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, enable2 = true) {
+    const canDisableAttributeZero = this.device.isWebGL2 || (0, import_env.getBrowser)() === "Chrome";
+    const canDisableAttribute = canDisableAttributeZero || location !== 0;
+    if (enable2 || canDisableAttribute) {
+      location = Number(location);
+      this.bind(
+        () => enable2 ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location)
+      );
+    }
+  }
   // Set (bind) an elements buffer, for indexed rendering.
   // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
   setElementBuffer(elementBuffer = null, opts = {}) {
@@ -5259,12 +5290,12 @@ var WEBGLVertexArrayObject = class extends WebGLResource {
     this.bind(() => {
       this.gl.bindBuffer(import_constants24.GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
     });
-    return this;
   }
   /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
   setBuffer(location, buffer, accessor) {
     if (buffer.target === import_constants24.GL.ELEMENT_ARRAY_BUFFER) {
-      return this.setElementBuffer(buffer, accessor);
+      this.setElementBuffer(buffer, accessor);
+      return;
     }
     const { size, type, stride, offset, normalized, integer, divisor } = accessor;
     const { gl: gl2, gl2: gl22 } = this;
@@ -5280,26 +5311,101 @@ var WEBGLVertexArrayObject = class extends WebGLResource {
       gl2.enableVertexAttribArray(location);
       gl22.vertexAttribDivisor(location, divisor || 0);
     });
-    return this;
   }
   /**
-   * 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?
+   * Set an attribute to a constant value
+   * @param device
+   * @param location
+   * @param array
+   * 
+   * @note Constants are stored globally on the WebGL context, not the VAO
+   * so they need to be updated before every render
+   * @todo - use known type (in configuration or passed in) to allow non-typed arrays?
+   * @todo - remember/cache values to avoid setting them unnecessarily?
    */
-  enable(location, enable2 = true) {
-    const canDisableAttributeZero = this.device.isWebGL2 || (0, import_env.getBrowser)() === "Chrome";
-    const canDisableAttribute = canDisableAttributeZero || location !== 0;
-    if (enable2 || canDisableAttribute) {
-      location = Number(location);
-      this.bind(
-        () => enable2 ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location)
-      );
+  setConstant(location, array) {
+    switch (array.constructor) {
+      case Float32Array:
+        setConstantFloatArray(this.device, location, array);
+        break;
+      case Int32Array:
+        setConstantIntArray(this.device, location, array);
+        break;
+      case Uint32Array:
+        setConstantUintArray(this.device, location, array);
+        break;
+      default:
+        (0, import_api22.assert)(false);
     }
-    return this;
+  }
+  /**
+   * 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) {
+    const constantValue = normalizeConstantArrayValue(value);
+    const byteLength = constantValue.byteLength * elementCount;
+    const length = constantValue.length * elementCount;
+    let updateNeeded = !this.buffer;
+    this.buffer = this.buffer || this.device.createBuffer({ byteLength });
+    updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
+    updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
+    if (updateNeeded) {
+      const typedArray = (0, import_api22.getScratchArray)(value.constructor, length);
+      (0, import_api22.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
+      this.buffer.subData(typedArray);
+      this.bufferValue = value;
+    }
+    return this.buffer;
   }
 };
+function setConstantFloatArray(device, location, array) {
+  switch (array.length) {
+    case 1:
+      device.gl.vertexAttrib1fv(location, array);
+      break;
+    case 2:
+      device.gl.vertexAttrib2fv(location, array);
+      break;
+    case 3:
+      device.gl.vertexAttrib3fv(location, array);
+      break;
+    case 4:
+      device.gl.vertexAttrib4fv(location, array);
+      break;
+    default:
+      (0, import_api22.assert)(false);
+  }
+}
+function setConstantIntArray(device, location, array) {
+  var _a;
+  device.assertWebGL2();
+  (_a = device.gl2) == null ? void 0 : _a.vertexAttribI4iv(location, array);
+}
+function setConstantUintArray(device, location, array) {
+  var _a;
+  device.assertWebGL2();
+  (_a = device.gl2) == null ? void 0 : _a.vertexAttribI4uiv(location, array);
+}
+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;
+}
 
 // src/adapter/resources/webgl-render-pipeline.ts
 var LOG_PROGRAM_PERF_PRIORITY = 4;
@@ -5367,7 +5473,26 @@ var WEBGLRenderPipeline = class extends import_api23.RenderPipeline {
       });
     }
   }
-  /** @todo needed for portable model */
+  /**
+   * Constant attributes are only supported in WebGL, not in WebGPU
+   * Any attribute that is disabled in the current vertex array object
+   * is read from the context's global constant value for that attribute location.
+   * @param attributes 
+   */
+  setConstantAttributes(attributes) {
+    for (const [name, value] of Object.entries(attributes)) {
+      const attribute = getAttributeLayout(this.layout, name);
+      if (!attribute) {
+        import_api23.log.warn(`Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`)();
+        continue;
+      }
+      this.vertexArrayObject.setConstant(attribute.location, value);
+    }
+  }
+  /** 
+   * Bindings include: textures, samplers and uniform buffers
+   * @todo needed for portable model 
+   */
   setBindings(bindings) {
     for (const [name, value] of Object.entries(bindings)) {
       const binding = this.layout.bindings.find((binding2) => binding2.name === name);