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

package/src/model/model.ts

@@ -1,25 +1,21 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {TypedArray, RenderPipelineProps, RenderPipelineParameters} from '@luma.gl/core';
-import type {BufferLayout, VertexArray, TransformFeedback} from '@luma.gl/core';
+import type {TypedArray} from '@luma.gl/core';
+import type {DeviceFeature, RenderPipelineProps, RenderPipelineParameters} from '@luma.gl/core';
+import type {Shader, BufferLayout, VertexArray, TransformFeedback} from '@luma.gl/core';
 import type {AttributeInfo, Binding, UniformValue, PrimitiveTopology} from '@luma.gl/core';
-import {
-  Device,
-  Buffer,
-  RenderPipeline,
-  RenderPass,
-  UniformStore,
-  getTypedArrayFromDataType
-} from '@luma.gl/core';
+import {Device, Buffer, RenderPipeline, RenderPass, UniformStore} from '@luma.gl/core';
 import {log, uid, deepEqual, splitUniformsAndBindings, isNumberArray} from '@luma.gl/core';
-import {getAttributeInfosFromLayouts} from '@luma.gl/core';
+import {getTypedArrayFromDataType, getAttributeInfosFromLayouts} from '@luma.gl/core';
 import type {ShaderModule, PlatformInfo} from '@luma.gl/shadertools';
 import {ShaderAssembler, getShaderLayoutFromWGSL} from '@luma.gl/shadertools';
 import {ShaderInputs} from '../shader-inputs';
 import type {Geometry} from '../geometry/geometry';
 import {GPUGeometry, makeGPUGeometry} from '../geometry/gpu-geometry';
 import {PipelineFactory} from '../lib/pipeline-factory';
+import {ShaderFactory} from '../lib/shader-factory';
 import {getDebugTableForShaderLayout} from '../debug/debug-shader-layout';
 import {debugFramebuffer} from '../debug/debug-framebuffer';
 
@@ -30,6 +26,7 @@ export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
   source?: string;
   vs: {glsl?: string; wgsl?: string} | string | null;
   fs: {glsl?: string; wgsl?: string} | string | null;
+
   /** shadertool shader modules (added to shader code) */
   modules?: ShaderModule[];
   /** Shadertool module defines (configures shader code)*/
@@ -38,8 +35,10 @@ export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
 
   /** Shader inputs, used to generated uniform buffers and bindings */
   shaderInputs?: ShaderInputs;
-  /** pipeline factory to use to create render pipelines. Defaults to default factory for the device */
+  /** Factory used to create a {@link RenderPipeline}. Defaults to {@link Device} default factory. */
   pipelineFactory?: PipelineFactory;
+  /** Factory used to create a {@link Shader}. Defaults to {@link Device} default factory. */
+  shaderFactory?: ShaderFactory;
   /** Shader assembler. Defaults to the ShaderAssembler.getShaderAssembler() */
   shaderAssembler?: ShaderAssembler;
 
@@ -59,6 +58,8 @@ export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
   attributes?: Record<string, Buffer>;
   /**   */
   constantAttributes?: Record<string, TypedArray>;
+  /** Some applications intentionally supply unused attributes */
+  ignoreUnknownAttributes?: boolean;
 
   /** @internal For use with {@link TransformFeedback}, WebGL only. */
   varyings?: string[];
@@ -67,6 +68,9 @@ export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
 
   /** Mapped uniforms for shadertool modules */
   moduleSettings?: Record<string, Record<string, any>>;
