@luma.gl/engine 9.0.17 → 9.1.0-alpha.10

package/src/async-texture/async-texture.ts

@@ -0,0 +1,146 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {Texture, TextureProps, Sampler, TextureView, Device} from '@luma.gl/core';
+
+import type {
+  Texture1DData,
+  Texture2DData,
+  Texture3DData,
+  TextureArrayData,
+  TextureCubeData,
+  TextureCubeArrayData
+} from '@luma.gl/core';
+
+import {loadImageBitmap} from '../application-utils/load-file';
+
+export type AsyncTextureProps = Omit<TextureProps, 'data'> & AsyncTextureDataProps;
+
+type AsyncTextureDataProps =
+  | AsyncTexture1DProps
+  | AsyncTexture2DProps
+  | AsyncTexture3DProps
+  | AsyncTextureArrayProps
+  | AsyncTextureCubeProps
+  | AsyncTextureCubeArrayProps;
+
+type AsyncTexture1DProps = {dimension: '1d'; data: Promise<Texture1DData> | Texture1DData | null};
+type AsyncTexture2DProps = {dimension?: '2d'; data: Promise<Texture2DData> | Texture2DData | null};
+type AsyncTexture3DProps = {dimension: '3d'; data: Promise<Texture3DData> | Texture3DData | null};
+type AsyncTextureArrayProps = {
+  dimension: '2d-array';
+  data: Promise<TextureArrayData> | TextureArrayData | null;
+};
+type AsyncTextureCubeProps = {
+  dimension: 'cube';
+  data: Promise<TextureCubeData> | TextureCubeData | null;
+};
+type AsyncTextureCubeArrayProps = {
+  dimension: 'cube-array';
+  data: Promise<TextureCubeArrayData> | TextureCubeArrayData | null;
+};
+
+type TextureData = TextureProps['data'];
+type AsyncTextureData = AsyncTextureProps['data'];
+
+/**
+ * It is very convenient to be able to initialize textures with promises
+ * This can add considerable complexity to the Texture class, and doesn't
+ * fit with the immutable nature of WebGPU resources.
+ * Instead, luma.gl offers async textures as a separate class.
+ */
+export class AsyncTexture {
+  readonly device: Device;
+
+  // TODO - should we type these as possibly `null`? It will make usage harder?
+  // @ts-expect-error
+  texture: Texture;
+  // @ts-expect-error
+  sampler: Sampler;
+  // @ts-expect-error
+  view: TextureView;
+
+  readonly ready: Promise<void>;
+  isReady: boolean = false;
+  destroyed: boolean = false;
+
+  protected resolveReady: () => void = () => {};
+  protected rejectReady: (error: Error) => void = () => {};
+
+  constructor(device: Device, props: AsyncTextureProps) {
+    this.device = device;
+
+    // Signature: new AsyncTexture(device, {data: url})
+    if (typeof props?.data === 'string' && props.dimension === '2d') {
+      props = {...props, data: loadImageBitmap(props.data)};
+    }
+
+    this.ready = new Promise<void>((resolve, reject) => {
+      this.resolveReady = () => {
+        this.isReady = true;
+        resolve();
+      };
+      this.rejectReady = reject;
+    });
+
+    this.initAsync(props);
+  }
+
+  async initAsync(props: AsyncTextureProps): Promise<void> {
+    let resolveReady;
+    let rejectReady;
+
+    const asyncData: AsyncTextureData = props.data;
+    const data: TextureData = await awaitAllPromises(asyncData).then(resolveReady, rejectReady);
+
+    // Check that we haven't been destroyed while waiting for texture data to load
+    if (this.destroyed) {
+      return;
+    }
+
+    // Now we can actually create the texture
+    // @ts-expect-error Discriminated union
+    const syncProps: TextureProps = {...props, data};
+
+    this.texture = this.device.createTexture(syncProps);
+    this.sampler = this.texture.sampler;
+    this.view = this.texture.view;
+    this.isReady = true;
+  }
+
+  destroy(): void {
+    if (this.texture) {
+      this.texture.destroy();
+      // @ts-expect-error
+      this.texture = null;
+    }
+    this.destroyed = true;
+  }
+
+  // We could implement resize by replacing the texture
+  // resize(width: number, height: number): boolean {
+  //   throw new Error('Not implemented');
+  //   // return false;
+  // }
+}
+
+// HELPERS
+
+/** Resolve all promises in a nested data structure */
+async function awaitAllPromises(x: any): Promise<any> {
+  x = await x;
+  if (Array.isArray(x)) {
+    return await Promise.all(x.map(awaitAllPromises));
+  }
+  if (x && typeof x === 'object' && x.constructor === Object) {
+    const object: Record<string, any> = x;
+    const values = await Promise.all(Object.values(object));
+    const keys = Object.keys(object);
+    const resolvedObject: Record<string, any> = {};
+    for (let i = 0; i < keys.length; i++) {
+      resolvedObject[keys[i]] = values[i];
+    }
+    return resolvedObject;
+  }
+  return x;
+}

