@luma.gl/engine 9.0.0-beta.4 → 9.0.0-beta.6

package/dist/index.cjs

@@ -22,9 +22,9 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
   AnimationLoop: () => AnimationLoop,
   AnimationLoopTemplate: () => AnimationLoopTemplate,
   BufferTransform: () => BufferTransform,
@@ -42,6 +42,7 @@ __export(src_exports, {
   PipelineFactory: () => PipelineFactory,
   PlaneGeometry: () => PlaneGeometry,
   ScenegraphNode: () => ScenegraphNode,
+  ShaderFactory: () => ShaderFactory,
   SphereGeometry: () => SphereGeometry,
   TextureTransform: () => TextureTransform,
   Timeline: () => Timeline,
@@ -49,9 +50,9 @@ __export(src_exports, {
   _ShaderInputs: () => ShaderInputs,
   makeAnimationLoop: () => makeAnimationLoop
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(dist_exports);
 
-// src/animation/timeline.ts
+// dist/animation/timeline.js
 var channelHandles = 1;
 var animationHandles = 1;
 var Timeline = class {
@@ -156,7 +157,7 @@ var Timeline = class {
   }
 };
 
-// src/animation/key-frames.ts
+// dist/animation/key-frames.js
 var KeyFrames = class {
   startIndex = -1;
   endIndex = -1;
@@ -213,7 +214,7 @@ var KeyFrames = class {
   }
 };
 
-// src/animation-loop/animation-loop-template.ts
+// dist/animation-loop/animation-loop-template.js
 var AnimationLoopTemplate = class {
   constructor(animationProps) {
   }
@@ -222,7 +223,7 @@ var AnimationLoopTemplate = class {
   }
 };
 
-// src/animation-loop/animation-loop.ts
+// dist/animation-loop/animation-loop.js
 var import_core = require("@luma.gl/core");
 var import_core2 = require("@luma.gl/core");
 var import_stats = require("@probe.gl/stats");
@@ -564,7 +565,14 @@ var AnimationLoop = class {
   /** Default viewport setup */
   _resizeViewport() {
     if (this.props.autoResizeViewport && this.device.gl) {
-      this.device.gl.viewport(0, 0, this.device.gl.drawingBufferWidth, this.device.gl.drawingBufferHeight);
+      this.device.gl.viewport(
+        0,
+        0,
+        // @ts-expect-error Expose canvasContext
+        this.device.gl.drawingBufferWidth,
+        // @ts-expect-error Expose canvasContext
+        this.device.gl.drawingBufferHeight
+      );
     }
   }
   /**
@@ -602,7 +610,7 @@ var AnimationLoop = class {
   }
 };
 
-// src/animation-loop/make-animation-loop.ts
+// dist/animation-loop/make-animation-loop.js
 var import_core3 = require("@luma.gl/core");
 function makeAnimationLoop(AnimationLoopTemplateCtor, props) {
   let renderLoop = null;
@@ -623,18 +631,18 @@ function makeAnimationLoop(AnimationLoopTemplateCtor, props) {
   return animationLoop;
 }
 
-// src/model/model.ts
-var import_core7 = require("@luma.gl/core");
+// dist/model/model.js
 var import_core8 = require("@luma.gl/core");
 var import_core9 = require("@luma.gl/core");
+var import_core10 = require("@luma.gl/core");
 var import_shadertools2 = require("@luma.gl/shadertools");
 
-// src/shader-inputs.ts
+// dist/shader-inputs.js
 var import_core4 = require("@luma.gl/core");
 var import_shadertools = require("@luma.gl/shadertools");
 var ShaderInputs = class {
-  /** 
-   * The map of modules 
+  /**
+   * The map of modules
    * @todo should should this include the resolved dependencies?
    */
   modules;
@@ -685,8 +693,8 @@ var ShaderInputs = class {
   // getUniformBlocks(): Record<string, Texture | Sampler> {
   //   return this.moduleUniforms;
   // }
-  /** 
-   * Return the map of modules 
+  /**
+   * Return the map of modules
    * @todo should should this include the resolved dependencies?
    */
   getModules() {
@@ -719,7 +727,7 @@ var ShaderInputs = class {
   }
 };
 
-// src/geometry/gpu-geometry.ts
+// dist/geometry/gpu-geometry.js
 var import_core5 = require("@luma.gl/core");
 var GPUGeometry = class {
   id;
@@ -811,7 +819,7 @@ function getAttributeBuffersFromGeometry(device, geometry) {
   return { attributes, bufferLayout, vertexCount };
 }
 
-// src/lib/pipeline-factory.ts
+// dist/lib/pipeline-factory.js
 var import_core6 = require("@luma.gl/core");
 var _PipelineFactory = class {
   device;
@@ -830,11 +838,7 @@ var _PipelineFactory = class {
     const props = { ..._PipelineFactory.defaultProps, ...options };
     const hash = this._hashRenderPipeline({ ...props });
     if (!this._pipelineCache[hash]) {
-      const pipeline = this.device.createRenderPipeline({
-        ...props,
-        vs: this.device.createShader({ stage: "vertex", source: props.vs }),
-        fs: props.fs ? this.device.createShader({ stage: "fragment", source: props.fs }) : null
-      });
+      const pipeline = this.device.createRenderPipeline({ ...props });
       pipeline.hash = hash;
       this._pipelineCache[hash] = pipeline;
       this._useCounts[hash] = 0;
@@ -854,16 +858,16 @@ var _PipelineFactory = class {
   // PRIVATE
   /** Calculate a hash based on all the inputs for a render pipeline */
   _hashRenderPipeline(props) {
-    const vsHash = this._getHash(props.vs);
-    const fsHash = props.fs ? this._getHash(props.fs) : 0;
+    const vsHash = this._getHash(props.vs.source);
+    const fsHash = props.fs ? this._getHash(props.fs.source) : 0;
     const varyingHash = "-";
+    const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
     switch (this.device.info.type) {
       case "webgpu":
         const parameterHash = this._getHash(JSON.stringify(props.parameters));
-        const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
-        return `${vsHash}/${fsHash}V${varyingHash}T${props.topology}P${parameterHash}BL${bufferLayoutHash}}`;
+        return `${vsHash}/${fsHash}V${varyingHash}T${props.topology}P${parameterHash}BL${bufferLayoutHash}`;
       default:
-        return `${vsHash}/${fsHash}V${varyingHash}`;
+        return `${vsHash}/${fsHash}V${varyingHash}BL${bufferLayoutHash}`;
     }
   }
   _getHash(key) {
@@ -874,13 +878,55 @@ var _PipelineFactory = class {
   }
 };
 var PipelineFactory = _PipelineFactory;
-__publicField(PipelineFactory, "defaultProps", {
-  ...import_core6.RenderPipeline.defaultProps,
-  vs: void 0,
-  fs: void 0
-});
+__publicField(PipelineFactory, "defaultProps", { ...import_core6.RenderPipeline.defaultProps });
+
+// dist/lib/shader-factory.js
+var import_core7 = require("@luma.gl/core");
+var _ShaderFactory = class {
+  device;
+  _cache = {};
+  /** Returns the default ShaderFactory for the given {@link Device}, creating one if necessary. */
+  static getDefaultShaderFactory(device) {
+    device._lumaData.defaultShaderFactory ||= new _ShaderFactory(device);
+    return device._lumaData.defaultShaderFactory;
+  }
+  /** @internal */
+  constructor(device) {
+    this.device = device;
+  }
+  /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */
+  createShader(props) {
+    const key = this._hashShader(props);
+    let cacheEntry = this._cache[key];
+    if (!cacheEntry) {
+      const shader = this.device.createShader({
+        ...props,
+        id: props.id ? `${props.id}-cached` : void 0
+      });
+      this._cache[key] = cacheEntry = { shader, useCount: 0 };
+    }
+    cacheEntry.useCount++;
+    return cacheEntry.shader;
+  }
+  /** Releases a previously-requested {@link Shader}, destroying it if no users remain. */
+  release(shader) {
+    const key = this._hashShader(shader);
+    const cacheEntry = this._cache[key];
+    cacheEntry.useCount--;
+    if (cacheEntry.useCount === 0) {
+      delete this._cache[key];
+      cacheEntry.shader.destroy();
+    }
+  }
+  // PRIVATE
+  _hashShader(value) {
+    return `${value.stage}:${value.source}`;
+  }
+};
+var ShaderFactory = _ShaderFactory;
+__publicField(ShaderFactory, "defaultProps", { ...import_core7.Shader.defaultProps });
 
-// src/debug/debug-shader-layout.ts
+// dist/debug/debug-shader-layout.js
 function getDebugTableForShaderLayout(layout, name) {
   var _a;
   const table = {};
@@ -901,7 +947,7 @@ function getDebugTableForShaderLayout(layout, name) {
   return table;
 }
 
-// src/debug/debug-framebuffer.ts
+// dist/debug/debug-framebuffer.js
 var canvas = null;
 var ctx = null;
 function debugFramebuffer(fbo, { id, minimap, opaque, top = "0", left = "0", rgbaScale = 1 }) {
@@ -936,7 +982,7 @@ function debugFramebuffer(fbo, { id, minimap, opaque, top = "0", left = "0", rgb
   ctx.putImageData(imageData, 0, 0);
 }
 
-// src/model/model.ts
+// dist/model/model.js
 var LOG_DRAW_PRIORITY = 2;
 var LOG_DRAW_TIMEOUT = 1e4;
 var _Model = class {
@@ -945,6 +991,7 @@ var _Model = class {
   vs;
   fs;
   pipelineFactory;
+  shaderFactory;
   userData = {};
   // Fixed properties (change can trigger pipeline rebuild)
   /** The render pipeline GPU parameters, depth testing etc */
@@ -986,16 +1033,15 @@ var _Model = class {
   _gpuGeometry = null;
   _getModuleUniforms;
   props;
+  _destroyed = false;
   constructor(device, props) {
     var _a, _b, _c;
     this.props = { ..._Model.defaultProps, ...props };
     props = this.props;
-    this.id = props.id || (0, import_core8.uid)("model");
+    this.id = props.id || (0, import_core9.uid)("model");
     this.device = device;
     Object.assign(this.userData, props.userData);
-    const moduleMap = Object.fromEntries(
-      ((_a = this.props.modules) == null ? void 0 : _a.map((module2) => [module2.name, module2])) || []
-    );
+    const moduleMap = Object.fromEntries(((_a = this.props.modules) == null ? void 0 : _a.map((module2) => [module2.name, module2])) || []);
     this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
     const isWebGPU = this.device.info.type === "webgpu";
     if (this.props.source) {
@@ -1027,6 +1073,7 @@ var _Model = class {
       this._gpuGeometry = this.setGeometry(props.geometry);
     }
     this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
+    this.shaderFactory = props.shaderFactory || ShaderFactory.getDefaultShaderFactory(this.device);
     this.pipeline = this._updatePipeline();
     this.vertexArray = device.createVertexArray({
       renderPipeline: this.pipeline
@@ -1047,7 +1094,9 @@ var _Model = class {
       this.setIndexBuffer(props.indexBuffer);
     }
     if (props.attributes) {
-      this.setAttributes(props.attributes);
+      this.setAttributes(props.attributes, {
+        ignoreUnknownAttributes: props.ignoreUnknownAttributes
+      });
     }
     if (props.constantAttributes) {
       this.setConstantAttributes(props.constantAttributes);
@@ -1059,7 +1108,7 @@ var _Model = class {
       this.setUniforms(props.uniforms);
     }
     if (props.moduleSettings) {
-      import_core8.log.warn("Model.props.moduleSettings is deprecated. Use Model.shaderInputs.setProps()")();
+      import_core9.log.warn("Model.props.moduleSettings is deprecated. Use Model.shaderInputs.setProps()")();
       this.updateModuleSettings(props.moduleSettings);
     }
     if (props.transformFeedback) {
@@ -1068,8 +1117,13 @@ var _Model = class {
     Object.seal(this);
   }
   destroy() {
+    if (this._destroyed)
+      return;
     this.pipelineFactory.release(this.pipeline);
+    this.shaderFactory.release(this.pipeline.vs);
+    this.shaderFactory.release(this.pipeline.fs);
     this._uniformStore.destroy();
+    this._destroyed = true;
   }
   // Draw call
   predraw() {
@@ -1081,7 +1135,7 @@ var _Model = class {
       this._logDrawCallStart();
       this.pipeline = this._updatePipeline();
       this.pipeline.setBindings(this.bindings);
-      this.pipeline.setUniforms(this.uniforms);
+      this.pipeline.setUniformsWebGL(this.uniforms);
       const { indexBuffer } = this.vertexArray;
       const indexCount = indexBuffer ? indexBuffer.byteLength / (indexBuffer.indexType === "uint32" ? 4 : 2) : void 0;
       this.pipeline.draw({
@@ -1126,8 +1180,8 @@ var _Model = class {
     }
     this.vertexCount = gpuGeometry.vertexCount;
     this.setIndexBuffer(gpuGeometry.indices);
-    this.setAttributes(gpuGeometry.attributes, "ignore-unknown");
-    this.setAttributes(attributes);
+    this.setAttributes(gpuGeometry.attributes, { ignoreUnknownAttributes: true });
+    this.setAttributes(attributes, { ignoreUnknownAttributes: this.props.ignoreUnknownAttributes });
   }
   /**
    * Updates the primitive topology ('triangle-list', 'triangle-strip' etc).
@@ -1141,7 +1195,7 @@ var _Model = class {
   }
   /**
    * Updates the buffer layout.
-   * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
+   * @note Triggers a pipeline rebuild / pipeline cache fetch
    */
   setBufferLayout(bufferLayout) {
     this.bufferLayout = this._gpuGeometry ? mergeBufferLayouts(bufferLayout, this._gpuGeometry.bufferLayout) : bufferLayout;
@@ -1160,7 +1214,7 @@ var _Model = class {
    * @param parameters
    */
   setParameters(parameters) {
-    if (!(0, import_core8.deepEqual)(parameters, this.parameters, 2)) {
+    if (!(0, import_core9.deepEqual)(parameters, this.parameters, 2)) {
       this.parameters = parameters;
       this._setPipelineNeedsUpdate("parameters");
     }
@@ -1182,7 +1236,7 @@ var _Model = class {
   }
   setShaderInputs(shaderInputs) {
     this.shaderInputs = shaderInputs;
-    this._uniformStore = new import_core7.UniformStore(this.shaderInputs.modules);
+    this._uniformStore = new import_core8.UniformStore(this.shaderInputs.modules);
     for (const moduleName of Object.keys(this.shaderInputs.modules)) {
       const uniformBuffer = this._uniformStore.getManagedUniformBuffer(this.device, moduleName);
       this.bindings[`${moduleName}Uniforms`] = uniformBuffer;
@@ -1195,7 +1249,7 @@ var _Model = class {
     const uniforms = this._getModuleUniforms(props);
     const keys = Object.keys(uniforms).filter((k) => {
       const uniform = uniforms[k];
-      return !(0, import_core8.isNumberArray)(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
+      return !(0, import_core9.isNumberArray)(uniform) && typeof uniform !== "number" && typeof uniform !== "boolean";
     });
     const bindings = {};
     for (const k of keys) {
@@ -1210,8 +1264,8 @@ var _Model = class {
    * @deprecated Updates shader module settings (which results in uniforms being set)
    */
   updateModuleSettings(props) {
-    import_core8.log.warn("Model.updateModuleSettings is deprecated. Use Model.shaderInputs.setProps()")();
-    const { bindings, uniforms } = (0, import_core8.splitUniformsAndBindings)(this._getModuleUniforms(props));
+    import_core9.log.warn("Model.updateModuleSettings is deprecated. Use Model.shaderInputs.setProps()")();
+    const { bindings, uniforms } = (0, import_core9.splitUniformsAndBindings)(this._getModuleUniforms(props));
     Object.assign(this.bindings, bindings);
     Object.assign(this.uniforms, uniforms);
   }
@@ -1228,7 +1282,7 @@ var _Model = class {
    * @returns self for chaining
    */
   setUniforms(uniforms) {
-    this.pipeline.setUniforms(uniforms);
+    this.pipeline.setUniformsWebGL(uniforms);
     Object.assign(this.uniforms, uniforms);
   }
   /**
@@ -1239,7 +1293,7 @@ var _Model = class {
     this.vertexArray.setIndexBuffer(indexBuffer);
   }
   /**
-   * Updates optional transform feedback. WebGL 2 only.
+   * Updates optional transform feedback. WebGL only.
    */
   setTransformFeedback(transformFeedback) {
     this.transformFeedback = transformFeedback;
@@ -1248,16 +1302,14 @@ var _Model = class {
    * Sets attributes (buffers)
    * @note Overrides any attributes previously set with the same name
    */
-  setAttributes(buffers, _option) {
+  setAttributes(buffers, options) {
     if (buffers.indices) {
-      import_core8.log.warn(
-        `Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`
-      )();
+      import_core9.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) => getAttributeNames(layout).includes(bufferName));
       if (!bufferLayout) {
-        import_core8.log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
+        import_core9.log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
         continue;
       }
       const attributeNames = getAttributeNames(bufferLayout);
@@ -1269,10 +1321,8 @@ var _Model = class {
           set = true;
         }
       }
-      if (!set && _option !== "ignore-unknown") {
-        import_core8.log.warn(
-          `Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`
-        )();
+      if (!set && ((options == null ? void 0 : options.ignoreUnknownAttributes) || this.props.ignoreUnknownAttributes)) {
+        import_core9.log.warn(`Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`)();
       }
     }
   }
@@ -1288,11 +1338,9 @@ var _Model = class {
     for (const [attributeName, value] of Object.entries(attributes)) {
       const attributeInfo = this._attributeInfos[attributeName];
       if (attributeInfo) {
-        this.vertexArray.setConstant(attributeInfo.location, value);
+        this.vertexArray.setConstantWebGL(attributeInfo.location, value);
       } else {
-        import_core8.log.warn(
-          `Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`
-        )();
+        import_core9.log.warn(`Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`)();
       }
     }
   }
@@ -1301,24 +1349,27 @@ var _Model = class {
   }
   _updatePipeline() {
     if (this._pipelineNeedsUpdate) {
+      let prevShaderVs = null;
+      let prevShaderFs = null;
       if (this.pipeline) {
-        import_core8.log.log(
-          1,
-          `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`
-        )();
+        import_core9.log.log(1, `Model ${this.id}: Recreating pipeline because "${this._pipelineNeedsUpdate}".`)();
+        prevShaderVs = this.pipeline.vs;
+        prevShaderFs = this.pipeline.fs;
       }
       this._pipelineNeedsUpdate = false;
-      const vs = this.device.createShader({
+      const vs = this.shaderFactory.createShader({
         id: `${this.id}-vertex`,
         stage: "vertex",
-        source: this.vs
+        source: this.vs,
+        debug: this.props.debugShaders
       });
-      const fs = this.fs ? this.device.createShader({
+      const fs = this.fs ? this.shaderFactory.createShader({
         id: `${this.id}-fragment`,
         stage: "fragment",
-        source: this.fs
+        source: this.fs,
+        debug: this.props.debugShaders
       }) : null;
-      this.pipeline = this.device.createRenderPipeline({
+      this.pipeline = this.pipelineFactory.createRenderPipeline({
         ...this.props,
         bufferLayout: this.bufferLayout,
         topology: this.topology,
@@ -1326,10 +1377,11 @@ var _Model = class {
         vs,
         fs
       });
-      this._attributeInfos = (0, import_core9.getAttributeInfosFromLayouts)(
-        this.pipeline.shaderLayout,
-        this.bufferLayout
-      );
+      this._attributeInfos = (0, import_core10.getAttributeInfosFromLayouts)(this.pipeline.shaderLayout, this.bufferLayout);
+      if (prevShaderVs)
+        this.shaderFactory.release(prevShaderVs);
+      if (prevShaderFs)
+        this.shaderFactory.release(prevShaderFs);
     }
     return this.pipeline;
   }
@@ -1337,33 +1389,33 @@ var _Model = class {
   _lastLogTime = 0;
   _logOpen = false;
   _logDrawCallStart() {
-    const logDrawTimeout = import_core8.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
-    if (import_core8.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
+    const logDrawTimeout = import_core9.log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
+    if (import_core9.log.level < 2 || Date.now() - this._lastLogTime < logDrawTimeout) {
       return;
     }
     this._lastLogTime = Date.now();
     this._logOpen = true;
-    import_core8.log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core8.log.level <= 2 })();
+    import_core9.log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, { collapsed: import_core9.log.level <= 2 })();
   }
   _logDrawCallEnd() {
     if (this._logOpen) {
       const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout, this.id);
-      import_core8.log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
+      import_core9.log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
       const uniformTable = this.shaderInputs.getDebugTable();
       for (const [name, value] of Object.entries(this.uniforms)) {
         uniformTable[name] = { value };
       }
-      import_core8.log.table(LOG_DRAW_PRIORITY, uniformTable)();
+      import_core9.log.table(LOG_DRAW_PRIORITY, uniformTable)();
       const attributeTable = this._getAttributeDebugTable();
-      import_core8.log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
-      import_core8.log.table(LOG_DRAW_PRIORITY, attributeTable)();
-      import_core8.log.groupEnd(LOG_DRAW_PRIORITY)();
+      import_core9.log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
+      import_core9.log.table(LOG_DRAW_PRIORITY, attributeTable)();
+      import_core9.log.groupEnd(LOG_DRAW_PRIORITY)();
       this._logOpen = false;
     }
   }
   _drawCount = 0;
   _logFramebuffer(renderPass) {
-    const debugFramebuffers = import_core8.log.get("framebuffer");
+    const debugFramebuffers = import_core9.log.get("framebuffer");
     this._drawCount++;
     if (!debugFramebuffers || this._drawCount++ > 3 && this._drawCount % 60) {
       return;
@@ -1379,10 +1431,7 @@ var _Model = class {
       table[attributeInfo.location] = {
         name,
         type: attributeInfo.shaderType,
-        values: this._getBufferOrConstantValues(
-          this.vertexArray.attributes[attributeInfo.location],
-          attributeInfo.bufferDataType
-        )
+        values: this._getBufferOrConstantValues(this.vertexArray.attributes[attributeInfo.location], attributeInfo.bufferDataType)
       };
     }
     if (this.vertexArray.indexBuffer) {
@@ -1398,14 +1447,14 @@ var _Model = class {
   }
   // TODO - fix typing of luma data types
   _getBufferOrConstantValues(attribute, dataType) {
-    const TypedArrayConstructor = (0, import_core7.getTypedArrayFromDataType)(dataType);
-    const typedArray = attribute instanceof import_core7.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
+    const TypedArrayConstructor = (0, import_core10.getTypedArrayFromDataType)(dataType);
+    const typedArray = attribute instanceof import_core8.Buffer ? new TypedArrayConstructor(attribute.debugData) : attribute;
     return typedArray.toString();
   }
 };
 var Model = _Model;
 __publicField(Model, "defaultProps", {
-  ...import_core7.RenderPipeline.defaultProps,
+  ...import_core8.RenderPipeline.defaultProps,
   source: null,
   vs: null,
   fs: null,
@@ -1422,8 +1471,11 @@ __publicField(Model, "defaultProps", {
   varyings: [],
   shaderInputs: void 0,
   pipelineFactory: void 0,
+  shaderFactory: void 0,
   transformFeedback: void 0,
-  shaderAssembler: import_shadertools2.ShaderAssembler.getDefaultShaderAssembler()
+  shaderAssembler: import_shadertools2.ShaderAssembler.getDefaultShaderAssembler(),
+  debugShaders: void 0,
+  ignoreUnknownAttributes: void 0
 });
 function mergeBufferLayouts(layouts1, layouts2) {
   const layouts = [...layouts1];
@@ -1443,6 +1495,7 @@ function getPlatformInfo(device) {
     shaderLanguage: device.info.shadingLanguage,
     shaderLanguageVersion: device.info.shadingLanguageVersion,
     gpu: device.info.gpu,
+    // HACK - we pretend that the DeviceFeatures is a Set, it has a similar API
     features: device.features
   };
 }
@@ -1451,8 +1504,8 @@ function getAttributeNames(bufferLayout) {
   return bufferLayout.attributes ? (_a = bufferLayout.attributes) == null ? void 0 : _a.map((layout) => layout.attribute) : [bufferLayout.name];
 }
 
-// src/transform/buffer-transform.ts
-var import_core10 = require("@luma.gl/core");
+// dist/transform/buffer-transform.js
+var import_core11 = require("@luma.gl/core");
 var import_shadertools3 = require("@luma.gl/shadertools");
 var BufferTransform = class {
   device;
@@ -1460,14 +1513,15 @@ var BufferTransform = class {
   transformFeedback;
   /** @deprecated Use device feature test. */
   static isSupported(device) {
-    return device.features.has("transform-feedback-webgl2");
+    var _a;
+    return ((_a = device == null ? void 0 : device.info) == null ? void 0 : _a.type) === "webgl";
   }
   constructor(device, props = Model.defaultProps) {
-    (0, import_core10.assert)(device.features.has("transform-feedback-webgl2"), "Device must support transform feedback");
+    (0, import_core11.assert)(BufferTransform.isSupported(device), "BufferTransform not yet implemented on WebGPU");
     this.device = device;
     this.model = new Model(this.device, {
       id: props.id || "buffer-transform-model",
-      fs: props.fs || (0, import_shadertools3.getPassthroughFS)({ version: 300 }),
+      fs: props.fs || (0, import_shadertools3.getPassthroughFS)(),
       topology: props.topology || "point-list",
       ...props
     });
@@ -1504,7 +1558,7 @@ var BufferTransform = class {
   }
   readAsync(varyingName) {
     const result = this.getBuffer(varyingName);
-    if (result instanceof import_core10.Buffer) {
+    if (result instanceof import_core11.Buffer) {
       return result.readAsync();
     }
     const { buffer, byteOffset = 0, byteLength = buffer.byteLength } = result;
@@ -1512,7 +1566,7 @@ var BufferTransform = class {
   }
 };
 
-// src/transform/texture-transform.ts
+// dist/transform/texture-transform.js
 var import_shadertools4 = require("@luma.gl/shadertools");
 var FS_OUTPUT_VARIABLE = "transform_output";
 var TextureTransform = class {
@@ -1537,7 +1591,6 @@ var TextureTransform = class {
     this.model = new Model(this.device, {
       id: props.id || "texture-transform-model",
       fs: props.fs || (0, import_shadertools4.getPassthroughFS)({
-        version: 300,
         input: props.targetTextureVarying,
         inputChannels: props.targetTextureChannels,
         output: FS_OUTPUT_VARIABLE
@@ -1620,11 +1673,11 @@ var TextureTransform = class {
   }
 };
 
-// src/lib/clip-space.ts
-var import_core12 = require("@luma.gl/core");
+// dist/lib/clip-space.js
+var import_core13 = require("@luma.gl/core");
 
-// src/geometry/geometry.ts
-var import_core11 = require("@luma.gl/core");
+// dist/geometry/geometry.js
+var import_core12 = require("@luma.gl/core");
 var Geometry = class {
   id;
   /** Determines how vertices are read from the 'vertex' attributes */
@@ -1635,7 +1688,7 @@ var Geometry = class {
   userData = {};
   constructor(props) {
     const { attributes = {}, indices = null, vertexCount = null } = props;
-    this.id = props.id || (0, import_core11.uid)("geometry");
+    this.id = props.id || (0, import_core12.uid)("geometry");
     this.topology = props.topology;
     if (indices) {
       this.indices = ArrayBuffer.isView(indices) ? { value: indices, size: 1 } : indices;
@@ -1643,15 +1696,12 @@ var Geometry = class {
     this.attributes = {};
     for (const [attributeName, attributeValue] of Object.entries(attributes)) {
       const attribute = ArrayBuffer.isView(attributeValue) ? { value: attributeValue } : attributeValue;
-      (0, import_core11.assert)(
-        ArrayBuffer.isView(attribute.value),
-        `${this._print(attributeName)}: must be typed array or object with value as typed array`
-      );
+      (0, import_core12.assert)(ArrayBuffer.isView(attribute.value), `${this._print(attributeName)}: must be typed array or object with value as typed array`);
       if ((attributeName === "POSITION" || attributeName === "positions") && !attribute.size) {
         attribute.size = 3;
       }
       if (attributeName === "indices") {
-        (0, import_core11.assert)(!this.indices);
+        (0, import_core12.assert)(!this.indices);
         this.indices = attribute;
       } else {
         this.attributes[attributeName] = attribute;
@@ -1666,7 +1716,7 @@ var Geometry = class {
   getVertexCount() {
     return this.vertexCount;
   }
-  /** 
+  /**
    * Return an object with all attributes plus indices added as a field.
    * TODO Geometry types are a mess
    */
@@ -1683,10 +1733,10 @@ var Geometry = class {
    * type: indices, vertices, uvs
    * size: elements per vertex
    * target: WebGL buffer type (string or constant)
-   * 
-   * @param attributes 
-   * @param indices 
-   * @returns 
+   *
+   * @param attributes
+   * @param indices
+   * @returns
    */
   _setAttributes(attributes, indices) {
     return this;
@@ -1702,13 +1752,13 @@ var Geometry = class {
         vertexCount = Math.min(vertexCount, value.length / size);
       }
     }
-    (0, import_core11.assert)(Number.isFinite(vertexCount));
+    (0, import_core12.assert)(Number.isFinite(vertexCount));
     return vertexCount;
   }
 };
 
-// src/lib/clip-space.ts
-var CLIPSPACE_VERTEX_SHADER = import_core12.glsl`\
+// dist/lib/clip-space.js
+var CLIPSPACE_VERTEX_SHADER = import_core13.glsl`\
 #version 300 es
 in vec2 aClipSpacePosition;
 in vec2 aTexCoord;
@@ -1729,41 +1779,38 @@ var POSITIONS = [-1, -1, 1, -1, -1, 1, 1, 1];
 var ClipSpace = class extends Model {
   constructor(device, opts) {
     const TEX_COORDS = POSITIONS.map((coord) => coord === -1 ? 0 : coord);
-    super(
-      device,
-      {
-        ...opts,
-        vs: CLIPSPACE_VERTEX_SHADER,
+    super(device, {
+      ...opts,
+      vs: CLIPSPACE_VERTEX_SHADER,
+      vertexCount: 4,
+      geometry: new Geometry({
+        topology: "triangle-strip",
         vertexCount: 4,
-        geometry: new Geometry({
-          topology: "triangle-strip",
-          vertexCount: 4,
-          attributes: {
-            aClipSpacePosition: { size: 2, value: new Float32Array(POSITIONS) },
-            aTexCoord: { size: 2, value: new Float32Array(TEX_COORDS) },
-            aCoordinate: { size: 2, value: new Float32Array(TEX_COORDS) }
-          }
-        })
-      }
-    );
+        attributes: {
+          aClipSpacePosition: { size: 2, value: new Float32Array(POSITIONS) },
+          aTexCoord: { size: 2, value: new Float32Array(TEX_COORDS) },
+          aCoordinate: { size: 2, value: new Float32Array(TEX_COORDS) }
+        }
+      })
+    });
   }
 };
 
-// src/scenegraph/scenegraph-node.ts
-var import_core13 = require("@luma.gl/core");
-var import_core14 = require("@math.gl/core");
+// dist/scenegraph/scenegraph-node.js
+var import_core14 = require("@luma.gl/core");
+var import_core15 = require("@math.gl/core");
 var ScenegraphNode = class {
   id;
-  matrix = new import_core14.Matrix4();
+  matrix = new import_core15.Matrix4();
   display = true;
-  position = new import_core14.Vector3();
-  rotation = new import_core14.Vector3();
-  scale = new import_core14.Vector3(1, 1, 1);
+  position = new import_core15.Vector3();
+  rotation = new import_core15.Vector3();
+  scale = new import_core15.Vector3(1, 1, 1);
   userData = {};
   props = {};
   constructor(props = {}) {
     const { id } = props;
-    this.id = id || (0, import_core13.uid)(this.constructor.name);
+    this.id = id || (0, import_core14.uid)(this.constructor.name);
     this._setScenegraphNodeProps(props);
   }
   getBounds() {
@@ -1783,17 +1830,17 @@ var ScenegraphNode = class {
     return `{type: ScenegraphNode, id: ${this.id})}`;
   }
   setPosition(position) {
-    (0, import_core13.assert)(position.length === 3, "setPosition requires vector argument");
+    (0, import_core14.assert)(position.length === 3, "setPosition requires vector argument");
     this.position = position;
     return this;
   }
   setRotation(rotation) {
-    (0, import_core13.assert)(rotation.length === 3, "setRotation requires vector argument");
+    (0, import_core14.assert)(rotation.length === 3, "setRotation requires vector argument");
     this.rotation = rotation;
     return this;
   }
   setScale(scale) {
-    (0, import_core13.assert)(scale.length === 3, "setScale requires vector argument");
+    (0, import_core14.assert)(scale.length === 3, "setScale requires vector argument");
     this.scale = scale;
     return this;
   }
@@ -1845,9 +1892,9 @@ var ScenegraphNode = class {
     return this;
   }
   getCoordinateUniforms(viewMatrix, modelMatrix) {
-    (0, import_core13.assert)(viewMatrix);
+    (0, import_core14.assert)(viewMatrix);
     modelMatrix = modelMatrix || this.matrix;
-    const worldMatrix = new import_core14.Matrix4(viewMatrix).multiplyRight(modelMatrix);
+    const worldMatrix = new import_core15.Matrix4(viewMatrix).multiplyRight(modelMatrix);
     const worldInverse = worldMatrix.invert();
     const worldInverseTranspose = worldInverse.transpose();
     return {
@@ -1901,39 +1948,35 @@ var ScenegraphNode = class {
   }
 };
 
-// src/scenegraph/group-node.ts
-var import_core15 = require("@math.gl/core");
-var import_core16 = require("@luma.gl/core");
+// dist/scenegraph/group-node.js
+var import_core16 = require("@math.gl/core");
+var import_core17 = require("@luma.gl/core");
 var GroupNode = class extends ScenegraphNode {
   children;
   constructor(props = {}) {
     props = Array.isArray(props) ? { children: props } : props;
     const { children = [] } = props;
-    import_core16.log.assert(
-      children.every((child) => child instanceof ScenegraphNode),
-      "every child must an instance of ScenegraphNode"
-    );
+    import_core17.log.assert(children.every((child) => child instanceof ScenegraphNode), "every child must an instance of ScenegraphNode");
     super(props);
     this.children = children;
   }
   getBounds() {
-    const result = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+    const result = [
+      [Infinity, Infinity, Infinity],
+      [-Infinity, -Infinity, -Infinity]
+    ];
     this.traverse((node, { worldMatrix }) => {
       const bounds = node.getBounds();
       if (!bounds) {
         return;
       }
       const [min, max] = bounds;
-      const center = new import_core15.Vector3(min).add(max).divide([2, 2, 2]);
+      const center = new import_core16.Vector3(min).add(max).divide([2, 2, 2]);
       worldMatrix.transformAsPoint(center, center);
-      const halfSize = new import_core15.Vector3(max).subtract(min).divide([2, 2, 2]);
+      const halfSize = new import_core16.Vector3(max).subtract(min).divide([2, 2, 2]);
       worldMatrix.transformAsVector(halfSize, halfSize);
       for (let v = 0; v < 8; v++) {
-        const position = new import_core15.Vector3(
-          v & 1 ? -1 : 1,
-          v & 2 ? -1 : 1,
-          v & 4 ? -1 : 1
-        ).multiply(halfSize).add(center);
+        const position = new import_core16.Vector3(v & 1 ? -1 : 1, v & 2 ? -1 : 1, v & 4 ? -1 : 1).multiply(halfSize).add(center);
         for (let i = 0; i < 3; i++) {
           result[0][i] = Math.min(result[0][i], position[i]);
           result[1][i] = Math.max(result[1][i], position[i]);
@@ -1973,8 +2016,8 @@ var GroupNode = class extends ScenegraphNode {
     this.children = [];
     return this;
   }
-  traverse(visitor, { worldMatrix = new import_core15.Matrix4() } = {}) {
-    const modelMatrix = new import_core15.Matrix4(worldMatrix).multiplyRight(this.matrix);
+  traverse(visitor, { worldMatrix = new import_core16.Matrix4() } = {}) {
+    const modelMatrix = new import_core16.Matrix4(worldMatrix).multiplyRight(this.matrix);
     for (const child of this.children) {
       if (child instanceof GroupNode) {
         child.traverse(visitor, { worldMatrix: modelMatrix });
@@ -1985,7 +2028,7 @@ var GroupNode = class extends ScenegraphNode {
   }
 };
 
-// src/scenegraph/model-node.ts
+// dist/scenegraph/model-node.js
 var ModelNode = class extends ScenegraphNode {
   model;
   bounds = null;
@@ -2018,11 +2061,11 @@ var ModelNode = class extends ScenegraphNode {
   }
 };
 
-// src/geometries/cone-geometry.ts
-var import_core18 = require("@luma.gl/core");
+// dist/geometries/cone-geometry.js
+var import_core19 = require("@luma.gl/core");
 
-// src/geometries/truncated-cone-geometry.ts
-var import_core17 = require("@luma.gl/core");
+// dist/geometries/truncated-cone-geometry.js
+var import_core18 = require("@luma.gl/core");
 var INDEX_OFFSETS = {
   x: [2, 0, 1],
   y: [0, 1, 2],
@@ -2030,7 +2073,7 @@ var INDEX_OFFSETS = {
 };
 var TruncatedConeGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core17.uid)("truncated-code-geometry") } = props;
+    const { id = (0, import_core18.uid)("truncated-code-geometry") } = props;
     const { indices, attributes } = tesselateTruncatedCone(props);
     super({
       ...props,
@@ -2047,16 +2090,7 @@ var TruncatedConeGeometry = class extends Geometry {
   }
 };
 function tesselateTruncatedCone(props = {}) {
-  const {
-    bottomRadius = 0,
-    topRadius = 0,
-    height = 1,
-    nradial = 10,
-    nvertical = 10,
-    verticalAxis = "y",
-    topCap = false,
-    bottomCap = false
-  } = props;
+  const { bottomRadius = 0, topRadius = 0, height = 1, nradial = 10, nvertical = 10, verticalAxis = "y", topCap = false, bottomCap = false } = props;
   const extra = (topCap ? 2 : 0) + (bottomCap ? 2 : 0);
   const numVertices = (nradial + 1) * (nvertical + 1 + extra);
   const slant = Math.atan2(bottomRadius - topRadius, height);
@@ -2131,10 +2165,10 @@ function tesselateTruncatedCone(props = {}) {
   };
 }
 
-// src/geometries/cone-geometry.ts
+// dist/geometries/cone-geometry.js
 var ConeGeometry = class extends TruncatedConeGeometry {
   constructor(props = {}) {
-    const { id = (0, import_core18.uid)("cone-geometry"), radius = 1, cap = true } = props;
+    const { id = (0, import_core19.uid)("cone-geometry"), radius = 1, cap = true } = props;
     super({
       ...props,
       id,
@@ -2146,11 +2180,11 @@ var ConeGeometry = class extends TruncatedConeGeometry {
   }
 };
 
-// src/geometries/cube-geometry.ts
-var import_core19 = require("@luma.gl/core");
+// dist/geometries/cube-geometry.js
+var import_core20 = require("@luma.gl/core");
 var CubeGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core19.uid)("cube-geometry"), indices = true } = props;
+    const { id = (0, import_core20.uid)("cube-geometry"), indices = true } = props;
     super(indices ? {
       ...props,
       id,
@@ -2756,11 +2790,11 @@ var NON_INDEXED_ATTRIBUTES = {
   COLOR_0: { size: 3, value: CUBE_NON_INDEXED_COLORS }
 };
 
-// src/geometries/cylinder-geometry.ts
-var import_core20 = require("@luma.gl/core");
+// dist/geometries/cylinder-geometry.js
+var import_core21 = require("@luma.gl/core");
 var CylinderGeometry = class extends TruncatedConeGeometry {
   constructor(props = {}) {
-    const { id = (0, import_core20.uid)("cylinder-geometry"), radius = 1 } = props;
+    const { id = (0, import_core21.uid)("cylinder-geometry"), radius = 1 } = props;
     super({
       ...props,
       id,
@@ -2770,14 +2804,14 @@ var CylinderGeometry = class extends TruncatedConeGeometry {
   }
 };
 
-// src/geometries/ico-sphere-geometry.ts
-var import_core21 = require("@luma.gl/core");
-var import_core22 = require("@math.gl/core");
+// dist/geometries/ico-sphere-geometry.js
+var import_core22 = require("@luma.gl/core");
+var import_core23 = 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_core21.uid)("ico-sphere-geometry") } = props;
+    const { id = (0, import_core22.uid)("ico-sphere-geometry") } = props;
     const { indices, attributes } = tesselateIcosaHedron(props);
     super({
       ...props,
@@ -2870,7 +2904,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_core22.Vector3(vec1).cross(vec2).normalize();
+    const normal = new import_core23.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]);
@@ -2918,10 +2952,10 @@ function tesselateIcosaHedron(props) {
   };
 }
 
-// src/geometries/plane-geometry.ts
-var import_core23 = require("@luma.gl/core");
+// dist/geometries/plane-geometry.js
+var import_core24 = require("@luma.gl/core");
 
-// src/geometry/geometry-utils.ts
+// dist/geometry/geometry-utils.js
 function unpackIndexedGeometry(geometry) {
   const { indices, attributes } = geometry;
   if (!indices) {
@@ -2949,10 +2983,10 @@ function unpackIndexedGeometry(geometry) {
   };
 }
 
-// src/geometries/plane-geometry.ts
+// dist/geometries/plane-geometry.js
 var PlaneGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core23.uid)("plane-geometry") } = props;
+    const { id = (0, import_core24.uid)("plane-geometry") } = props;
     const { indices, attributes } = tesselatePlane(props);
     super({
       ...props,
@@ -3041,11 +3075,11 @@ function tesselatePlane(props) {
   return unpack ? unpackIndexedGeometry(geometry) : geometry;
 }
 
-// src/geometries/sphere-geometry.ts
-var import_core24 = require("@luma.gl/core");
+// dist/geometries/sphere-geometry.js
+var import_core25 = require("@luma.gl/core");
 var SphereGeometry = class extends Geometry {
   constructor(props = {}) {
-    const { id = (0, import_core24.uid)("sphere-geometry") } = props;
+    const { id = (0, import_core25.uid)("sphere-geometry") } = props;
     const { indices, attributes } = tesselateSphere(props);
     super({
       ...props,
@@ -3119,3 +3153,4 @@ function tesselateSphere(props) {
     }
   };
 }
+//# sourceMappingURL=index.cjs.map