@luma.gl/engine 9.0.0-alpha.5 → 9.0.0-alpha.50

package/src/index.ts

@@ -1,16 +1,43 @@
 // luma.gl Engine API
-export type {AnimationProps} from './lib/animation-props';
-export {RenderLoop} from './lib/render-loop';
-export type {ModelProps} from './lib/model';
-export {default as Model} from './lib/model';
-export type {AnimationLoopProps} from './lib/animation-loop';
-export {default as AnimationLoop} from './lib/animation-loop';
+
+// Animation
+export {Timeline} from './animation/timeline';
+export {KeyFrames} from './animation/key-frames';
+export type {AnimationProps} from './animation-loop/animation-props';
+
+export {AnimationLoopTemplate} from './animation-loop/render-loop';
+
+export type {AnimationLoopProps} from './animation-loop/animation-loop';
+export {AnimationLoop} from './animation-loop/animation-loop';
+
+export type {MakeAnimationLoopProps} from './animation-loop/make-animation-loop';
+export {makeAnimationLoop} from './animation-loop/make-animation-loop';
+
+export type {ModelProps} from './model/model';
+export {Model} from './model/model';
+
+// Transforms
+export type {BufferTransformProps} from './transform/buffer-transform';
+export {BufferTransform} from './transform/buffer-transform';
+export type {TextureTransformProps} from './transform/texture-transform';
+export {TextureTransform} from './transform/texture-transform';
+
+export {PipelineFactory} from './lib/pipeline-factory';
 
 // Utils
-// export {default as ClipSpace} from './lib/clip-space';
+export {ClipSpace} from './lib/clip-space';
+
+// Scenegraph Core nodes
+export {ScenegraphNode} from './scenegraph/scenegraph-node';
+export {GroupNode} from './scenegraph/group-node';
+export type {ModelNodeProps} from './scenegraph/model-node';
+export {ModelNode} from './scenegraph/model-node';
 
 // Geometries
-export {default as Geometry} from './geometry/geometry';
+export type {GeometryProps} from './geometry/geometry';
+export {Geometry} from './geometry/geometry';
+export type {GPUGeometryProps} from './geometry/gpu-geometry';
+export {GPUGeometry} from './geometry/gpu-geometry';
 
 // Primitives
 export type {ConeGeometryProps} from './geometries/cone-geometry';
@@ -28,7 +55,6 @@ export {SphereGeometry} from './geometries/sphere-geometry';
 export type {TruncatedConeGeometryProps} from './geometries/truncated-cone-geometry';
 export {TruncatedConeGeometry} from './geometries/truncated-cone-geometry';
 
-// Animation
-export {Timeline} from './animation/timeline';
-export {KeyFrames} from './animation/key-frames';
-
+// EXPERIMENTAL
+export type {ShaderModuleInputs} from './shader-inputs';
+export {ShaderInputs as _ShaderInputs} from './shader-inputs';

package/src/lib/clip-space.ts

@@ -1,18 +1,17 @@
 
 // ClipSpace
-/*
-import GL from '@luma.gl/constants';
-import Model, {ModelProps} from './model';
-import Geometry from '../geometry/geometry';
+import {Device, glsl} from '@luma.gl/core';
+import {Model, ModelProps} from '../model/model';
+import {Geometry} from '../geometry/geometry';
 
-const CLIPSPACE_VERTEX_SHADER = `\
-attribute vec2 aClipSpacePosition;
-attribute vec2 aTexCoord;
-attribute vec2 aCoordinate;
+const CLIPSPACE_VERTEX_SHADER = glsl`\
+in vec2 aClipSpacePosition;
+in vec2 aTexCoord;
+in vec2 aCoordinate;
 
-varying vec2 position;
-varying vec2 coordinate;
-varying vec2 uv;
+out vec2 position;
+out vec2 coordinate;
+out vec2 uv;
 
 void main(void) {
   gl_Position = vec4(aClipSpacePosition, 0., 1.);
@@ -22,20 +21,24 @@ void main(void) {
 }
 `;
 
-/* eslint-disable indent, no-multi-spaces *
+/* eslint-disable indent, no-multi-spaces */
 const POSITIONS = [-1, -1, 1, -1, -1, 1, 1, 1];
 