package/src/computation.ts

@@ -2,16 +2,17 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {TypedArray} from '@luma.gl/core';
 import type {DeviceFeature, ComputePipelineProps, Shader, Binding} from '@luma.gl/core';
 import {Device, Buffer, ComputePipeline, ComputePass, UniformStore} from '@luma.gl/core';
-import {log, uid, isNumberArray} from '@luma.gl/core';
+import {log} from '@luma.gl/core';
 import {getTypedArrayFromDataType} from '@luma.gl/core';
 import type {ShaderModule, PlatformInfo} from '@luma.gl/shadertools';
 import {ShaderAssembler, getShaderLayoutFromWGSL} from '@luma.gl/shadertools';
+import {TypedArray, isNumericArray} from '@math.gl/types';
 import {ShaderInputs} from './shader-inputs';
 import {PipelineFactory} from './lib/pipeline-factory';
 import {ShaderFactory} from './lib/shader-factory';
+import {uid} from './utils/uid';
 // import {getDebugTableForShaderLayout} from '../debug/debug-shader-layout';
 
 const LOG_DRAW_PRIORITY = 2;
@@ -69,7 +70,7 @@ export class Computation {
     shaderFactory: undefined!,
     shaderAssembler: ShaderAssembler.getDefaultShaderAssembler(),
 
-    debugShaders: undefined
+    debugShaders: undefined!
   };
 
   readonly device: Device;