+
+  /** Show shader source in browser? */
+  debugShaders?: 'never' | 'errors' | 'warnings' | 'always';
 };
 
 /**
@@ -97,8 +101,12 @@ export class Model {
 
     shaderInputs: undefined!,
     pipelineFactory: undefined!,
+    shaderFactory: undefined!,
     transformFeedback: undefined,
-    shaderAssembler: ShaderAssembler.getDefaultShaderAssembler()
+    shaderAssembler: ShaderAssembler.getDefaultShaderAssembler(),
+
+    debugShaders: undefined,
+    ignoreUnknownAttributes: undefined
   };
 
   readonly device: Device;
@@ -106,6 +114,7 @@ export class Model {
   readonly vs: string;
   readonly fs: string;
   readonly pipelineFactory: PipelineFactory;
+  readonly shaderFactory: ShaderFactory;
   userData: {[key: string]: any} = {};
 
   // Fixed properties (change can trigger pipeline rebuild)
@@ -160,6 +169,8 @@ export class Model {
   private _getModuleUniforms: (props?: Record<string, Record<string, any>>) => Record<string, any>;
   private props: Required<ModelProps>;
 
+  private _destroyed = false;
+
   constructor(device: Device, props: ModelProps) {
     this.props = {...Model.defaultProps, ...props};
     props = this.props;
@@ -221,6 +232,7 @@ export class Model {
 
     this.pipelineFactory =
       props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
+    this.shaderFactory = props.shaderFactory || ShaderFactory.getDefaultShaderFactory(this.device);
 
     // Create the pipeline
     // @note order is important
@@ -250,7 +262,9 @@ export class Model {
       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);
@@ -269,16 +283,17 @@ export class Model {
       this.transformFeedback = props.transformFeedback;
     }
 
-    // TODO - restore?
-    // this.setUniforms(this._getModuleUniforms()); // Get all default module uniforms
-
     // Catch any access to non-standard props
     Object.seal(this);
   }
 
   destroy(): void {
+    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
@@ -301,11 +316,13 @@ export class Model {
       // Set pipeline state, we may be sharing a pipeline so we need to set all state on every draw
       // Any caching needs to be done inside the pipeline functions
       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) : undefined;
-  
+      const indexCount = indexBuffer
+        ? indexBuffer.byteLength / (indexBuffer.indexType === 'uint32' ? 4 : 2)
+        : undefined;
+
       this.pipeline.draw({
         renderPass,
         vertexArray: this.vertexArray,
@@ -357,8 +374,8 @@ export class Model {
     // TODO - delete previous geometry?
     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});
   }
 
   /**
@@ -374,7 +391,7 @@ export class Model {
 
   /**
    * Updates the buffer layout.
-   * @note Triggers a pipeline rebuild / pipeline cache fetch on WebGPU
+   * @note Triggers a pipeline rebuild / pipeline cache fetch
    */
   setBufferLayout(bufferLayout: BufferLayout[]): void {
     this.bufferLayout = this._gpuGeometry
@@ -484,7 +501,7 @@ export class Model {
    * @returns self for chaining
    */
   setUniforms(uniforms: Record<string, UniformValue>): void {
-    this.pipeline.setUniforms(uniforms);
+    this.pipeline.setUniformsWebGL(uniforms);
     Object.assign(this.uniforms, uniforms);
   }
 
@@ -507,14 +524,19 @@ export class Model {
    * Sets attributes (buffers)
    * @note Overrides any attributes previously set with the same name
    */
-  setAttributes(buffers: Record<string, Buffer>, _option?: 'ignore-unknown'): void {
+  setAttributes(
+    buffers: Record<string, Buffer>,
+    options?: {ignoreUnknownAttributes?: boolean}
+  ): void {
     if (buffers.indices) {
       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));
+      const bufferLayout = this.bufferLayout.find(layout =>
+        getAttributeNames(layout).includes(bufferName)
+      );
       if (!bufferLayout) {
         log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
         continue; // eslint-disable-line no-continue
@@ -530,7 +552,7 @@ export class Model {
           set = true;
         }
       }
-      if (!set && _option !== 'ignore-unknown') {
+      if (!set && (options?.ignoreUnknownAttributes || this.props.ignoreUnknownAttributes)) {
         log.warn(
           `Model(${this.id}): Ignoring buffer "${buffer.id}" for unknown attribute "${bufferName}"`
         )();
@@ -550,7 +572,7 @@ export class Model {
     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 {
         log.warn(
           `Model "${this.id}: Ignoring constant supplied for unknown attribute "${attributeName}"`
@@ -565,27 +587,33 @@ export class Model {
 
   _updatePipeline(): RenderPipeline {
     if (this._pipelineNeedsUpdate) {
+      let prevShaderVs: Shader | null = null;
+      let prevShaderFs: Shader | null = null;
       if (this.pipeline) {
         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({
-          id: `${this.id}-fragment`,
-          stage: 'fragment',
-          source: this.fs
-        })
+        ? this.shaderFactory.createShader({
+            id: `${this.id}-fragment`,
+            stage: 'fragment',
+            source: this.fs,
+            debug: this.props.debugShaders
+          })
         : null;
 
       this.pipeline = this.pipelineFactory.createRenderPipeline({
@@ -601,6 +629,9 @@ export class Model {
         this.pipeline.shaderLayout,
         this.bufferLayout
       );
+
+      if (prevShaderVs) this.shaderFactory.release(prevShaderVs);
+      if (prevShaderFs) this.shaderFactory.release(prevShaderFs);
     }
     return this.pipeline;
   }
@@ -651,7 +682,7 @@ export class Model {
     const debugFramebuffers = log.get('framebuffer');
     this._drawCount++;
     // Update first 3 frames and then every 60 frames
-    if (!debugFramebuffers || ((this._drawCount++ > 3) && (this._drawCount % 60))) {
+    if (!debugFramebuffers || (this._drawCount++ > 3 && this._drawCount % 60)) {
       return;
     }
     // TODO - display framebuffer output in debug window
@@ -721,7 +752,8 @@ export function getPlatformInfo(device: Device): PlatformInfo {
     shaderLanguage: device.info.shadingLanguage,
     shaderLanguageVersion: device.info.shadingLanguageVersion as 100 | 300,
     gpu: device.info.gpu,
-    features: device.features
+    // HACK - we pretend that the DeviceFeatures is a Set, it has a similar API
+    features: device.features as unknown as Set<DeviceFeature>
   };
 }
 

package/src/scenegraph/group-node.ts

@@ -4,7 +4,7 @@ import {ScenegraphNode, ScenegraphNodeProps} from './scenegraph-node';
 
 export type GroupNodeProps = ScenegraphNodeProps & {
   children?: ScenegraphNode[];
-}
+};
 
 export class GroupNode extends ScenegraphNode {
   children: ScenegraphNode[];
@@ -16,7 +16,7 @@ export class GroupNode extends ScenegraphNode {
     props = Array.isArray(props) ? {children: props} : props;
     const {children = []} = props;
     log.assert(
-      children.every((child) => child instanceof ScenegraphNode),
+      children.every(child => child instanceof ScenegraphNode),
       'every child must an instance of ScenegraphNode'
     );
     super(props);
@@ -24,7 +24,10 @@ export class GroupNode extends ScenegraphNode {
   }
 
   override getBounds(): [number[], number[]] | null {
-    const result: [number[], number[]] = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+    const result: [number[], number[]] = [
+      [Infinity, Infinity, Infinity],
+      [-Infinity, -Infinity, -Infinity]
+    ];
 
     this.traverse((node, {worldMatrix}) => {
       const bounds = node.getBounds();
@@ -39,11 +42,9 @@ export class GroupNode extends ScenegraphNode {
 
       for (let v = 0; v < 8; v++) {
         // Test all 8 corners of the box
-        const position = new Vector3(
-          v & 0b001 ? -1 : 1,
-          v & 0b010 ? -1 : 1,
-          v & 0b100 ? -1 : 1
-        ).multiply(halfSize).add(center);
+        const position = new Vector3(v & 0b001 ? -1 : 1, v & 0b010 ? -1 : 1, v & 0b100 ? -1 : 1)
+          .multiply(halfSize)
+          .add(center);
 
         for (let i = 0; i < 3; i++) {
           result[0][i] = Math.min(result[0][i], position[i]);
@@ -58,7 +59,7 @@ export class GroupNode extends ScenegraphNode {
   }
 
   override destroy(): void {
-    this.children.forEach((child) => child.destroy());
+    this.children.forEach(child => child.destroy());
     this.removeAll();
     super.destroy();
   }
@@ -89,7 +90,10 @@ export class GroupNode extends ScenegraphNode {
     return this;
   }
 
-  traverse(visitor: (node: ScenegraphNode, context: {worldMatrix: Matrix4}) => void, {worldMatrix = new Matrix4()} = {}) {
+  traverse(
+    visitor: (node: ScenegraphNode, context: {worldMatrix: Matrix4}) => void,
+    {worldMatrix = new Matrix4()} = {}
+  ) {
     const modelMatrix = new Matrix4(worldMatrix).multiplyRight(this.matrix);
 
     for (const child of this.children) {

package/src/scenegraph/model-node.ts

@@ -6,7 +6,7 @@ export type ModelNodeProps = ScenegraphNodeProps & {
   model: Model;
   managedResources?: any[];
   bounds?: [number[], number[]];
-}
+};
 
 export class ModelNode extends ScenegraphNode {
   readonly model: Model;
@@ -38,7 +38,7 @@ export class ModelNode extends ScenegraphNode {
       // @ts-expect-error
       this.model = null;
     }
-    this.managedResources.forEach((resource) => resource.destroy());
+    this.managedResources.forEach(resource => resource.destroy());
     this.managedResources = [];
   }
 

package/src/scenegraph/scenegraph-node.ts

@@ -10,14 +10,14 @@ export type ScenegraphNodeProps = {
   position?: NumberArray;
   rotation?: NumberArray;
   scale?: NumberArray;
-  update?: boolean
+  update?: boolean;
 };
 
 export class ScenegraphNode {
   readonly id: string;
   matrix: Matrix4 = new Matrix4();
 
-  display = true; 
+  display = true;
   position = new Vector3();
   rotation = new Vector3();
   scale = new Vector3(1, 1, 1);

package/src/shader-inputs.ts

@@ -1,9 +1,11 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {UniformValue, Texture, Sampler} from '@luma.gl/core';
 import {log} from '@luma.gl/core';
 // import type {ShaderUniformType, UniformValue, UniformFormat, UniformInfoDevice, Texture, Sampler} from '@luma.gl/core';
-import {_resolveModules, ShaderModuleInstance} from '@luma.gl/shadertools'
-
+import {_resolveModules, ShaderModuleInstance} from '@luma.gl/shadertools';
 
 /** Minimal ShaderModule subset, we don't need shader code etc */
 export type ShaderModuleInputs<
@@ -40,8 +42,8 @@ export class ShaderInputs<
     Record<string, Record<string, unknown>>
   >
 > {
-  /** 
-   * The map of modules 
+  /**
+   * The map of modules
    * @todo should should this include the resolved dependencies?
    */
   modules: Readonly<{[P in keyof ShaderPropsT]: ShaderModuleInputs<ShaderPropsT[P]>}>;
@@ -59,8 +61,12 @@ export class ShaderInputs<
    */
   constructor(modules: {[P in keyof ShaderPropsT]: ShaderModuleInputs<ShaderPropsT[P]>}) {
     // TODO - get all dependencies from modules
-    const allModules =_resolveModules(Object.values(modules));
-    log.log(1, 'Creating ShaderInputs with modules', allModules.map(m => m.name))();
+    const allModules = _resolveModules(Object.values(modules));
+    log.log(
+      1,
+      'Creating ShaderInputs with modules',
+      allModules.map(m => m.name)
+    )();
 
     // Store the module definitions and create storage for uniform values and binding values, per module
     this.modules = modules;
@@ -94,8 +100,9 @@ export class ShaderInputs<
         continue; // eslint-disable-line no-continue
       }
 
-      const oldUniforms = this.moduleUniforms[moduleName];  
-      const uniforms = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || moduleProps as any;
+      const oldUniforms = this.moduleUniforms[moduleName];
+      const uniforms =
+        module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || (moduleProps as any);
       // console.error(uniforms)
       this.moduleUniforms[moduleName] = {...oldUniforms, ...uniforms};
       // this.moduleUniformsChanged ||= moduleName;
@@ -113,8 +120,8 @@ export class ShaderInputs<
   //   return this.moduleUniforms;
   // }
 
-  /** 
-   * Return the map of modules 
+  /**
+   * Return the map of modules
    * @todo should should this include the resolved dependencies?
    */
   getModules(): ShaderModuleInstance[] {
@@ -136,7 +143,7 @@ export class ShaderInputs<
   }
 
   getDebugTable(): Record<string, Record<string, unknown>> {
-    const table: Record<string,Record<string, unknown>> = {};
+    const table: Record<string, Record<string, unknown>> = {};
     for (const [moduleName, module] of Object.entries(this.moduleUniforms)) {
       for (const [key, value] of Object.entries(module)) {
         table[`${moduleName}.${key}`] = {

package/src/transform/buffer-transform.ts

@@ -1,10 +1,18 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Device, Buffer, BufferRange, TransformFeedback, assert, RenderPassProps} from '@luma.gl/core';
+import {
+  Device,
+  Buffer,
+  BufferRange,
+  TransformFeedback,
+  assert,
+  RenderPassProps
+} from '@luma.gl/core';
 import {getPassthroughFS} from '@luma.gl/shadertools';
 import {Model} from '../model/model';
-import type { ModelProps } from '..';
+import type {ModelProps} from '..';
 
 /**
  * Properties for creating a {@link BufferTransform}
@@ -26,11 +34,11 @@ export class BufferTransform {
 
   /** @deprecated Use device feature test. */
   static isSupported(device: Device): boolean {
-    return device.features.has('transform-feedback-webgl');
+    return device?.info?.type === 'webgl';
   }
 
   constructor(device: Device, props: BufferTransformProps = Model.defaultProps) {
-    assert(device.features.has('transform-feedback-webgl'), 'Device must support transform feedback');
+    assert(BufferTransform.isSupported(device), 'BufferTransform not yet implemented on WebGPU');
 
     this.device = device;
 
@@ -38,12 +46,12 @@ export class BufferTransform {
       id: props.id || 'buffer-transform-model',
       fs: props.fs || getPassthroughFS(),
       topology: props.topology || 'point-list',
-      ...props,
+      ...props
     });
 
     this.transformFeedback = this.device.createTransformFeedback({
       layout: this.model.pipeline.shaderLayout,
-      buffers: props.feedbackBuffers,
+      buffers: props.feedbackBuffers
     });
 
     this.model.setTransformFeedback(this.transformFeedback);

package/src/transform/texture-transform.ts

@@ -1,9 +1,10 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import { Buffer, Device, Framebuffer, RenderPassProps, Sampler, Texture } from '@luma.gl/core';
-import { Model, ModelProps } from '../model/model';
-import { getPassthroughFS } from '@luma.gl/shadertools';
+import {Buffer, Device, Framebuffer, RenderPassProps, Sampler, Texture} from '@luma.gl/core';
+import {Model, ModelProps} from '../model/model';
+import {getPassthroughFS} from '@luma.gl/shadertools';
 
 /**
  * Properties for creating a {@link TextureTransform}
@@ -24,7 +25,6 @@ export type TextureTransformProps = Omit<ModelProps, 'fs'> & {
   targetTextureVarying: string;
 };
 
-
 type TextureBinding = {
   sourceBuffers: Record<string, Buffer>;
   sourceTextures: Record<string, Texture>;
@@ -42,7 +42,7 @@ export class TextureTransform {
   readonly device: Device;
   readonly model: Model;
   readonly sampler: Sampler;
-  
+
   currentIndex = 0;
   samplerTextureMap: Record<string, any> | null = null;
   bindings: TextureBinding[] = []; // each element is an object : {sourceTextures, targetTexture, framebuffer}
@@ -57,16 +57,18 @@ export class TextureTransform {
       addressModeV: 'clamp-to-edge',
       minFilter: 'nearest',
       magFilter: 'nearest',
-      mipmapFilter: 'nearest',
+      mipmapFilter: 'nearest'
     });
 
     this.model = new Model(this.device, {
       id: props.id || 'texture-transform-model',
-      fs: props.fs || getPassthroughFS({
-        input: props.targetTextureVarying,
-        inputChannels: props.targetTextureChannels,
-        output: FS_OUTPUT_VARIABLE
-      }),
+      fs:
+        props.fs ||
+        getPassthroughFS({
+          input: props.targetTextureVarying,
+          inputChannels: props.targetTextureChannels,
+          output: FS_OUTPUT_VARIABLE
+        }),
       vertexCount: props.vertexCount, // TODO(donmccurdy): Naming?
       ...props
     });
@@ -109,7 +111,6 @@ export class TextureTransform {
     return targetTexture;
   }
 
-
   getFramebuffer(): Framebuffer {
     const currentResources = this.bindings[this.currentIndex];
     return currentResources.framebuffer;