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

package/src/geometries/plane-geometry.ts

@@ -5,7 +5,7 @@ import {unpackIndexedGeometry} from '../geometry/geometry-utils';
 export type PlaneGeometryProps = {
   id?: string;
   radius?: number;
-  attributes?: any
+  attributes?: any;
 };
 
 // Primitives inspired by TDL http://code.google.com/p/webglsamples/,

package/src/geometries/sphere-geometry.ts

@@ -6,7 +6,7 @@ export type SphereGeometryProps = {
   radius?: number;
   nlat?: number;
   nlong?: number;
-  attributes?: any
+  attributes?: any;
 };
 
 // Primitives inspired by TDL http://code.google.com/p/webglsamples/,

package/src/geometries/truncated-cone-geometry.ts

@@ -36,7 +36,8 @@ export class TruncatedConeGeometry extends Geometry {
         POSITION: {size: 3, value: attributes.POSITION},
         NORMAL: {size: 3, value: attributes.NORMAL},
         TEXCOORD_0: {size: 2, value: attributes.TEXCOORD_0},
-        ...props.attributes}
+        ...props.attributes
+      }
     });
   }
 }

package/src/geometry/geometry-table.ts

@@ -1,4 +1,7 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {TypedArray, VertexFormat} from '@luma.gl/core';
 
 /** Holds one geometry */
@@ -6,11 +9,11 @@ export type GeometryTable = {
   length: number;
   schema?: Record<string, VertexFormat>;
   attributes: {
-    POSITION: TypedArray,
-    NORMAL: TypedArray,
-    TEXCOORD_0: TypedArray,
-    [key: string]: TypedArray,
+    POSITION: TypedArray;
+    NORMAL: TypedArray;
+    TEXCOORD_0: TypedArray;
+    [key: string]: TypedArray;
   };
   indices?: Uint16Array | Uint32Array;
   topology?: 'point-list' | 'line-list' | 'line-strip' | 'triangle-list' | 'triangle-strip';
-}
+};

package/src/geometry/geometry-utils.ts

@@ -44,4 +44,4 @@ export function unpackIndexedGeometry(geometry: any) {
 //     normals.set(normal[2], i + 2);
 //   }
 //   const normal = new Vector3(vec1).cross(vec2).normalize();
-// }
+// }

package/src/geometry/geometry.ts

@@ -1,4 +1,7 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {PrimitiveTopology, TypedArray} from '@luma.gl/core';
 import {uid, assert} from '@luma.gl/core';
 
@@ -98,7 +101,7 @@ export class Geometry {
     return this.vertexCount;
   }
 
-  /** 
+  /**
    * Return an object with all attributes plus indices added as a field.
    * TODO Geometry types are a mess
    */
@@ -118,10 +121,10 @@ export class Geometry {
    * 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: Record<string, GeometryAttribute>, indices: any): this {
     return this;

package/src/geometry/gpu-geometry.ts

@@ -48,11 +48,10 @@ export class GPUGeometry {
   }
 
   destroy(): void {
-    this.indices.destroy();
-    this.attributes.positions.destroy();
-    this.attributes.normals.destroy();
-    this.attributes.texCoords.destroy();
-    this.attributes.colors?.destroy();
+    this.indices?.destroy();
+    for (const attribute of Object.values(this.attributes)) {
+      attribute.destroy();
+    }
   }
 
   getVertexCount(): number {
@@ -101,7 +100,7 @@ export function getIndexBufferFromGeometry(device: Device, geometry: Geometry):
 export function getAttributeBuffersFromGeometry(
   device: Device,
   geometry: Geometry
-): {attributes: Record<string, Buffer>, bufferLayout: BufferLayout[], vertexCount: number} {
+): {attributes: Record<string, Buffer>; bufferLayout: BufferLayout[]; vertexCount: number} {
   const bufferLayout: BufferLayout[] = [];
 
   const attributes: Record<string, Buffer> = {};
@@ -109,17 +108,25 @@ export function getAttributeBuffersFromGeometry(
     let name: string = attributeName;
     // TODO Map some GLTF attribute names (is this still needed?)
     switch (attributeName) {
-      case 'POSITION': name = 'positions'; break;
-      case 'NORMAL': name = 'normals'; break;
-      case 'TEXCOORD_0': name = 'texCoords'; break;
-      case 'COLOR_0': name = 'colors'; break;
+      case 'POSITION':
+        name = 'positions';
+        break;
+      case 'NORMAL':
+        name = 'normals';
+        break;
+      case 'TEXCOORD_0':
+        name = 'texCoords';
+        break;
+      case 'COLOR_0':
+        name = 'colors';
+        break;
     }
     attributes[name] = device.createBuffer({data: attribute.value, id: `${attributeName}-buffer`});
     const {value, size, normalized} = attribute;
     bufferLayout.push({name, format: getVertexFormatFromAttribute(value, size, normalized)});
   }
 
-  const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices)
+  const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices);
 
   return {attributes, bufferLayout, vertexCount};
 }

package/src/index.ts

@@ -23,6 +23,7 @@ export type {TextureTransformProps} from './transform/texture-transform';
 export {TextureTransform} from './transform/texture-transform';
 
 export {PipelineFactory} from './lib/pipeline-factory';
+export {ShaderFactory} from './lib/shader-factory';
 
 // Utils
 export {ClipSpace} from './lib/clip-space';
@@ -58,3 +59,5 @@ export {TruncatedConeGeometry} from './geometries/truncated-cone-geometry';
 // EXPERIMENTAL
 export type {ShaderModuleInputs} from './shader-inputs';
 export {ShaderInputs as _ShaderInputs} from './shader-inputs';
+export type {ComputationProps} from './computation';
+export {Computation} from './computation';

package/src/lib/clip-space.ts

@@ -1,4 +1,3 @@
-
 // ClipSpace
 import {Device, glsl} from '@luma.gl/core';
 import {Model, ModelProps} from '../model/model';
@@ -30,24 +29,21 @@ const POSITIONS = [-1, -1, 1, -1, -1, 1, 1, 1];
  */
 export class ClipSpace extends Model {
   constructor(device: Device, opts: Omit<ModelProps, 'vs' | 'vertexCount' | 'geometry'>) {
-    const TEX_COORDS = POSITIONS.map((coord) => (coord === -1 ? 0 : coord));
+    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)}
+        }
+      })
+    });
   }
 }