@@ -83,15 +84,18 @@ export class Computation {
   /** Bindings (textures, samplers, uniform buffers) */
   bindings: Record<string, Binding> = {};
 
-  /** The underlying GPU "program". @note May be recreated if parameters change */
+  /** The underlying GPU pipeline. */
   pipeline: ComputePipeline;
+  /** Assembled compute shader source */
+  source: string;
   /** the underlying compiled compute shader */
+  // @ts-ignore Set in function called from constructor
   shader: Shader;
-  source: string;
 
   /** ShaderInputs instance */
   shaderInputs: ShaderInputs;
 
+  // @ts-ignore Set in function called from constructor
   _uniformStore: UniformStore;
 
   _pipelineNeedsUpdate: string | false = 'newly created';
@@ -117,7 +121,9 @@ export class Computation {
     const moduleMap = Object.fromEntries(
       this.props.modules?.map(module => [module.name, module]) || []
     );
-    this.setShaderInputs(props.shaderInputs || new ShaderInputs(moduleMap));
+    // @ts-ignore TODO - fix up typing?
+    this.shaderInputs = props.shaderInputs || new ShaderInputs(moduleMap);
+    this.setShaderInputs(this.shaderInputs);
 
     // Support WGSL shader layout introspection
     // TODO - Don't modify props!!
@@ -134,14 +140,14 @@ export class Computation {
       props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
     this.shaderFactory = props.shaderFactory || ShaderFactory.getDefaultShaderFactory(this.device);
 
-    const {source, getUniforms} = this.props.shaderAssembler.assembleShader({
+    const {source, getUniforms} = this.props.shaderAssembler.assembleWGSLShader({
       platformInfo,
       ...this.props,
       modules
     });
 
     this.source = source;
-
+    // @ts-ignore
     this._getModuleUniforms = getUniforms;
 
     // Create the pipeline
@@ -233,7 +239,9 @@ export class Computation {
     // TODO better way to extract bindings
     const keys = Object.keys(uniforms).filter(k => {
       const uniform = uniforms[k];
-      return !isNumberArray(uniform) && typeof uniform !== 'number' && typeof uniform !== 'boolean';
+      return (
+        !isNumericArray(uniform) && typeof uniform !== 'number' && typeof uniform !== 'boolean'
+      );
     });
     const bindings: Record<string, Binding> = {};
     for (const k of keys) {

package/src/debug/copy-texture-to-image.ts

@@ -60,9 +60,12 @@ export function copyTextureToDataUrl(
   canvas.width = width;
   canvas.height = height;
   const context = canvas.getContext('2d');
+  if (!context) {
+    throw new Error('Failed to create context');
+  }
 
   // Copy the pixels to a 2D canvas
-  const imageData = context.createImageData(width, height);
+  const imageData = context?.createImageData(width, height);
   imageData.data.set(data);
   context.putImageData(imageData, 0, 0);
 

package/src/debug/debug-framebuffer.ts

@@ -1,3 +1,7 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {Framebuffer, Texture} from '@luma.gl/core';
 // import {copyTextureToImage} from '../debug/copy-texture-to-image';
 
@@ -54,17 +58,19 @@ export function debugFramebuffer(
   // ctx.drawImage(image, 0, 0);
 
   const color = fbo.device.readPixelsToArrayWebGL(fbo);
-  const imageData = ctx.createImageData(fbo.width, fbo.height);
-  // Full map
-  const offset = 0;
-  // if (color.some((v) => v > 0)) {
-  //   console.error('THERE IS NON-ZERO DATA IN THE FBO!');
-  // }
-  for (let i = 0; i < color.length; i += 4) {
-    imageData.data[offset + i + 0] = color[i + 0] * rgbaScale;
-    imageData.data[offset + i + 1] = color[i + 1] * rgbaScale;
-    imageData.data[offset + i + 2] = color[i + 2] * rgbaScale;
-    imageData.data[offset + i + 3] = opaque ? 255 : color[i + 3] * rgbaScale;
+  const imageData = ctx?.createImageData(fbo.width, fbo.height);
+  if (imageData) {
+    // Full map
+    const offset = 0;
+    // if (color.some((v) => v > 0)) {
+    //   console.error('THERE IS NON-ZERO DATA IN THE FBO!');
+    // }
+    for (let i = 0; i < color.length; i += 4) {
+      imageData.data[offset + i + 0] = color[i + 0] * rgbaScale;
+      imageData.data[offset + i + 1] = color[i + 1] * rgbaScale;
+      imageData.data[offset + i + 2] = color[i + 2] * rgbaScale;
+      imageData.data[offset + i + 3] = opaque ? 255 : color[i + 3] * rgbaScale;
+    }
+    ctx?.putImageData(imageData, 0, 0);
   }
-  ctx.putImageData(imageData, 0, 0);
 }

package/src/debug/pixel-data-utils.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {TypedArray} from '@luma.gl/core';
+import {TypedArray} from '@math.gl/core';
 
 /**
  * Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)

package/src/geometries/cone-geometry.ts

@@ -1,5 +1,9 @@
-import {uid} from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {TruncatedConeGeometry} from './truncated-cone-geometry';
+import {uid} from '../utils/uid';
 
 export type ConeGeometryProps = {
   id?: string;

package/src/geometries/cube-geometry.ts

@@ -1,5 +1,9 @@
-import {uid} from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {Geometry} from '../geometry/geometry';
+import {uid} from '../utils/uid';
 // import type {GeometryType} from '../geometry/geometry-type';
 
 export type CubeGeometryProps = {

package/src/geometries/cylinder-geometry.ts

@@ -1,5 +1,9 @@
-import {uid} from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {TruncatedConeGeometry} from './truncated-cone-geometry';
+import {uid} from '../utils/uid';
 
 export type CylinderGeometryProps = {
   id?: string;

package/src/geometries/ico-sphere-geometry.ts

@@ -1,6 +1,10 @@
-import {uid} from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {Vector3} from '@math.gl/core';
 import {Geometry} from '../geometry/geometry';
+import {uid} from '../utils/uid';
 
 /* eslint-disable comma-spacing, max-statements, complexity */
 

package/src/geometries/plane-geometry.ts

@@ -1,6 +1,10 @@
-import {uid} from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {Geometry} from '../geometry/geometry';
 import {unpackIndexedGeometry} from '../geometry/geometry-utils';
+import {uid} from '../utils/uid';
 
 export type PlaneGeometryProps = {
   id?: string;

package/src/geometries/sphere-geometry.ts

@@ -1,5 +1,9 @@
-import {uid} from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {Geometry} from '../geometry/geometry';
+import {uid} from '../utils/uid';
 
 export type SphereGeometryProps = {
   id?: string;

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

@@ -1,5 +1,9 @@
-import {uid} from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {Geometry} from '../geometry/geometry';
+import {uid} from '../utils/uid';
 
 const INDEX_OFFSETS = {
   x: [2, 0, 1],

package/src/geometry/geometry-table.ts

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {TypedArray, VertexFormat} from '@luma.gl/core';
+import type {TypedArray} from '@math.gl/core';
+import type {VertexFormat} from '@luma.gl/core';
 
 /** Holds one geometry */
 export type GeometryTable = {

package/src/geometry/geometry-utils.ts

@@ -1,4 +1,6 @@
-// import type {Geometry} from './geometry';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
 export function unpackIndexedGeometry(geometry: any) {
   const {indices, attributes} = geometry;

package/src/geometry/geometry.ts

@@ -2,23 +2,17 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {PrimitiveTopology, TypedArray} from '@luma.gl/core';
-import {uid, assert} from '@luma.gl/core';
+import type {TypedArray} from '@math.gl/core';
+import type {PrimitiveTopology} from '@luma.gl/core';
+import {uid} from '../utils/uid';
 
 export type GeometryProps = {
   id?: string;
   /** Determines how vertices are read from the 'vertex' attributes */
-  topology:
-    | 'point-list'
-    | 'line-list'
-    | 'line-strip'
-    | 'line-loop-webgl'
-    | 'triangle-list'
-    | 'triangle-strip'
-    | 'triangle-fan-webgl';
+  topology: 'point-list' | 'line-list' | 'line-strip' | 'triangle-list' | 'triangle-strip';
   /** Auto calculated from attributes if not provided */
   vertexCount?: number;
-  attributes?: Record<string, GeometryAttribute | TypedArray>;
+  attributes: Record<string, GeometryAttribute | TypedArray>;
   indices?: GeometryAttribute | TypedArray;
 };
 
@@ -71,10 +65,11 @@ export class Geometry {
         ? {value: attributeValue}
         : attributeValue;
 
-      assert(
-        ArrayBuffer.isView(attribute.value),
-        `${this._print(attributeName)}: must be typed array or object with value as typed array`
-      );
+      if (!ArrayBuffer.isView(attribute.value)) {
+        throw new Error(
+          `${this._print(attributeName)}: must be typed array or object with value as typed array`
+        );
+      }
 
       if ((attributeName === 'POSITION' || attributeName === 'positions') && !attribute.size) {
         attribute.size = 3;
@@ -82,7 +77,9 @@ export class Geometry {
 
       // Move indices to separate field
       if (attributeName === 'indices') {
-        assert(!this.indices);
+        if (this.indices) {
+          throw new Error('Multiple indices detected');
+        }
         this.indices = attribute;
       } else {
         this.attributes[attributeName] = attribute;
@@ -130,19 +127,19 @@ export class Geometry {
     return this;
   }
 
-  _calculateVertexCount(attributes: GeometryAttributes, indices: GeometryAttribute): number {
+  _calculateVertexCount(attributes: GeometryAttributes, indices?: GeometryAttribute): number {
     if (indices) {
       return indices.value.length;
     }
     let vertexCount = Infinity;
     for (const attribute of Object.values(attributes)) {
       const {value, size, constant} = attribute;
-      if (!constant && value && size >= 1) {
+      if (!constant && value && size !== undefined && size >= 1) {
         vertexCount = Math.min(vertexCount, value.length / size);
       }
     }
 
-    assert(Number.isFinite(vertexCount));
+    // assert(Number.isFinite(vertexCount));
     return vertexCount;
   }
 }

package/src/geometry/gpu-geometry.ts

@@ -1,18 +1,16 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {PrimitiveTopology, BufferLayout} from '@luma.gl/core';
-import {Device, Buffer, uid, assert, getVertexFormatFromAttribute} from '@luma.gl/core';
+import {Device, Buffer, getVertexFormatFromAttribute} from '@luma.gl/core';
 import type {Geometry} from '../geometry/geometry';
+import {uid} from '../utils/uid';
 
 export type GPUGeometryProps = {
   id?: string;
   /** Determines how vertices are read from the 'vertex' attributes */
-  topology:
-    | 'point-list'
-    | 'line-list'
-    | 'line-strip'
-    | 'line-loop-webgl'
-    | 'triangle-list'
-    | 'triangle-strip'
-    | 'triangle-fan-webgl';
+  topology: 'point-list' | 'line-list' | 'line-strip' | 'triangle-list' | 'triangle-strip';
   /** Auto calculated from attributes if not provided */
   vertexCount: number;
   bufferLayout: BufferLayout[];
@@ -43,7 +41,9 @@ export class GPUGeometry {
     this.bufferLayout = props.bufferLayout || [];
 
     if (this.indices) {
-      assert(this.indices.usage === Buffer.INDEX);
+      if (!(this.indices.usage & Buffer.INDEX)) {
+        throw new Error('Index buffer must have INDEX usage');
+      }
     }
   }
 
@@ -63,7 +63,7 @@ export class GPUGeometry {
   }
 
   getIndexes(): Buffer | null {
-    return this.indices;
+    return this.indices || null;
   }
 
   _calculateVertexCount(positions: Buffer): number {
@@ -121,9 +121,15 @@ export function getAttributeBuffersFromGeometry(
         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)});
+    if (attribute) {
+      attributes[name] = device.createBuffer({
+        data: attribute.value,
+        id: `${attributeName}-buffer`
+      });
+      const {value, size, normalized} = attribute;
+      // @ts-expect-error
+      bufferLayout.push({name, format: getVertexFormatFromAttribute(value, size, normalized)});
+    }
   }
 
   const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices);

package/src/geometry/gpu-table.ts

@@ -1,3 +1,7 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 /*
 export function getAttributeLayoutsFromGeometry(geometry: Geometry) {
   const layouts: Record<string, {}> = {};

package/src/index.ts

@@ -1,3 +1,7 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // luma.gl Engine API
 
 // Animation
@@ -56,7 +60,19 @@ export {SphereGeometry} from './geometries/sphere-geometry';
 export type {TruncatedConeGeometryProps} from './geometries/truncated-cone-geometry';
 export {TruncatedConeGeometry} from './geometries/truncated-cone-geometry';
 
+// Application Utilities
+export {makeRandomGenerator} from './application-utils/random';
+export {setPathPrefix, loadImage, loadImageBitmap} from './application-utils/load-file';
+
 // EXPERIMENTAL
+export type {ShaderModuleInputs} from './shader-inputs';
 export {ShaderInputs as _ShaderInputs} from './shader-inputs';
 export type {ComputationProps} from './computation';
 export {Computation} from './computation';
+export {
+  requestAnimationFrame,
+  cancelAnimationFrame
+} from './animation-loop/request-animation-frame';
+
+export type {AsyncTextureProps} from './async-texture/async-texture';
+export {AsyncTexture} from './async-texture/async-texture';

package/src/lib/clip-space.ts

@@ -1,9 +1,13 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // ClipSpace
-import {Device, glsl} from '@luma.gl/core';
+import {Device} from '@luma.gl/core';
 import {Model, ModelProps} from '../model/model';
 import {Geometry} from '../geometry/geometry';
 
-const CLIPSPACE_VERTEX_SHADER = glsl`\
+const CLIPSPACE_VERTEX_SHADER = /* glsl */ `\
 #version 300 es
 in vec2 aClipSpacePosition;
 in vec2 aTexCoord;

package/src/lib/pipeline-factory.ts

@@ -7,25 +7,15 @@ import {Device, RenderPipeline, ComputePipeline} from '@luma.gl/core';
 
 export type PipelineFactoryProps = RenderPipelineProps;
 
+type RenderPipelineCacheItem = {pipeline: RenderPipeline; useCount: number};
+type ComputePipelineCacheItem = {pipeline: ComputePipeline; useCount: number};
+
 /**
  * Efficiently creates / caches pipelines
  */
 export class PipelineFactory {
   static defaultProps: Required<PipelineFactoryProps> = {...RenderPipeline.defaultProps};
 
-  readonly device: Device;
-
-  private _hashCounter: number = 0;
-  private readonly _hashes: Record<string, number> = {};
-  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 =
@@ -33,8 +23,17 @@ export class PipelineFactory {
     return device._lumaData.defaultPipelineFactory as PipelineFactory;
   }
 
+  readonly device: Device;
+  readonly destroyPolicy: 'unused' | 'never';
+
+  private _hashCounter: number = 0;
+  private readonly _hashes: Record<string, number> = {};
+  private readonly _renderPipelineCache: Record<string, RenderPipelineCacheItem> = {};
+  private readonly _computePipelineCache: Record<string, ComputePipelineCacheItem> = {};
+
   constructor(device: Device) {
     this.device = device;
+    this.destroyPolicy = device.props._factoryDestroyPolicy;
   }
 
   /** Return a RenderPipeline matching props. Reuses a similar pipeline if already created. */
@@ -80,8 +79,10 @@ export class PipelineFactory {
       pipeline instanceof ComputePipeline ? this._computePipelineCache : this._renderPipelineCache;
     cache[hash].useCount--;
     if (cache[hash].useCount === 0) {
-      cache[hash].pipeline.destroy();
-      delete cache[hash];
+      if (this.destroyPolicy === 'unused') {
+        cache[hash].pipeline.destroy();
+        delete cache[hash];
+      }
     }
   }
 
@@ -93,7 +94,7 @@ export class PipelineFactory {
 
   /** Calculate a hash based on all the inputs for a render pipeline */
   private _hashRenderPipeline(props: RenderPipelineProps): string {
-    const vsHash = this._getHash(props.vs.source);
+    const vsHash = props.vs ? this._getHash(props.vs.source) : 0;
     const fsHash = props.fs ? this._getHash(props.fs.source) : 0;
 
     // WebGL specific