@luma.gl/engine 9.0.0-alpha.34 → 9.0.0-alpha.36

package/dist/index.cjs

@@ -21,8 +21,8 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -72,6 +72,7 @@ __export(src_exports, {
   PipelineFactory: () => PipelineFactory,
   PlaneGeometry: () => PlaneGeometry,
   ScenegraphNode: () => ScenegraphNode,
+  ShaderModuleUniforms: () => ShaderModuleUniforms,
   SphereGeometry: () => SphereGeometry,
   Timeline: () => Timeline,
   Transform: () => Transform,
@@ -93,7 +94,7 @@ var Timeline = class {
   }
   addChannel(props) {
     const { delay = 0, duration = Number.POSITIVE_INFINITY, rate = 1, repeat = 1 } = props;
-    const handle = channelHandles++;
+    const channelId = channelHandles++;
     const channel = {
       time: 0,
       delay,
@@ -102,29 +103,29 @@ var Timeline = class {
       repeat
     };
     this._setChannelTime(channel, this.time);
-    this.channels.set(handle, channel);
-    return handle;
+    this.channels.set(channelId, channel);
+    return channelId;
   }
-  removeChannel(handle) {
-    this.channels.delete(handle);
+  removeChannel(channelId) {
+    this.channels.delete(channelId);
     for (const [animationHandle, animation] of this.animations) {
-      if (animation.channel === handle) {
+      if (animation.channel === channelId) {
         this.detachAnimation(animationHandle);
       }
     }
   }
-  isFinished(handle) {
-    const channel = this.channels.get(handle);
+  isFinished(channelId) {
+    const channel = this.channels.get(channelId);
     if (channel === void 0) {
       return false;
     }
     return this.time >= channel.delay + channel.duration * channel.repeat;
   }
-  getTime(handle) {
-    if (handle === void 0) {
+  getTime(channelId) {
+    if (channelId === void 0) {
       return this.time;
     }
-    const channel = this.channels.get(handle);
+    const channel = this.channels.get(channelId);
     if (channel === void 0) {
       return -1;
     }
@@ -161,8 +162,8 @@ var Timeline = class {
     animation.setTime(this.getTime(channelHandle));
     return animationHandle;
   }
-  detachAnimation(handle) {
-    this.animations.delete(handle);
+  detachAnimation(channelId) {
+    this.animations.delete(channelId);
   }
   update(engineTime) {
     if (this.playing) {
@@ -377,7 +378,7 @@ var AnimationLoop = class {
     if ((_a = this.device) == null ? void 0 : _a.isLost) {
       return this;
     }
-    this._beginTimers();
+    this._beginFrameTimers();
     this._setupFrame();
     this._updateAnimationProps();
     this._renderFrame(this._getAnimationProps());
@@ -387,7 +388,7 @@ var AnimationLoop = class {
       this._nextFramePromise = null;
       this._resolveNextFrame = null;
     }
-    this._endTimers();
+    this._endFrameTimers();
     return this;
   }
   // Stops a render loop if already running, finalizing
@@ -493,7 +494,6 @@ var AnimationLoop = class {
       animationLoop: this,
       device: this.device,
       canvas: (_b = (_a = this.device) == null ? void 0 : _a.canvasContext) == null ? void 0 : _b.canvas,
-      renderPass: this.device.getDefaultRenderPass(),
       timeline: this.timeline,
       // Initial values
       useDevicePixels: this.props.useDevicePixels,
@@ -524,7 +524,6 @@ var AnimationLoop = class {
     if (!this.animationProps) {
       return;
     }
-    this.animationProps.renderPass = this.device.getDefaultRenderPass();
     const { width, height, aspect } = this._getSizeAndAspect();
     if (width !== this.animationProps.width || height !== this.animationProps.height) {
       this.setNeedsRedraw("drawing buffer resized");
@@ -607,11 +606,12 @@ var AnimationLoop = class {
       (_b = (_a = this.device) == null ? void 0 : _a.canvasContext) == null ? void 0 : _b.resize({ useDevicePixels: this.props.useDevicePixels });
     }
   }
-  _beginTimers() {
+  _beginFrameTimers() {
     this.frameRate.timeEnd();
     this.frameRate.timeStart();
+    this.cpuTime.timeStart();
   }
-  _endTimers() {
+  _endFrameTimers() {
     this.cpuTime.timeEnd();
   }
   // Event handling
@@ -655,6 +655,7 @@ function makeAnimationLoop(AnimationLoopTemplateCtor, props) {
 
 // src/model/model.ts
 var import_core6 = require("@luma.gl/core");
+var import_core7 = require("@luma.gl/core");
 var import_shadertools = require("@luma.gl/shadertools");
 
 // src/geometry/gpu-geometry.ts
@@ -720,20 +721,20 @@ function getAttributeBuffersFromGeometry(device, geometry) {
   const bufferLayout = [];
   const attributes = {};
   for (const [attributeName, attribute] of Object.entries(geometry.attributes)) {
-    let name = attributeName;
+    let name2 = attributeName;
     switch (attributeName) {
       case "POSITION":
-        name = "positions";
+        name2 = "positions";
         break;
       case "NORMAL":
-        name = "normals";
+        name2 = "normals";
         break;
       case "TEXCOORD_0":
-        name = "texCoords";
+        name2 = "texCoords";
         break;
     }
-    attributes[name] = device.createBuffer({ data: attribute.value, id: `${attributeName}-buffer` });
-    bufferLayout.push({ name, format: `float32x${attribute.size}` });
+    attributes[name2] = device.createBuffer({ data: attribute.value, id: `${attributeName}-buffer` });
+    bufferLayout.push({ name: name2, format: `float32x${attribute.size}` });
   }
   const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices);
   return { attributes, bufferLayout, vertexCount };
@@ -822,7 +823,7 @@ var _Model = class {
     /** instance count */
     this.instanceCount = 0;
     /** Index buffer */
-    this.indices = null;
+    this.indexBuffer = null;
     /** Buffer-valued attributes */
     this.bufferAttributes = {};
     /** Constant-valued attributes */
@@ -832,6 +833,7 @@ var _Model = class {
     /** Sets uniforms @deprecated Use uniform buffers and setBindings() for portability*/
     this.uniforms = {};
     this._pipelineNeedsUpdate = "newly created";
+    this._attributeInfos = {};
     this.props = __spreadValues(__spreadValues({}, _Model.defaultProps), props);
     props = this.props;
     this.id = props.id || (0, import_core6.uid)("model");
@@ -843,7 +845,10 @@ var _Model = class {
       gpu: device.info.gpu,
       features: device.features
     };
-    const { vs, fs, getUniforms } = this.props.shaderAssembler.assembleShaders(platformInfo, this.props);
+    const { vs, fs, getUniforms } = this.props.shaderAssembler.assembleShaders(
+      platformInfo,
+      this.props
+    );
     this.vs = vs;
     this.fs = fs;
     this._getModuleUniforms = getUniforms;
@@ -852,11 +857,18 @@ var _Model = class {
     this.topology = this.props.topology;
     this.bufferLayout = this.props.bufferLayout;
     this.parameters = this.props.parameters;
+    let gpuGeometry;
     if (props.geometry) {
-      this.setGeometry(props.geometry);
+      gpuGeometry = this.setGeometry(props.geometry);
     }
     this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
     this.pipeline = this._updatePipeline();
+    this.vertexArray = device.createVertexArray({
+      renderPipeline: this.pipeline
+    });
+    if (gpuGeometry) {
+      this._setGeometryAttributes(gpuGeometry);
+    }
     if (props.vertexCount) {
       this.setVertexCount(props.vertexCount);
     }
@@ -864,11 +876,17 @@ var _Model = class {
       this.setInstanceCount(props.instanceCount);
     }
     if (props.indices) {
-      this.setIndexBuffer(props.indices);
+      throw new Error("Model.props.indices removed. Use props.indexBuffer");
+    }
+    if (props.indexBuffer) {
+      this.setIndexBuffer(props.indexBuffer);
     }
     if (props.attributes) {
       this.setAttributes(props.attributes);
     }
+    if (props.constantAttributes) {
+      this.setConstantAttributes(props.constantAttributes);
+    }
     if (props.bindings) {
       this.setBindings(props.bindings);
     }
@@ -887,33 +905,42 @@ var _Model = class {
   // Draw call
   draw(renderPass) {
     this.pipeline = this._updatePipeline();
-    this.pipeline.setIndexBuffer(this.indices);
-    this.pipeline.setAttributes(this.bufferAttributes);
-    this.pipeline.setConstantAttributes(this.constantAttributes);
     this.pipeline.setBindings(this.bindings);
     this.pipeline.setUniforms(this.uniforms);
     this.pipeline.draw({
       renderPass,
+      vertexArray: this.vertexArray,
       vertexCount: this.vertexCount,
       instanceCount: this.instanceCount
     });
   }
   // Update fixed fields (can trigger pipeline rebuild)
-  /** 
+  /**
    * Updates the optional geometry
-  * Geometry, sets several attributes, indices, and also vertex count and topology
+   * Geometry, set topology and bufferLayout
    * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
    */
   setGeometry(geometry) {
     const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
     this.setTopology(gpuGeometry.topology || "triangle-list");
     this.bufferLayout = mergeBufferLayouts(this.bufferLayout, gpuGeometry.bufferLayout);
+    if (this.vertexArray) {
+      this._setGeometryAttributes(gpuGeometry);
+    }
+    return gpuGeometry;
+  }
+  /**
+   * Updates the optional geometry attributes
+   * Geometry, sets several attributes, indexBuffer, and also vertex count
+   * @note Can trigger a pipeline rebuild / pipeline cache fetch on WebGPU
+   */
+  _setGeometryAttributes(gpuGeometry) {
     this.vertexCount = gpuGeometry.vertexCount;
     this.setAttributes(gpuGeometry.attributes);
     this.setIndexBuffer(gpuGeometry.indices);
   }
-  /** 
-   * Updates the primitive topology ('triangle-list', 'triangle-strip' etc). 
+  /**
+   * Updates the primitive topology ('triangle-list', 'triangle-strip' etc).
    * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
    */
   setTopology(topology) {
@@ -922,8 +949,8 @@ var _Model = class {
       this._setPipelineNeedsUpdate("topology");
     }
   }
-  /** 
-   * Updates the buffer layout. 
+  /**
+   * Updates the buffer layout.
    * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
    */
   setBufferLayout(bufferLayout) {
@@ -971,61 +998,99 @@ var _Model = class {
   updateModuleSettings(props) {
     this.setShaderModuleProps(props);
   }
+  /**
+   * Sets bindings (textures, samplers, uniform buffers)
+   */
+  setBindings(bindings) {
+    Object.assign(this.bindings, bindings);
+  }
+  /**
+   * Sets individual uniforms
+   * @deprecated WebGL only, use uniform buffers for portability
+   * @param uniforms
+   * @returns self for chaining
+   */
+  setUniforms(uniforms) {
+    this.pipeline.setUniforms(uniforms);
+    Object.assign(this.uniforms, uniforms);
+  }
   /**
    * Sets the index buffer
    * @todo - how to unset it if we change geometry?
    */
-  setIndexBuffer(indices) {
-    this.indices = indices;
+  setIndexBuffer(indexBuffer) {
+    this.vertexArray.setIndexBuffer(indexBuffer);
   }
   /**
    * Sets attributes (buffers)
    * @note Overrides any attributes previously set with the same name
    */
-  setAttributes(bufferAttributes) {
-    if (bufferAttributes.indices) {
-      import_core6.log.warn(`Model:${this.id} setAttributes() - indices should be set using setIndexBuffer()`);
+  setAttributes(buffers) {
+    var _a;
+    if (buffers.indices) {
+      import_core6.log.warn(
+        `Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`
+      );
+    }
+    for (const [bufferName, buffer] of Object.entries(buffers)) {
+      const bufferLayout = this.bufferLayout.find((layout) => layout.name === bufferName);
+      if (!bufferLayout) {
+        continue;
+      }
+      const attributeNames = bufferLayout.attributes ? (_a = bufferLayout.attributes) == null ? void 0 : _a.map((layout) => layout.attribute) : [bufferLayout.name];
+      let set = false;
+      for (const attributeName of attributeNames) {
+        const attributeInfo = this._attributeInfos[attributeName];
+        if (attributeInfo) {
+          this.vertexArray.setBuffer(attributeInfo.location, buffer);
+          set = true;
+        }
+      }
+      if (!set) {
+        import_core6.log.warn(
+          `Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`
+        )();
+      }
     }
-    Object.assign(this.bufferAttributes, bufferAttributes);
   }
   /**
    * Sets constant attributes
    * @note Overrides any attributes previously set with the same name
+   * 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 constantAttributes
    */
-  setConstantAttributes(constantAttributes) {
-    Object.assign(this.constantAttributes, constantAttributes);
-  }
-  /**
-   * Sets bindings (textures, samplers, uniform buffers)
-   */
-  setBindings(bindings) {
-    Object.assign(this.bindings, bindings);
-  }
-  /**
-   * Sets individual uniforms
-   * @deprecated WebGL only, use uniform buffers for portability
-   * @param uniforms
-   * @returns self for chaining
-   */
-  setUniforms(uniforms) {
-    this.pipeline.setUniforms(uniforms);
-    Object.assign(this.uniforms, uniforms);
+  setConstantAttributes(attributes) {
+    for (const [attributeName, value] of Object.entries(attributes)) {
+      const attributeInfo = this._attributeInfos[attributeName];
+      if (attributeInfo) {
+        this.vertexArray.setConstant(attributeInfo.location, value);
+      } else {
+        import_core6.log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${name}"`)();
+      }
+    }
   }
   _setPipelineNeedsUpdate(reason) {
     this._pipelineNeedsUpdate = this._pipelineNeedsUpdate || reason;
   }
   _updatePipeline() {
     if (this._pipelineNeedsUpdate) {
-      import_core6.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
+      if (this.pipeline) {
+        import_core6.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
+      }
       this._pipelineNeedsUpdate = false;
       this.pipeline = this.device.createRenderPipeline(__spreadProps(__spreadValues({}, this.props), {
         bufferLayout: this.bufferLayout,
         topology: this.topology,
         parameters: this.parameters,
-        vs: this.device.createShader({ stage: "vertex", source: this.vs }),
-        fs: this.fs ? this.device.createShader({ stage: "fragment", source: this.fs }) : null
+        vs: this.device.createShader({ id: "{$this.id}-vertex", stage: "vertex", source: this.vs }),
+        fs: this.fs ? this.device.createShader({ id: "{$this.id}-fragment", stage: "fragment", source: this.fs }) : null
       }));
+      this._attributeInfos = (0, import_core7.getAttributeInfosFromLayouts)(
+        this.pipeline.shaderLayout,
+        this.bufferLayout
+      );
     }
     return this.pipeline;
   }
@@ -1041,15 +1106,16 @@ Model.defaultProps = __spreadProps(__spreadValues({}, import_core6.RenderPipelin
   modules: [],
   moduleSettings: {},
   geometry: null,
+  indexBuffer: null,
+  attributes: {},
+  constantAttributes: {},
   pipelineFactory: void 0,
   shaderAssembler: import_shadertools.ShaderAssembler.getDefaultShaderAssembler()
 });
 function mergeBufferLayouts(layouts1, layouts2) {
   const layouts = [...layouts1];
   for (const attribute of layouts2) {
-    const index = layouts.findIndex(
-      (attribute2) => attribute2.name === attribute.name
-    );
+    const index = layouts.findIndex((attribute2) => attribute2.name === attribute.name);
     if (index < 0) {
       layouts.push(attribute);
     } else {
@@ -1060,9 +1126,6 @@ function mergeBufferLayouts(layouts1, layouts2) {
 }
 
 // src/transform/transform.ts
-var import_shadertools2 = require("@luma.gl/shadertools");
-var import_constants = require("@luma.gl/constants");
-var import_webgl = require("@luma.gl/webgl");
 var Transform = class {
   constructor(device, props = {}) {
     // model: Model;
@@ -1070,18 +1133,6 @@ var Transform = class {
     // bufferTransform: BufferTransform | null = null;
     // textureTransform: TextureTransform | null = null;
     this.elementIDBuffer = null;
-    this.device = import_webgl.WebGLDevice.attach(device);
-    this.gl = this.device.gl2;
-    this._buildResourceTransforms(props);
-    props = this._updateModelProps(props);
-    this.model = new Model(this.device, __spreadProps(__spreadValues({}, props), {
-      fs: props.fs || (0, import_shadertools2.getPassthroughFS)({ version: (0, import_shadertools2.getShaderInfo)(props.vs).version }),
-      id: props.id || "transform-model",
-      // @ts-expect-error
-      drawMode: props.drawMode || import_constants.GL.POINTS,
-      vertexCount: props.elementCount
-    }));
-    Object.seal(this);
   }
   /**
    * Check if Transforms are supported (they are not under WebGL1)
@@ -1134,17 +1185,105 @@ var Transform = class {
   }
 };
 
-// src/lib/clip-space.ts
+// src/shadertools/shader-module-uniforms.ts
 var import_core8 = require("@luma.gl/core");
-var import_webgl2 = require("@luma.gl/webgl");
+var import_core9 = require("@luma.gl/core");
+var ShaderModuleUniforms = class {
+  constructor(props) {
+    this.uniformBuffer = null;
+    this.uniforms = {};
+    this.modifiedUniforms = {};
+    this.modified = true;
+    this.needsRedraw = "initialized";
+    this.device = props.device;
+    this.shaderModule = props.shaderModule;
+    this.useUniformBuffers = this.device.info.type !== "webgl";
+    const uniformTypes = {};
+    for (const [name2, { format }] of Object.entries(props.shaderModule.uniforms)) {
+      uniformTypes[name2] = format;
+    }
+    this.uniformBufferLayout = new import_core9.UniformBufferLayout(uniformTypes);
+    if (this.useUniformBuffers) {
+      this.uniformBuffer = this.device.createBuffer({
+        usage: import_core9.Buffer.UNIFORM,
+        byteLength: this.uniformBufferLayout.byteLength
+      });
+    }
+  }
+  /** Set a map of uniforms */
+  setUniforms(uniforms) {
+    for (const [key, value] of Object.entries(uniforms)) {
+      this._setUniform(key, value);
+      this.setNeedsRedraw(key);
+    }
+  }
+  setNeedsRedraw(reason) {
+    this.needsRedraw = this.needsRedraw || reason;
+  }
+  /** 
+   * Updates the uniform buffer if needed. 
+   * Clears the dirty flag.
+   */
+  getUniformBuffer() {
+    if (this.needsRedraw) {
+      const modifiedUniforms = this.getModifiedUniforms();
+      const data = this.uniformBufferLayout.getData(modifiedUniforms);
+      this.uniformBuffer.write(data);
+    }
+    return this.uniformBuffer;
+  }
+  /** Returns all uniforms */
+  getUniforms(groupName) {
+    this.modifiedUniforms = {};
+    this.needsRedraw = false;
+    return this.uniforms[groupName] || {};
+  }
+  /** Returns modified uniforms */
+  getModifiedUniforms() {
+    const modifiedUniforms = this.modifiedUniforms;
+    this.modifiedUniforms = {};
+    this.needsRedraw = false;
+    return modifiedUniforms;
+  }
+  /** Set a single uniform */
+  _setUniform(key, value) {
+    if (arrayEqual(this.uniforms[key], value)) {
+      return;
+    }
+    this.uniforms[key] = value;
+    this.modifiedUniforms[key] = true;
+    this.modified = true;
+  }
+};
+function arrayEqual(a, b, limit = 16) {
+  if (a !== b) {
+    return false;
+  }
+  const arrayA = (0, import_core8.isNumberArray)(a);
+  if (!arrayA) {
+    return false;
+  }
+  const arrayB = (0, import_core8.isNumberArray)(b);
+  if (arrayB && arrayA.length === arrayB.length) {
+    for (let i = 0; i < arrayA.length; ++i) {
+      if (arrayB[i] !== arrayA[i]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/lib/clip-space.ts
+var import_core11 = require("@luma.gl/core");
 
 // src/geometry/geometry.ts
-var import_core7 = require("@luma.gl/core");
+var import_core10 = require("@luma.gl/core");
 var Geometry = class {
   constructor(props) {
     this.userData = {};
     const { attributes = {}, indices = null, vertexCount = null } = props;
-    this.id = props.id || (0, import_core7.uid)("geometry");
+    this.id = props.id || (0, import_core10.uid)("geometry");
     this.topology = props.topology;
     if (indices) {
       this.indices = ArrayBuffer.isView(indices) ? { value: indices, size: 1 } : indices;
@@ -1152,7 +1291,7 @@ var Geometry = class {
     this.attributes = {};
     for (const [attributeName, attributeValue] of Object.entries(attributes)) {
       const attribute = ArrayBuffer.isView(attributeValue) ? { value: attributeValue } : attributeValue;
-      (0, import_core7.assert)(
+      (0, import_core10.assert)(
         ArrayBuffer.isView(attribute.value),
         `${this._print(attributeName)}: must be typed array or object with value as typed array`
       );
@@ -1160,7 +1299,7 @@ var Geometry = class {
         attribute.size = 3;
       }
       if (attributeName === "indices") {
-        (0, import_core7.assert)(!this.indices);
+        (0, import_core10.assert)(!this.indices);
         this.indices = attribute;
       } else {
         this.attributes[attributeName] = attribute;
@@ -1211,13 +1350,13 @@ var Geometry = class {
         vertexCount = Math.min(vertexCount, value.length / size);
       }
     }
-    (0, import_core7.assert)(Number.isFinite(vertexCount));
+    (0, import_core10.assert)(Number.isFinite(vertexCount));
     return vertexCount;
   }
 };
 
 // src/lib/clip-space.ts
-var CLIPSPACE_VERTEX_SHADER = import_core8.glsl`\
+var CLIPSPACE_VERTEX_SHADER = import_core11.glsl`\
 attribute vec2 aClipSpacePosition;
 attribute vec2 aTexCoord;
 attribute vec2 aCoordinate;
@@ -1238,7 +1377,7 @@ var ClipSpace = class extends Model {
   constructor(device, opts) {
     const TEX_COORDS = POSITIONS.map((coord) => coord === -1 ? 0 : coord);
     super(
-      import_webgl2.WebGLDevice.attach(device),
+      device,
       __spreadProps(__spreadValues({}, opts), {
         vs: CLIPSPACE_VERTEX_SHADER,
         vertexCount: 4,
@@ -1257,19 +1396,19 @@ var ClipSpace = class extends Model {
 };
 
 // src/scenegraph/scenegraph-node.ts
-var import_core9 = require("@luma.gl/core");
-var import_core10 = require("@math.gl/core");
+var import_core12 = require("@luma.gl/core");
+var import_core13 = require("@math.gl/core");
 var ScenegraphNode = class {
   constructor(props = {}) {
-    this.matrix = new import_core10.Matrix4();
+    this.matrix = new import_core13.Matrix4();
     this.display = true;
-    this.position = new import_core10.Vector3();
-    this.rotation = new import_core10.Vector3();
-    this.scale = new import_core10.Vector3(1, 1, 1);
+    this.position = new import_core13.Vector3();
+    this.rotation = new import_core13.Vector3();
+    this.scale = new import_core13.Vector3(1, 1, 1);
     this.userData = {};
     this.props = {};
     const { id } = props;
-    this.id = id || (0, import_core9.uid)(this.constructor.name);
+    this.id = id || (0, import_core12.uid)(this.constructor.name);
     this._setScenegraphNodeProps(props);
   }
   getBounds() {
@@ -1289,17 +1428,17 @@ var ScenegraphNode = class {
     return `{type: ScenegraphNode, id: ${this.id})}`;
   }
   setPosition(position) {
-    (0, import_core9.assert)(position.length === 3, "setPosition requires vector argument");
+    (0, import_core12.assert)(position.length === 3, "setPosition requires vector argument");
     this.position = position;
     return this;
   }
   setRotation(rotation) {
-    (0, import_core9.assert)(rotation.length === 3, "setRotation requires vector argument");
+    (0, import_core12.assert)(rotation.length === 3, "setRotation requires vector argument");
     this.rotation = rotation;
     return this;
   }
   setScale(scale) {
-    (0, import_core9.assert)(scale.length === 3, "setScale requires vector argument");
+    (0, import_core12.assert)(scale.length === 3, "setScale requires vector argument");
     this.scale = scale;
     return this;
   }
@@ -1351,9 +1490,9 @@ var ScenegraphNode = class {
     return this;
   }
   getCoordinateUniforms(viewMatrix, modelMatrix) {
-    (0, import_core9.assert)(viewMatrix);
+    (0, import_core12.assert)(viewMatrix);
     modelMatrix = modelMatrix || this.matrix;
-    const worldMatrix = new import_core10.Matrix4(viewMatrix).multiplyRight(modelMatrix);
+    const worldMatrix = new import_core13.Matrix4(viewMatrix).multiplyRight(modelMatrix);
     const worldInverse = worldMatrix.invert();
     const worldInverseTranspose = worldInverse.transpose();
     return {
@@ -1408,13 +1547,13 @@ var ScenegraphNode = class {
 };
 
 // src/scenegraph/group-node.ts
-var import_core11 = require("@math.gl/core");
-var import_core12 = require("@luma.gl/core");
+var import_core14 = require("@math.gl/core");
+var import_core15 = require("@luma.gl/core");
 var GroupNode = class extends ScenegraphNode {
   constructor(props = {}) {
     props = Array.isArray(props) ? { children: props } : props;
     const { children = [] } = props;
-    import_core12.log.assert(
+    import_core15.log.assert(
       children.every((child) => child instanceof ScenegraphNode),
       "every child must an instance of ScenegraphNode"
     );
@@ -1429,12 +1568,12 @@ var GroupNode = class extends ScenegraphNode {
         return;
       }
       const [min, max] = bounds;
-      const center = new import_core11.Vector3(min).add(max).divide([2, 2, 2]);
+      const center = new import_core14.Vector3(min).add(max).divide([2, 2, 2]);
       worldMatrix.transformAsPoint(center, center);
-      const halfSize = new import_core11.Vector3(max).subtract(min).divide([2, 2, 2]);
+      const halfSize = new import_core14.Vector3(max).subtract(min).divide([2, 2, 2]);
       worldMatrix.transformAsVector(halfSize, halfSize);
       for (let v = 0; v < 8; v++) {
-        const position = new import_core11.Vector3(
+        const position = new import_core14.Vector3(
           v & 1 ? -1 : 1,
           v & 2 ? -1 : 1,
           v & 4 ? -1 : 1
@@ -1478,8 +1617,8 @@ var GroupNode = class extends ScenegraphNode {
     this.children = [];
     return this;
   }
-  traverse(visitor, { worldMatrix = new import_core11.Matrix4() } = {}) {
-    const modelMatrix = new import_core11.Matrix4(worldMatrix).multiplyRight(this.matrix);
+  traverse(visitor, { worldMatrix = new import_core14.Matrix4() } = {}) {
+    const modelMatrix = new import_core14.Matrix4(worldMatrix).multiplyRight(this.matrix);
     for (const child of this.children) {
       if (child instanceof GroupNode) {
         child.traverse(visitor, { worldMatrix: modelMatrix });
@@ -1522,10 +1661,10 @@ var ModelNode = class extends ScenegraphNode {
 };
 
 // src/geometries/cone-geometry.ts
-var import_core14 = require("@luma.gl/core");
+var import_core17 = require("@luma.gl/core");
 
 // src/geometries/truncated-cone-geometry.ts
-var import_core13 = require("@luma.gl/core");
+var import_core16 = require("@luma.gl/core");
 var INDEX_OFFSETS = {
   x: [2, 0, 1],
   y: [0, 1, 2],
@@ -1533,7 +1672,7 @@ var INDEX_OFFSETS = {
 };
 var TruncatedConeGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core13.uid)("truncated-code-geometry") } = props;
+    const { id = (0, import_core16.uid)("truncated-code-geometry") } = props;
     const { indices, attributes } = tesselateTruncatedCone(props);
     super(__spreadProps(__spreadValues({}, props), {
       id,
@@ -1635,7 +1774,7 @@ function tesselateTruncatedCone(props = {}) {
 // src/geometries/cone-geometry.ts
 var ConeGeometry = class extends TruncatedConeGeometry {
   constructor(props = {}) {
-    const { id = (0, import_core14.uid)("cone-geometry"), radius = 1, cap = true } = props;
+    const { id = (0, import_core17.uid)("cone-geometry"), radius = 1, cap = true } = props;
     super(__spreadProps(__spreadValues({}, props), {
       id,
       topRadius: 0,
@@ -1647,10 +1786,10 @@ var ConeGeometry = class extends TruncatedConeGeometry {
 };
 
 // src/geometries/cube-geometry.ts
-var import_core15 = require("@luma.gl/core");
+var import_core18 = require("@luma.gl/core");
 var CubeGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core15.uid)("cube-geometry"), indices = true } = props;
+    const { id = (0, import_core18.uid)("cube-geometry"), indices = true } = props;
     super(indices ? __spreadProps(__spreadValues({}, props), {
       id,
       topology: "triangle-list",
@@ -2291,10 +2430,10 @@ var NON_INDEXED_ATTRIBUTES = {
 };
 
 // src/geometries/cylinder-geometry.ts
-var import_core16 = require("@luma.gl/core");
+var import_core19 = require("@luma.gl/core");
 var CylinderGeometry = class extends TruncatedConeGeometry {
   constructor(props = {}) {
-    const { id = (0, import_core16.uid)("cylinder-geometry"), radius = 1 } = props;
+    const { id = (0, import_core19.uid)("cylinder-geometry"), radius = 1 } = props;
     super(__spreadProps(__spreadValues({}, props), {
       id,
       bottomRadius: radius,
@@ -2304,13 +2443,13 @@ var CylinderGeometry = class extends TruncatedConeGeometry {
 };
 
 // src/geometries/ico-sphere-geometry.ts
-var import_core17 = require("@luma.gl/core");
-var import_core18 = require("@math.gl/core");
+var import_core20 = require("@luma.gl/core");
+var import_core21 = 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_core17.uid)("ico-sphere-geometry") } = props;
+    const { id = (0, import_core20.uid)("ico-sphere-geometry") } = props;
     const { indices, attributes } = tesselateIcosaHedron(props);
     super(__spreadProps(__spreadValues({}, props), {
       id,
@@ -2402,7 +2541,7 @@ function tesselateIcosaHedron(props) {
     const u3 = 1 - phi3 / PI2;
     const vec1 = [x3 - x2, y3 - y2, z3 - z2];
     const vec2 = [x1 - x2, y1 - y2, z1 - z2];
-    const normal = new import_core18.Vector3(vec1).cross(vec2).normalize();
+    const normal = new import_core21.Vector3(vec1).cross(vec2).normalize();
     let newIndex;
     if ((u1 === 0 || u2 === 0 || u3 === 0) && (u1 === 0 || u1 > 0.5) && (u2 === 0 || u2 > 0.5) && (u3 === 0 || u3 > 0.5)) {
       positions.push(positions[in1 + 0], positions[in1 + 1], positions[in1 + 2]);
@@ -2451,7 +2590,7 @@ function tesselateIcosaHedron(props) {
 }
 
 // src/geometries/plane-geometry.ts
-var import_core19 = require("@luma.gl/core");
+var import_core22 = require("@luma.gl/core");
 
 // src/geometry/geometry-utils.ts
 function unpackIndexedGeometry(geometry) {
@@ -2484,7 +2623,7 @@ function unpackIndexedGeometry(geometry) {
 // src/geometries/plane-geometry.ts
 var PlaneGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core19.uid)("plane-geometry") } = props;
+    const { id = (0, import_core22.uid)("plane-geometry") } = props;
     const { indices, attributes } = tesselatePlane(props);
     super(__spreadProps(__spreadValues({}, props), {
       id,
@@ -2573,10 +2712,10 @@ function tesselatePlane(props) {
 }
 
 // src/geometries/sphere-geometry.ts
-var import_core20 = require("@luma.gl/core");
+var import_core23 = require("@luma.gl/core");
 var SphereGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core20.uid)("sphere-geometry") } = props;
+    const { id = (0, import_core23.uid)("sphere-geometry") } = props;
     const { indices, attributes } = tesselateSphere(props);
     super(__spreadProps(__spreadValues({}, props), {
       id,