-
-export default class ClipSpace extends Model {
-  constructor(gl: WebGLRenderingContext, opts?: ModelProps) {
+/**
+ * A flat geometry that covers the "visible area" that the GPU renders.
+ */
+export class ClipSpace extends Model {
+  constructor(device: Device, opts?: ModelProps) {
     const TEX_COORDS = POSITIONS.map((coord) => (coord === -1 ? 0 : coord));
 
     super(
-      gl,
-      Object.assign({}, opts, {
+      device,
+      {
+        ...opts,
         vs: CLIPSPACE_VERTEX_SHADER,
+        vertexCount: 4,
         geometry: new Geometry({
-          drawMode: GL.TRIANGLE_STRIP,
+          topology: 'triangle-strip',
           vertexCount: 4,
           attributes: {
             aClipSpacePosition: {size: 2, value: new Float32Array(POSITIONS)},
@@ -43,9 +46,7 @@ export default class ClipSpace extends Model {
             aCoordinate: {size: 2, value: new Float32Array(TEX_COORDS)}
           }
         })
-      })
+      }
     );
-    this.setVertexCount(4);
   }
 }
-*/

package/src/lib/pipeline-factory.ts

@@ -1,122 +1,60 @@
-import type {RenderPipelineProps, RenderPipelineParameters} from '@luma.gl/api';
-import {Device, RenderPipeline, ComputePipeline} from '@luma.gl/api/';
-import type { ShaderModule } from '@luma.gl/shadertools';
-import {assembleShaders} from '@luma.gl/shadertools';
-
-export type GetRenderPipelineOptions = {
-  vs: string,
-  fs: string,
-  topology;
-  parameters?: RenderPipelineParameters;
-
-  modules?: ShaderModule[];
-  defines?: Record<string, string>,
-  inject?: Record<string, string>,
-  transpileToGLSL100?: boolean;
-
-  varyings?: string[],
-  bufferMode?: number,  
+// luma.gl, MIT license
+import type {RenderPipelineProps} from '@luma.gl/core';
+import {Device, RenderPipeline} from '@luma.gl/core';
+
+/** Todo - should be same as RenderPipelineProps */
+export type PipelineFactoryProps = Omit<RenderPipelineProps, 'vs' | 'fs'> & {
+  // Only accepts string shaders
+  vs: string;
+  fs: string;
 };
 
-export type GetComputePipelineOptions = {
-  cs: string,
-  parameters?: RenderPipelineParameters;
-
-  modules?: ShaderModule[];
-  defines?: Record<string, string>,
-  inject?: Record<string, string>,
-  transpileToGLSL100?: boolean;
-
-  varyings?: string[],
-  bufferMode?: number,
-};
-
-const DEFAULT_RENDER_PIPELINE_OPTIONS: Required<GetRenderPipelineOptions> = {
-  vs: '',
-  fs: '',
-  modules: [],
-  defines: {},
-  inject: {},
-  transpileToGLSL100: false,
-
-  varyings: [],
-  bufferMode: 0x8c8d, // // varyings/bufferMode for xform feedback, 0x8c8d: SEPARATE_ATTRIBS
-  topology: 'triangle-list',
-  parameters: {} 
-};
+/** 
+ * Efficiently creates / caches pipelines
+ */
+export class PipelineFactory {
+  static defaultProps: Required<PipelineFactoryProps> = {
+    ...RenderPipeline.defaultProps,
+    vs: undefined!,
+    fs: undefined!
+  }
 
-/** Efficiently create shared pipelines with varying parameters */
-export default class PipelineFactory {
   readonly device: Device;
 
-  stateHash: number = 0; // Used to change hashing if hooks are modified
   private _hashCounter: number = 0;
   private readonly _hashes: Record<string, number> = {};
   private readonly _useCounts: Record<string, number> = {};
-
   private readonly _pipelineCache: Record<string, RenderPipeline> = {};
 
-  private readonly _getUniforms: Record<string, any> = {};
-  private readonly _hookFunctions: any[] = [];
-  private _defaultModules: any[] = [];
-  // private readonly _registeredModules = {}; // TODO: Remove? This isn't used anywhere in luma.gl
-
   static getDefaultPipelineFactory(device: Device): PipelineFactory {
-    // @ts-expect-error Add to device
-    device.defaultPipelineFactory = device.defaultPipelineFactory || new PipelineFactory(device);
-    // @ts-expect-error Add to device
-    return device.defaultPipelineFactory;
+    device._lumaData.defaultPipelineFactory = device._lumaData.defaultPipelineFactory || new PipelineFactory(device);
+    return device._lumaData.defaultPipelineFactory as PipelineFactory;
   }
 
   constructor(device: Device) {
     this.device = device;
   }
 
-  // addDefaultModule(module: ShaderModule): void {
-  //   if (!this._defaultModules.find((m) => m.name === (typeof module === 'string' ? module : module.name))) {
-  //     this._defaultModules.push(module);
-  //   }
-  //   this.stateHash++;
-  // }
-
-  // removeDefaultModule(module: ShaderModule): void {
-  //   const moduleName = typeof module === 'string' ? module : module.name;
-  //   this._defaultModules = this._defaultModules.filter((m) => m.name !== moduleName);
-  //   this.stateHash++;
-  // }
-
-  addShaderHook(hook, opts?): void {
-    if (opts) {
-      hook = Object.assign(opts, {hook});
-    }
-    this._hookFunctions.push(hook);
-    this.stateHash++;
-  }
-
-  createRenderPipeline(options: GetRenderPipelineOptions): {
-    renderPipeline: RenderPipeline;
-    getUniforms: (props: Record<string, Record<string, any>>) => Record<string, any>;
-  } {
-    const props: Required<GetRenderPipelineOptions> = {...DEFAULT_RENDER_PIPELINE_OPTIONS, ...options};
-
-    const modules = this._getModuleList(props.modules); // Combine with default modules
+  createRenderPipeline(options: PipelineFactoryProps): RenderPipeline {
+    const props: Required<PipelineFactoryProps> = {...PipelineFactory.defaultProps, ...options};
 
-    const hash = this._hashRenderPipeline({...props, modules});
+    const hash = this._hashRenderPipeline({...props});
 
     if (!this._pipelineCache[hash]) {
-      const {renderPipeline, getUniforms} = this._createRenderPipeline({...props, modules});
-      renderPipeline.hash = hash;
-      this._pipelineCache[hash] = renderPipeline;
-      this._getUniforms[hash] = getUniforms || ((x: Record<string, Record<string, any>>) => {});
+      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,
+      });
+
+      pipeline.hash = hash;
+      this._pipelineCache[hash] = pipeline;
       this._useCounts[hash] = 0;
     }
 
     this._useCounts[hash]++;
 
-    return {
-      renderPipeline: this._pipelineCache[hash],
-      getUniforms: this._getUniforms[hash]
-    };
+    return this._pipelineCache[hash];
   }
 
   release(pipeline: RenderPipeline): void {
@@ -125,68 +63,48 @@ export default class PipelineFactory {
     if (this._useCounts[hash] === 0) {
       this._pipelineCache[hash].destroy();
       delete this._pipelineCache[hash];
-      delete this._getUniforms[hash];
       delete this._useCounts[hash];
     }
   }
 
-  getUniforms(pipeline: RenderPipeline) {
-    return this._getUniforms[pipeline.hash] || null;
-  }
-
   // PRIVATE
 
-  _createRenderPipeline(props: GetRenderPipelineOptions): {
-    renderPipeline: RenderPipeline,
-    getUniforms: (props: Record<string, Record<string, any>>) => Record<string, any>
-  } {
-    const platformInfo = {
-      gpu: this.device.info.gpu,
-      features: this.device.features
-    };
-
-    const assembled = assembleShaders(platformInfo, {...props, hookFunctions: this._hookFunctions});
+  _createRenderPipeline(props: PipelineFactoryProps): RenderPipeline {
+    if (!props.fs) {
+      throw new Error('fs');
+    }
 
-    const renderPipeline = this.device.createRenderPipeline({
+    const pipeline = this.device.createRenderPipeline({
       ...props,
-      vs: this.device.createShader({stage: 'vertex', source: assembled.vs}),
-      fs: assembled.fs && this.device.createShader({stage: 'fragment', source: assembled.fs}),
+      vs: this.device.createShader({stage: 'vertex', source: props.vs}),
+      fs: props.fs ? this.device.createShader({stage: 'fragment', source: props.fs}) : null,
     });
 
-    return {renderPipeline, getUniforms: assembled.getUniforms};
+    return pipeline;
   }
 
   /** Calculate a hash based on all the inputs for a render pipeline */
-  _hashRenderPipeline(props: GetRenderPipelineOptions): string {
+  _hashRenderPipeline(props: PipelineFactoryProps): string {
     const vsHash = this._getHash(props.vs);
-    const fsHash = this._getHash(props.fs);
-
-    const moduleHashes = props.modules.map((m) => this._getHash(typeof m === 'string' ? m : m.name)).sort();
-    const varyingHashes = props.varyings.map((v) => this._getHash(v));
-
-    const defineKeys = Object.keys(props.defines).sort();
-    const injectKeys = Object.keys(props.inject).sort();
-    const defineHashes = [];
-    const injectHashes = [];
-
-    for (const key of defineKeys) {
-      defineHashes.push(this._getHash(key));
-      defineHashes.push(this._getHash(props.defines[key]));
-    }
-
-    for (const key of injectKeys) {
-      injectHashes.push(this._getHash(key));
-      injectHashes.push(this._getHash(props.inject[key]));
+    const fsHash = props.fs ? this._getHash(props.fs) : 0;
+
+    // WebGL specific
+    // const {varyings = [], bufferMode = {}} = props;
+    // const varyingHashes = varyings.map((v) => this._getHash(v));
+    const varyingHash = '-'; // `${varyingHashes.join('/')}B${bufferMode}`
+
+    switch (this.device.info.type) {
+      case 'webgpu':
+        // On WebGPU we need to rebuild the pipeline if topology, parameters or bufferLayout change
+        const parameterHash = this._getHash(JSON.stringify(props.parameters));
+        const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
+        // TODO - Can json.stringify() generate different strings for equivalent objects if order of params is different?
+        // create a deepHash() to deduplicate?
+        return `${vsHash}/${fsHash}V${varyingHash}T${props.topology}P${parameterHash}BL${bufferLayoutHash}}`;
+      default:
+        // WebGL is more dynamic
+        return `${vsHash}/${fsHash}V${varyingHash}`;
     }
-
-    // TODO - hash parameters!
-    const parameterHash = JSON.stringify(props.parameters);
-
-    return `${vsHash}/${fsHash}D${defineHashes.join('/')}M${moduleHashes.join(
-      '/'
-    )}I${injectHashes.join('/')}V${varyingHashes.join('/')}H${this.stateHash}B${props.bufferMode}${
-      props.transpileToGLSL100 ? 'T' : ''
-    }P${parameterHash}`;
   }
 
   _getHash(key: string): number {
@@ -195,31 +113,5 @@ export default class PipelineFactory {
     }
     return this._hashes[key];
   }
-
-  // Dedupe and combine with default modules
-  _getModuleList(appModules: ShaderModule[] = []): ShaderModule[] {
-    const modules = new Array(this._defaultModules.length + appModules.length);
-    const seen: Record<string, boolean> = {};
-    let count = 0;
-
-    for (let i = 0, len = this._defaultModules.length; i < len; ++i) {
-      const module = this._defaultModules[i];
-      const name = module.name;
-      modules[count++] = module;
-      seen[name] = true;
-    }
-
-    for (let i = 0, len = appModules.length; i < len; ++i) {
-      const module = appModules[i];
-      const name = module.name;
-      if (!seen[name]) {
-        modules[count++] = module;
-        seen[name] = true;
-      }
-    }
-
-    modules.length = count;
-
-    return modules;
-  }
 }
+