@luma.gl/engine 9.0.0-alpha.25 → 9.0.0-alpha.27

package/dist/dist.dev.js

@@ -1369,9 +1369,9 @@ var __exports__ = (() => {
       };
       if ((props.usage || 0) & Buffer2.INDEX && !props.indexType) {
         if (props.data instanceof Uint32Array) {
-          props.indexType = "uint32";
+          newProps.indexType = "uint32";
         } else if (props.data instanceof Uint16Array) {
-          props.indexType = "uint16";
+          newProps.indexType = "uint16";
         }
       }
       return newProps;
@@ -1581,7 +1581,7 @@ var __exports__ = (() => {
      * Use devicePixelRatio to set canvas width and height
      * @note this is a raw port of luma.gl v8 code. Might be worth a review
      */
-    setDevicePixelRatio(devicePixelRatio2, options = {}) {
+    setDevicePixelRatio(devicePixelRatio, options = {}) {
       if (!this.htmlCanvas) {
         return;
       }
@@ -1589,13 +1589,13 @@ var __exports__ = (() => {
       let clientHeight = "height" in options ? options.height : this.htmlCanvas.clientHeight;
       if (!clientWidth || !clientHeight) {
         log.log(1, "Canvas clientWidth/clientHeight is 0")();
-        devicePixelRatio2 = 1;
+        devicePixelRatio = 1;
         clientWidth = this.htmlCanvas.width || 1;
         clientHeight = this.htmlCanvas.height || 1;
       }
       const cachedSize = this._canvasSizeInfo;
-      if (cachedSize.clientWidth !== clientWidth || cachedSize.clientHeight !== clientHeight || cachedSize.devicePixelRatio !== devicePixelRatio2) {
-        let clampedPixelRatio = devicePixelRatio2;
+      if (cachedSize.clientWidth !== clientWidth || cachedSize.clientHeight !== clientHeight || cachedSize.devicePixelRatio !== devicePixelRatio) {
+        let clampedPixelRatio = devicePixelRatio;
         const canvasWidth = Math.floor(clientWidth * clampedPixelRatio);
         const canvasHeight = Math.floor(clientHeight * clampedPixelRatio);
         this.htmlCanvas.width = canvasWidth;
@@ -1609,7 +1609,7 @@ var __exports__ = (() => {
         }
         this._canvasSizeInfo.clientWidth = clientWidth;
         this._canvasSizeInfo.clientHeight = clientHeight;
-        this._canvasSizeInfo.devicePixelRatio = devicePixelRatio2;
+        this._canvasSizeInfo.devicePixelRatio = devicePixelRatio;
       }
     }
     // PRIVATE
@@ -2028,6 +2028,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 */
@@ -2042,7 +2043,11 @@ var __exports__ = (() => {
     constructor(device, props) {
       super(device, props, _RenderPass.defaultProps);
     }
-    /** A small set of parameters can be changed between every draw call (viewport, scissorRect, blendColor, stencilReference) */
+    /** Call when rendering is done in this pass. */
+    /** 
+     * A small set of parameters can be changed between every draw call 
+     * (viewport, scissorRect, blendColor, stencilReference) 
+     */
     // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
     // beginOcclusionQuery(queryIndex: number): void;
     // endOcclusionQuery(): void;
@@ -2429,6 +2434,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;
+  }
+
   // ../api/src/lib/request-animation-frame.ts
   function requestAnimationFrame(callback) {
     return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame(callback) : setTimeout(callback, 1e3 / 60);
@@ -5830,6 +5872,7 @@ void main() {
   };
   var Model = class {
     fs = null;
+    userData = {};
     constructor(device, props) {
       this.props = {
         ...DEFAULT_MODEL_PROPS,
@@ -5838,6 +5881,7 @@ void main() {
       props = this.props;
       this.id = this.props.id;
       this.device = device;
+      Object.assign(this.userData, this.props.userData);
       if (!props.vs) {
         throw new Error("no vertex shader");
       }
@@ -5910,10 +5954,49 @@ void main() {
       this.pipeline.setIndexBuffer(indices);
       return this;
     }
-    setAttributes(attributes) {
-      this.pipeline.setAttributes(attributes);
-      Object.assign(this.props.attributes, attributes);
-      return this;
+    // Temporary hack to support deck.gl's dependency on luma.gl v8 Model attribute API.
+    _splitAttributes(attributes, filterBuffers) {
+      const bufferAttributes = {};
+      const constantAttributes = {};
+      const indices = attributes.indices;
+      delete attributes.indices;
+      for (const name in attributes) {
+        let attribute = attributes[name];
+        if (attribute instanceof Buffer2) {
+          bufferAttributes[name] = attribute;
+          continue;
+        }
+        if (attribute.getValue) {
+          attribute = attribute.getValue();
+          console.warn(`attribute ${name}: getValue() will be removed`);
+        }
+        if (ArrayBuffer.isView(attribute) && !attribute) {
+          constantAttributes[name] = attribute;
+          continue;
+        }
+        if (filterBuffers && attribute[name]._buffer) {
+          buffer[name] = attribute[name]._buffer;
+        }
+      }
+      return {
+        bufferAttributes,
+        constantAttributes,
+        indices
+      };
+    }
+    setAttributes(attributes, filterBuffers) {
+      const {
+        bufferAttributes,
+        constantAttributes,
+        indices
+      } = this._splitAttributes(attributes, filterBuffers);
+      if (indices) {
+        this.setIndexBuffer(indices);
+        console.warn("luma.gl: indices should not be part of attributes");
+      }
+      this.pipeline.setAttributes(bufferAttributes);
+      this.pipeline.setConstantAttributes(constantAttributes);
+      Object.assign(this.props.attributes, bufferAttributes, constantAttributes);
     }
     /** Set the bindings */
     setBindings(bindings) {
@@ -6756,13 +6839,13 @@ void main() {
       attrib.enabled = false;
       return original.disableVertexAttribArray.apply(this, arguments);
     };
-    gl.bindBuffer = function bindBuffer2(target, buffer) {
+    gl.bindBuffer = function bindBuffer2(target, buffer2) {
       switch (target) {
         case gl.ARRAY_BUFFER:
-          self.currentArrayBuffer = buffer;
+          self.currentArrayBuffer = buffer2;
           break;
         case gl.ELEMENT_ARRAY_BUFFER:
-          self.currentVertexArrayObject.elementArrayBuffer = buffer;
+          self.currentVertexArrayObject.elementArrayBuffer = buffer2;
           break;
         default:
       }
@@ -7601,7 +7684,7 @@ void main() {
           return null;
       }
     },
-    bindBuffer: (update, target, buffer) => {
+    bindBuffer: (update, target, buffer2) => {
       const pname = {
         [GL.ARRAY_BUFFER]: [GL.ARRAY_BUFFER_BINDING],
         [GL.COPY_READ_BUFFER]: [GL.COPY_READ_BUFFER_BINDING],
@@ -7611,7 +7694,7 @@ void main() {
       }[target];
       if (pname) {
         return update({
-          [pname]: buffer
+          [pname]: buffer2
         });
       }
       return {
@@ -10981,6 +11064,7 @@ void main(void) {}`;
      */
     resize(options) {
       if (this.canvas) {
+        const devicePixelRatio = this.getDevicePixelRatio(options?.useDevicePixels);
         this.setDevicePixelRatio(devicePixelRatio, options);
         return;
       }
@@ -12376,8 +12460,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();
@@ -12389,6 +12490,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 = {}) {
@@ -12396,12 +12511,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);
+    setBuffer(location, buffer2, accessor) {
+      if (buffer2.target === GL.ELEMENT_ARRAY_BUFFER) {
+        this.setElementBuffer(buffer2, accessor);
+        return;
       }
       const {
         size,
@@ -12418,7 +12533,7 @@ ${formattedLog}`)();
       } = this;
       location = Number(location);
       this.bind(() => {
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer2.handle);
         if (integer) {
           this.device.assertWebGL2();
           gl2.vertexAttribIPointer(location, size, type, stride, offset);
@@ -12428,24 +12543,106 @@ ${formattedLog}`)();
         gl.enableVertexAttribArray(location);
         gl2.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;
+  }
 
   // ../webgl/src/adapter/resources/webgl-render-pipeline.ts
   var LOG_PROGRAM_PERF_PRIORITY = 4;
@@ -12495,11 +12692,11 @@ ${formattedLog}`)();
     }
     /** @todo needed for portable model */
     setAttributes(attributes) {
-      for (const [name, buffer] of Object.entries(attributes)) {
-        const webglBuffer = cast(buffer);
+      for (const [name, buffer2] of Object.entries(attributes)) {
+        const webglBuffer = cast(buffer2);
         const attribute = getAttributeLayout(this.layout, name);
         if (!attribute) {
-          log.warn(`Ignoring buffer supplied for unknown attribute "${name}" in pipeline "${this.id}" (buffer "${buffer.id}")`)();
+          log.warn(`Ignoring buffer supplied for unknown attribute "${name}" in pipeline "${this.id}" (buffer "${buffer2.id}")`)();
           continue;
         }
         const decoded = decodeVertexFormat(attribute.format);
@@ -12523,7 +12720,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);