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

package/dist/dist.dev.js

@@ -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 */
@@ -2433,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);
@@ -5916,18 +5954,49 @@ void main() {
       this.pipeline.setIndexBuffer(indices);
       return this;
     }
-    setAttributes(attributes) {
-      if (attributes.indices) {
-        this.setIndexBuffer(attributes.indices);
-        attributes = {
-          ...attributes
-        };
-        delete attributes.indices;
+    // 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(attributes);
-      Object.assign(this.props.attributes, attributes);
-      return this;
+      this.pipeline.setAttributes(bufferAttributes);
+      this.pipeline.setConstantAttributes(constantAttributes);
+      Object.assign(this.props.attributes, bufferAttributes, constantAttributes);
     }
     /** Set the bindings */
     setBindings(bindings) {
@@ -6770,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:
       }
@@ -7615,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],
@@ -7625,7 +7694,7 @@ void main() {
       }[target];
       if (pname) {
         return update({
-          [pname]: buffer
+          [pname]: buffer2
         });
       }
       return {
@@ -12391,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();
@@ -12404,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 = {}) {
@@ -12411,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,
@@ -12433,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);
@@ -12443,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;
@@ -12510,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);
@@ -12538,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);

package/dist/index.cjs

@@ -655,6 +655,7 @@ function makeAnimationLoop(AnimationLoopTemplateCtor, props) {
 
 // src/model/model.ts
 var import_api5 = require("@luma.gl/api");
+var import_api6 = require("@luma.gl/api");
 
 // src/model/model-utils.ts
 var import_api4 = require("@luma.gl/api");
@@ -847,7 +848,7 @@ var PipelineFactory = class {
 };
 
 // src/model/model.ts
-var DEFAULT_MODEL_PROPS = __spreadProps(__spreadValues({}, import_api5.RenderPipeline._DEFAULT_PROPS), {
+var DEFAULT_MODEL_PROPS = __spreadProps(__spreadValues({}, import_api6.RenderPipeline._DEFAULT_PROPS), {
   vs: null,
   fs: null,
   id: "unnamed",
@@ -936,16 +937,41 @@ var Model = class {
     this.pipeline.setIndexBuffer(indices);
     return this;
   }
-  setAttributes(attributes) {
-    if (attributes.indices) {
-      this.setIndexBuffer(attributes.indices);
-      attributes = __spreadValues({}, attributes);
-      delete attributes.indices;
+  // 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 import_api5.Buffer) {
+        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(attributes);
-    Object.assign(this.props.attributes, attributes);
-    return this;
+    this.pipeline.setAttributes(bufferAttributes);
+    this.pipeline.setConstantAttributes(constantAttributes);
+    Object.assign(this.props.attributes, bufferAttributes, constantAttributes);
   }
   /** Set the bindings */
   setBindings(bindings) {
@@ -1062,11 +1088,11 @@ var Transform = class {
 
 // src/lib/clip-space.ts
 var import_constants3 = require("@luma.gl/constants");
-var import_api7 = require("@luma.gl/api");
+var import_api8 = require("@luma.gl/api");
 var import_webgl2 = require("@luma.gl/webgl");
 
 // src/geometry/geometry.ts
-var import_api6 = require("@luma.gl/api");
+var import_api7 = require("@luma.gl/api");
 var import_constants2 = require("@luma.gl/constants");
 var Geometry = class {
   constructor(props = {}) {
@@ -1074,7 +1100,7 @@ var Geometry = class {
     /** @deprecated */
     this.drawMode = import_constants2.GL.TRIANGLES;
     const {
-      id = (0, import_api6.uid)("geometry"),
+      id = (0, import_api7.uid)("geometry"),
       drawMode = import_constants2.GL.TRIANGLES,
       attributes = {},
       indices = null,
@@ -1089,7 +1115,7 @@ var Geometry = class {
     this.attributes = {};
     for (const [attributeName, attributeValue] of Object.entries(attributes)) {
       const attribute = ArrayBuffer.isView(attributeValue) ? { value: attributeValue } : attributeValue;
-      (0, import_api6.assert)(
+      (0, import_api7.assert)(
         ArrayBuffer.isView(attribute.value),
         `${this._print(attributeName)}: must be typed array or object with value as typed array`
       );
@@ -1097,7 +1123,7 @@ var Geometry = class {
         attribute.size = 3;
       }
       if (attributeName === "indices") {
-        (0, import_api6.assert)(!this.indices);
+        (0, import_api7.assert)(!this.indices);
         this.indices = attribute;
       } else {
         this.attributes[attributeName] = attribute;
@@ -1144,7 +1170,7 @@ var Geometry = class {
         vertexCount = Math.min(vertexCount, value.length / size);
       }
     }
-    (0, import_api6.assert)(Number.isFinite(vertexCount));
+    (0, import_api7.assert)(Number.isFinite(vertexCount));
     return vertexCount;
   }
 };
@@ -1187,7 +1213,7 @@ function convertToTopology(drawMode) {
 }
 
 // src/lib/clip-space.ts
-var CLIPSPACE_VERTEX_SHADER = import_api7.glsl`\
+var CLIPSPACE_VERTEX_SHADER = import_api8.glsl`\
 attribute vec2 aClipSpacePosition;
 attribute vec2 aTexCoord;
 attribute vec2 aCoordinate;
@@ -1227,7 +1253,7 @@ var ClipSpace = class extends Model {
 };
 
 // src/scenegraph/scenegraph-node.ts
-var import_api8 = require("@luma.gl/api");
+var import_api9 = require("@luma.gl/api");
 var import_core = require("@math.gl/core");
 var ScenegraphNode = class {
   constructor(props = {}) {
@@ -1239,7 +1265,7 @@ var ScenegraphNode = class {
     this.userData = {};
     this.props = {};
     const { id } = props;
-    this.id = id || (0, import_api8.uid)(this.constructor.name);
+    this.id = id || (0, import_api9.uid)(this.constructor.name);
     this._setScenegraphNodeProps(props);
   }
   getBounds() {
@@ -1259,17 +1285,17 @@ var ScenegraphNode = class {
     return `{type: ScenegraphNode, id: ${this.id})}`;
   }
   setPosition(position) {
-    (0, import_api8.assert)(position.length === 3, "setPosition requires vector argument");
+    (0, import_api9.assert)(position.length === 3, "setPosition requires vector argument");
     this.position = position;
     return this;
   }
   setRotation(rotation) {
-    (0, import_api8.assert)(rotation.length === 3, "setRotation requires vector argument");
+    (0, import_api9.assert)(rotation.length === 3, "setRotation requires vector argument");
     this.rotation = rotation;
     return this;
   }
   setScale(scale) {
-    (0, import_api8.assert)(scale.length === 3, "setScale requires vector argument");
+    (0, import_api9.assert)(scale.length === 3, "setScale requires vector argument");
     this.scale = scale;
     return this;
   }
@@ -1321,7 +1347,7 @@ var ScenegraphNode = class {
     return this;
   }
   getCoordinateUniforms(viewMatrix, modelMatrix) {
-    (0, import_api8.assert)(viewMatrix);
+    (0, import_api9.assert)(viewMatrix);
     modelMatrix = modelMatrix || this.matrix;
     const worldMatrix = new import_core.Matrix4(viewMatrix).multiplyRight(modelMatrix);
     const worldInverse = worldMatrix.invert();
@@ -1379,12 +1405,12 @@ var ScenegraphNode = class {
 
 // src/scenegraph/group-node.ts
 var import_core2 = require("@math.gl/core");
-var import_api9 = require("@luma.gl/api");
+var import_api10 = require("@luma.gl/api");
 var GroupNode = class extends ScenegraphNode {
   constructor(props = {}) {
     props = Array.isArray(props) ? { children: props } : props;
     const { children = [] } = props;
-    import_api9.log.assert(
+    import_api10.log.assert(
       children.every((child) => child instanceof ScenegraphNode),
       "every child must an instance of ScenegraphNode"
     );
@@ -1492,10 +1518,10 @@ var ModelNode = class extends ScenegraphNode {
 };
 
 // src/geometries/cone-geometry.ts
-var import_api11 = require("@luma.gl/api");
+var import_api12 = require("@luma.gl/api");
 
 // src/geometries/truncated-cone-geometry.ts
-var import_api10 = require("@luma.gl/api");
+var import_api11 = require("@luma.gl/api");
 var INDEX_OFFSETS = {
   x: [2, 0, 1],
   y: [0, 1, 2],
@@ -1503,7 +1529,7 @@ var INDEX_OFFSETS = {
 };
 var TruncatedConeGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_api10.uid)("truncated-code-geometry") } = props;
+    const { id = (0, import_api11.uid)("truncated-code-geometry") } = props;
     const { indices, attributes } = tesselateTruncatedCone(props);
     super(__spreadProps(__spreadValues({}, props), {
       id,
@@ -1604,7 +1630,7 @@ function tesselateTruncatedCone(props = {}) {
 // src/geometries/cone-geometry.ts
 var ConeGeometry = class extends TruncatedConeGeometry {
   constructor(props = {}) {
-    const { id = (0, import_api11.uid)("cone-geometry"), radius = 1, cap = true } = props;
+    const { id = (0, import_api12.uid)("cone-geometry"), radius = 1, cap = true } = props;
     super(__spreadProps(__spreadValues({}, props), {
       id,
       topRadius: 0,
@@ -1616,10 +1642,10 @@ var ConeGeometry = class extends TruncatedConeGeometry {
 };
 
 // src/geometries/cube-geometry.ts
-var import_api12 = require("@luma.gl/api");
+var import_api13 = require("@luma.gl/api");
 var CubeGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_api12.uid)("cube-geometry"), indices = true } = props;
+    const { id = (0, import_api13.uid)("cube-geometry"), indices = true } = props;
     super(indices ? __spreadProps(__spreadValues({}, props), {
       id,
       indices: { size: 1, value: CUBE_INDICES },
@@ -2258,10 +2284,10 @@ var NON_INDEXED_ATTRIBUTES = {
 };
 
 // src/geometries/cylinder-geometry.ts
-var import_api13 = require("@luma.gl/api");
+var import_api14 = require("@luma.gl/api");
 var CylinderGeometry = class extends TruncatedConeGeometry {
   constructor(props = {}) {
-    const { id = (0, import_api13.uid)("cylinder-geometry"), radius = 1 } = props;
+    const { id = (0, import_api14.uid)("cylinder-geometry"), radius = 1 } = props;
     super(__spreadProps(__spreadValues({}, props), {
       id,
       bottomRadius: radius,
@@ -2271,13 +2297,13 @@ var CylinderGeometry = class extends TruncatedConeGeometry {
 };
 
 // src/geometries/ico-sphere-geometry.ts
-var import_api14 = require("@luma.gl/api");
+var import_api15 = require("@luma.gl/api");
 var import_core3 = require("@math.gl/core");
 var ICO_POSITIONS = [-1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 1, 0, -1, 0, 1, 0, 0];
 var ICO_INDICES = [3, 4, 5, 3, 5, 1, 3, 1, 0, 3, 0, 4, 4, 0, 2, 4, 2, 5, 2, 0, 1, 5, 2, 1];
 var IcoSphereGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_api14.uid)("ico-sphere-geometry") } = props;
+    const { id = (0, import_api15.uid)("ico-sphere-geometry") } = props;
     const { indices, attributes } = tesselateIcosaHedron(props);
     super(__spreadProps(__spreadValues({}, props), {
       id,
@@ -2417,7 +2443,7 @@ function tesselateIcosaHedron(props) {
 }
 
 // src/geometries/plane-geometry.ts
-var import_api15 = require("@luma.gl/api");
+var import_api16 = require("@luma.gl/api");
 
 // src/geometry/geometry-utils.ts
 function unpackIndexedGeometry(geometry) {
@@ -2450,7 +2476,7 @@ function unpackIndexedGeometry(geometry) {
 // src/geometries/plane-geometry.ts
 var PlaneGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_api15.uid)("plane-geometry") } = props;
+    const { id = (0, import_api16.uid)("plane-geometry") } = props;
     const { indices, attributes } = tesselatePlane(props);
     super(__spreadProps(__spreadValues({}, props), {
       id,
@@ -2538,10 +2564,10 @@ function tesselatePlane(props) {
 }
 
 // src/geometries/sphere-geometry.ts
-var import_api16 = require("@luma.gl/api");
+var import_api17 = require("@luma.gl/api");
 var SphereGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_api16.uid)("sphere-geometry") } = props;
+    const { id = (0, import_api17.uid)("sphere-geometry") } = props;
     const { indices, attributes } = tesselateSphere(props);
     super(__spreadProps(__spreadValues({}, props), {
       id,