package/src/lib/pipeline-factory.ts

@@ -1,6 +1,9 @@
-// luma.gl, MIT license
-import type {RenderPipelineProps} from '@luma.gl/core';
-import {Device, RenderPipeline} from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {RenderPipelineProps, ComputePipelineProps} from '@luma.gl/core';
+import {Device, RenderPipeline, ComputePipeline} from '@luma.gl/core';
 
 export type PipelineFactoryProps = RenderPipelineProps;
 
@@ -14,9 +17,16 @@ export class PipelineFactory {
 
   private _hashCounter: number = 0;
   private readonly _hashes: Record<string, number> = {};
-  private readonly _useCounts: Record<string, number> = {};
-  private readonly _pipelineCache: Record<string, RenderPipeline> = {};
-
+  private readonly _renderPipelineCache: Record<
+    string,
+    {pipeline: RenderPipeline; useCount: number}
+  > = {};
+  private readonly _computePipelineCache: Record<
+    string,
+    {pipeline: ComputePipeline; useCount: number}
+  > = {};
+
+  /** Get the singleton default pipeline factory for the specified device */
   static getDefaultPipelineFactory(device: Device): PipelineFactory {
     device._lumaData.defaultPipelineFactory =
       device._lumaData.defaultPipelineFactory || new PipelineFactory(device);
@@ -27,38 +37,62 @@ export class PipelineFactory {
     this.device = device;
   }
 
-  createRenderPipeline(options: PipelineFactoryProps): RenderPipeline {
-    const props: Required<PipelineFactoryProps> = {...PipelineFactory.defaultProps, ...options};
-
-    const hash = this._hashRenderPipeline({...props});
+  /** Return a RenderPipeline matching props. Reuses a similar pipeline if already created. */
+  createRenderPipeline(props: RenderPipelineProps): RenderPipeline {
+    const allProps: Required<RenderPipelineProps> = {...RenderPipeline.defaultProps, ...props};
 
-    if (!this._pipelineCache[hash]) {
-      const pipeline = this.device.createRenderPipeline({...props});
+    const hash = this._hashRenderPipeline(allProps);
 
+    if (!this._renderPipelineCache[hash]) {
+      const pipeline = this.device.createRenderPipeline({
+        ...allProps,
+        id: allProps.id ? `${allProps.id}-cached` : undefined
+      });
       pipeline.hash = hash;
-      this._pipelineCache[hash] = pipeline;
-      this._useCounts[hash] = 0;
+      this._renderPipelineCache[hash] = {pipeline, useCount: 0};
     }
 
-    this._useCounts[hash]++;
+    this._renderPipelineCache[hash].useCount++;
+    return this._renderPipelineCache[hash].pipeline;
+  }
+
+  createComputePipeline(props: ComputePipelineProps): ComputePipeline {
+    const allProps: Required<ComputePipelineProps> = {...ComputePipeline.defaultProps, ...props};
+
+    const hash = this._hashComputePipeline(allProps);
 
-    return this._pipelineCache[hash];
+    if (!this._computePipelineCache[hash]) {
+      const pipeline = this.device.createComputePipeline({
+        ...allProps,
+        id: allProps.id ? `${allProps.id}-cached` : undefined
+      });
+      pipeline.hash = hash;
+      this._computePipelineCache[hash] = {pipeline, useCount: 0};
+    }
+
+    this._computePipelineCache[hash].useCount++;
+    return this._computePipelineCache[hash].pipeline;
   }
 
-  release(pipeline: RenderPipeline): void {
+  release(pipeline: RenderPipeline | ComputePipeline): void {
     const hash = pipeline.hash;
-    this._useCounts[hash]--;
-    if (this._useCounts[hash] === 0) {
-      this._pipelineCache[hash].destroy();
-      delete this._pipelineCache[hash];
-      delete this._useCounts[hash];
+    const cache =
+      pipeline instanceof ComputePipeline ? this._computePipelineCache : this._renderPipelineCache;
+    cache[hash].useCount--;
+    if (cache[hash].useCount === 0) {
+      cache[hash].pipeline.destroy();
+      delete cache[hash];
     }
   }
 
   // PRIVATE
+  private _hashComputePipeline(props: ComputePipelineProps): string {
+    const shaderHash = this._getHash(props.shader.source);
+    return `${shaderHash}`;
+  }
 
   /** Calculate a hash based on all the inputs for a render pipeline */
-  private _hashRenderPipeline(props: PipelineFactoryProps): string {
+  private _hashRenderPipeline(props: RenderPipelineProps): string {
     const vsHash = this._getHash(props.vs.source);
     const fsHash = props.fs ? this._getHash(props.fs.source) : 0;
 
@@ -68,16 +102,16 @@ export class PipelineFactory {
     const varyingHash = '-'; // `${varyingHashes.join('/')}B${bufferMode}`
     const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
 
-    switch (this.device.info.type) {
-      case 'webgpu':
+    switch (this.device.type) {
+      // case 'webgl':
+      // WebGL is more dynamic
+      // return `${vsHash}/${fsHash}V${varyingHash}BL${bufferLayoutHash}`;
+      default:
         // On WebGPU we need to rebuild the pipeline if topology, parameters or bufferLayout change
         const parameterHash = this._getHash(JSON.stringify(props.parameters));
         // 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}BL${bufferLayoutHash}`;
     }
   }
 

package/src/lib/shader-factory.ts

@@ -0,0 +1,57 @@
+import {Device, Shader, ShaderProps} from '@luma.gl/core';
+
+/** Manages a cached pool of Shaders for reuse. */
+export class ShaderFactory {
+  static readonly defaultProps: Required<ShaderProps> = {...Shader.defaultProps};
+
+  public readonly device: Device;
+
+  private readonly _cache: Record<string, {shader: Shader; useCount: number}> = {};
+
+  /** Returns the default ShaderFactory for the given {@link Device}, creating one if necessary. */
+  static getDefaultShaderFactory(device: Device): ShaderFactory {
+    device._lumaData.defaultShaderFactory ||= new ShaderFactory(device);
+    return device._lumaData.defaultShaderFactory as ShaderFactory;
+  }
+
+  /** @internal */
+  constructor(device: Device) {
+    this.device = device;
+  }
+
+  /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */
+  createShader(props: ShaderProps): Shader {
+    const key = this._hashShader(props);
+
+    let cacheEntry = this._cache[key];
+    if (!cacheEntry) {
+      const shader = this.device.createShader({
+        ...props,
+        id: props.id ? `${props.id}-cached` : undefined
+      });
+      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: Shader): void {
+    const key = this._hashShader(shader);
+    const cacheEntry = this._cache[key];
+    if (cacheEntry) {
+      cacheEntry.useCount--;
+      if (cacheEntry.useCount === 0) {
+        delete this._cache[key];
+        cacheEntry.shader.destroy();
+      }
+    }
+  }
+
+  // PRIVATE
+
+  private _hashShader(value: Shader | ShaderProps): string {
+    return `${value.stage}:${value.source}`;
+  }
+}