@luma.gl/engine 9.0.0-alpha.9 → 9.0.0-beta.10

package/dist/index.js

@@ -1,15 +1,29 @@
-export { AnimationLoop } from './lib/animation-loop';
-export { RenderLoop } from './lib/render-loop';
-export { default as Model } from './lib/model';
-export { PipelineFactory } from './lib/pipeline-factory';
-export { Timeline } from './animation/timeline';
-export { KeyFrames } from './animation/key-frames';
-export { default as Geometry } from './geometry/geometry';
-export { ConeGeometry } from './geometries/cone-geometry';
-export { CubeGeometry } from './geometries/cube-geometry';
-export { CylinderGeometry } from './geometries/cylinder-geometry';
-export { IcoSphereGeometry } from './geometries/ico-sphere-geometry';
-export { PlaneGeometry } from './geometries/plane-geometry';
-export { SphereGeometry } from './geometries/sphere-geometry';
-export { TruncatedConeGeometry } from './geometries/truncated-cone-geometry';
-//# sourceMappingURL=index.js.map
+// luma.gl Engine API
+// Animation
+export { Timeline } from "./animation/timeline.js";
+export { KeyFrames } from "./animation/key-frames.js";
+export { AnimationLoopTemplate } from "./animation-loop/animation-loop-template.js";
+export { AnimationLoop } from "./animation-loop/animation-loop.js";
+export { makeAnimationLoop } from "./animation-loop/make-animation-loop.js";
+export { Model } from "./model/model.js";
+export { BufferTransform } from "./transform/buffer-transform.js";
+export { TextureTransform } from "./transform/texture-transform.js";
+export { PipelineFactory } from "./lib/pipeline-factory.js";
+export { ShaderFactory } from "./lib/shader-factory.js";
+// Utils
+export { ClipSpace } from "./lib/clip-space.js";
+// Scenegraph Core nodes
+export { ScenegraphNode } from "./scenegraph/scenegraph-node.js";
+export { GroupNode } from "./scenegraph/group-node.js";
+export { ModelNode } from "./scenegraph/model-node.js";
+export { Geometry } from "./geometry/geometry.js";
+export { GPUGeometry } from "./geometry/gpu-geometry.js";
+export { ConeGeometry } from "./geometries/cone-geometry.js";
+export { CubeGeometry } from "./geometries/cube-geometry.js";
+export { CylinderGeometry } from "./geometries/cylinder-geometry.js";
+export { IcoSphereGeometry } from "./geometries/ico-sphere-geometry.js";
+export { PlaneGeometry } from "./geometries/plane-geometry.js";
+export { SphereGeometry } from "./geometries/sphere-geometry.js";
+export { TruncatedConeGeometry } from "./geometries/truncated-cone-geometry.js";
+export { ShaderInputs as _ShaderInputs } from "./shader-inputs.js";
+export { Computation } from "./computation.js";

package/dist/lib/clip-space.d.ts

@@ -1 +1,9 @@
+import { Device } from '@luma.gl/core';
+import { Model, ModelProps } from "../model/model.js";
+/**
+ * A flat geometry that covers the "visible area" that the GPU renders.
+ */
+export declare class ClipSpace extends Model {
+    constructor(device: Device, opts: Omit<ModelProps, 'vs' | 'vertexCount' | 'geometry'>);
+}
 //# sourceMappingURL=clip-space.d.ts.map

package/dist/lib/clip-space.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clip-space.d.ts","sourceRoot":"","sources":["../../src/lib/clip-space.ts"],"names":[],"mappings":""}
+{"version":3,"file":"clip-space.d.ts","sourceRoot":"","sources":["../../src/lib/clip-space.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,MAAM,EAAO,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAC,KAAK,EAAE,UAAU,EAAC,0BAAuB;AAwBjD;;GAEG;AACH,qBAAa,SAAU,SAAQ,KAAK;gBACtB,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC;CAkBtF"}

package/dist/lib/clip-space.js

@@ -1,2 +1,43 @@
-
-//# sourceMappingURL=clip-space.js.map
+// ClipSpace
+import { glsl } from '@luma.gl/core';
+import { Model } from "../model/model.js";
+import { Geometry } from "../geometry/geometry.js";
+const CLIPSPACE_VERTEX_SHADER = `\
+#version 300 es
+in vec2 aClipSpacePosition;
+in vec2 aTexCoord;
+in vec2 aCoordinate;
+out vec2 position;
+out vec2 coordinate;
+out vec2 uv;
+void main(void) {
+gl_Position = vec4(aClipSpacePosition, 0., 1.);
+position = aClipSpacePosition;
+coordinate = aCoordinate;
+uv = aTexCoord;
+}
+`;
+/* eslint-disable indent, no-multi-spaces */
+const POSITIONS = [-1, -1, 1, -1, -1, 1, 1, 1];
+/**
+ * A flat geometry that covers the "visible area" that the GPU renders.
+ */
+export class ClipSpace extends Model {
+    constructor(device, opts) {
+        const TEX_COORDS = POSITIONS.map(coord => (coord === -1 ? 0 : coord));
+        super(device, {
+            ...opts,
+            vs: CLIPSPACE_VERTEX_SHADER,
+            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) }
+                }
+            })
+        });
+    }
+}

package/dist/lib/pipeline-factory.d.ts

@@ -1,60 +1,26 @@
-import type { RenderPipelineParameters, PrimitiveTopology, ShaderLayout } from '@luma.gl/api';
-import { Device, RenderPipeline } from '@luma.gl/api/';
-import type { ShaderModule } from '@luma.gl/shadertools';
-export declare type GetRenderPipelineOptions = {
-    vs: string;
-    fs: string | null;
-    topology: PrimitiveTopology;
-    layout?: ShaderLayout | null;
-    parameters?: RenderPipelineParameters;
-    modules?: ShaderModule[];
-    defines?: Record<string, string | number | boolean>;
-    inject?: Record<string, string>;
-    transpileToGLSL100?: boolean;
-    varyings?: string[];
-    bufferMode?: number;
-};
-export declare type GetComputePipelineOptions = {
-    cs: string;
-    parameters?: RenderPipelineParameters;
-    modules?: ShaderModule[];
-    defines?: Record<string, string>;
-    inject?: Record<string, string>;
-    transpileToGLSL100?: boolean;
-    varyings?: string[];
-    bufferMode?: number;
-};
-declare type GetUniformsFunc = (props?: Record<string, any>) => Record<string, any>;
-/** Efficiently create shared pipelines with varying parameters */
+import type { RenderPipelineProps, ComputePipelineProps } from '@luma.gl/core';
+import { Device, RenderPipeline, ComputePipeline } from '@luma.gl/core';
+export type PipelineFactoryProps = RenderPipelineProps;
+/**
+ * Efficiently creates / caches pipelines
+ */
 export declare class PipelineFactory {
+    static defaultProps: Required<PipelineFactoryProps>;
     readonly device: Device;
-    stateHash: number;
     private _hashCounter;
     private readonly _hashes;
-    private readonly _useCounts;
-    private readonly _pipelineCache;
-    private readonly _getUniforms;
-    private readonly _hookFunctions;
-    private _defaultModules;
+    private readonly _renderPipelineCache;
+    private readonly _computePipelineCache;
+    /** Get the singleton default pipeline factory for the specified device */
     static getDefaultPipelineFactory(device: Device): PipelineFactory;
     constructor(device: Device);
-    addDefaultModule(module: ShaderModule): void;
-    removeDefaultModule(module: ShaderModule): void;
-    addShaderHook(hook: any, opts?: any): void;
-    createRenderPipeline(options: GetRenderPipelineOptions): {
-        pipeline: RenderPipeline;
-        getUniforms: GetUniformsFunc;
-    };
-    release(pipeline: RenderPipeline): void;
-    getUniforms(pipeline: RenderPipeline): GetUniformsFunc;
-    _createRenderPipeline(props: GetRenderPipelineOptions): {
-        pipeline: RenderPipeline;
-        getUniforms: GetUniformsFunc;
-    };
+    /** Return a RenderPipeline matching props. Reuses a similar pipeline if already created. */
+    createRenderPipeline(props: RenderPipelineProps): RenderPipeline;
+    createComputePipeline(props: ComputePipelineProps): ComputePipeline;
+    release(pipeline: RenderPipeline | ComputePipeline): void;
+    private _hashComputePipeline;
     /** Calculate a hash based on all the inputs for a render pipeline */
-    _hashRenderPipeline(props: GetRenderPipelineOptions): string;
-    _getHash(key: string): number;
-    _getModuleList(appModules?: ShaderModule[]): ShaderModule[];
+    private _hashRenderPipeline;
+    private _getHash;
 }
-export {};
 //# sourceMappingURL=pipeline-factory.d.ts.map

package/dist/lib/pipeline-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline-factory.d.ts","sourceRoot":"","sources":["../../src/lib/pipeline-factory.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"pipeline-factory.d.ts","sourceRoot":"","sources":["../../src/lib/pipeline-factory.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAC,MAAM,EAAE,cAAc,EAAE,eAAe,EAAC,MAAM,eAAe,CAAC;AAEtE,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,CAAC;AAEvD;;GAEG;AACH,qBAAa,eAAe;IAC1B,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,oBAAoB,CAAC,CAAoC;IAEvF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IACtD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAG9B;IACP,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAG/B;IAEP,0EAA0E;IAC1E,MAAM,CAAC,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe;gBAMrD,MAAM,EAAE,MAAM;IAI1B,4FAA4F;IAC5F,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,GAAG,cAAc;IAkBhE,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,GAAG,eAAe;IAkBnE,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,eAAe,GAAG,IAAI;IAYzD,OAAO,CAAC,oBAAoB;IAK5B,qEAAqE;IACrE,OAAO,CAAC,mBAAmB;IAuB3B,OAAO,CAAC,QAAQ;CAMjB"}

package/dist/lib/pipeline-factory.js

@@ -1,219 +1,94 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { assembleShaders } from '@luma.gl/shadertools';
-const DEFAULT_RENDER_PIPELINE_OPTIONS = {
-  vs: '',
-  fs: '',
-  modules: [],
-  defines: {},
-  inject: {},
-  transpileToGLSL100: false,
-  layout: null,
-  varyings: [],
-  bufferMode: 0x8c8d,
-  topology: 'triangle-list',
-  parameters: {}
-};
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { RenderPipeline, ComputePipeline } from '@luma.gl/core';
+/**
+ * Efficiently creates / caches pipelines
+ */
 export class PipelineFactory {
-  static getDefaultPipelineFactory(device) {
-    device.defaultPipelineFactory = device.defaultPipelineFactory || new PipelineFactory(device);
-    return device.defaultPipelineFactory;
-  }
-
-  constructor(device) {
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "stateHash", 0);
-
-    _defineProperty(this, "_hashCounter", 0);
-
-    _defineProperty(this, "_hashes", {});
-
-    _defineProperty(this, "_useCounts", {});
-
-    _defineProperty(this, "_pipelineCache", {});
-
-    _defineProperty(this, "_getUniforms", {});
-
-    _defineProperty(this, "_hookFunctions", []);
-
-    _defineProperty(this, "_defaultModules", []);
-
-    this.device = device;
-  }
-
-  addDefaultModule(module) {
-    if (!this._defaultModules.find(m => m.name === (typeof module === 'string' ? module : module.name))) {
-      this._defaultModules.push(module);
+    static defaultProps = { ...RenderPipeline.defaultProps };
+    device;
+    _hashCounter = 0;
+    _hashes = {};
+    _renderPipelineCache = {};
+    _computePipelineCache = {};
+    /** Get the singleton default pipeline factory for the specified device */
+    static getDefaultPipelineFactory(device) {
+        device._lumaData.defaultPipelineFactory =
+            device._lumaData.defaultPipelineFactory || new PipelineFactory(device);
+        return device._lumaData.defaultPipelineFactory;
     }
-
-    this.stateHash++;
-  }
-
-  removeDefaultModule(module) {
-    const moduleName = typeof module === 'string' ? module : module.name;
-    this._defaultModules = this._defaultModules.filter(m => m.name !== moduleName);
-    this.stateHash++;
-  }
-
-  addShaderHook(hook, opts) {
-    if (opts) {
-      hook = Object.assign(opts, {
-        hook
-      });
+    constructor(device) {
+        this.device = device;
     }
-
-    this._hookFunctions.push(hook);
-
-    this.stateHash++;
-  }
-
-  createRenderPipeline(options) {
-    const props = { ...DEFAULT_RENDER_PIPELINE_OPTIONS,
-      ...options
-    };
-
-    const modules = this._getModuleList(props.modules);
-
-    const hash = this._hashRenderPipeline({ ...props,
-      modules
-    });
-
-    if (!this._pipelineCache[hash]) {
-      const {
-        pipeline,
-        getUniforms
-      } = this._createRenderPipeline({ ...props,
-        modules
-      });
-
-      pipeline.hash = hash;
-      this._pipelineCache[hash] = pipeline;
-
-      this._getUniforms[hash] = getUniforms || (x => ({}));
-
-      this._useCounts[hash] = 0;
+    /** Return a RenderPipeline matching props. Reuses a similar pipeline if already created. */
+    createRenderPipeline(props) {
+        const allProps = { ...RenderPipeline.defaultProps, ...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._renderPipelineCache[hash] = { pipeline, useCount: 0 };
+        }
+        this._renderPipelineCache[hash].useCount++;
+        return this._renderPipelineCache[hash].pipeline;
     }
-
-    this._useCounts[hash]++;
-    return {
-      pipeline: this._pipelineCache[hash],
-      getUniforms: this._getUniforms[hash]
-    };
-  }
-
-  release(pipeline) {
-    const hash = pipeline.hash;
-    this._useCounts[hash]--;
-
-    if (this._useCounts[hash] === 0) {
-      this._pipelineCache[hash].destroy();
-
-      delete this._pipelineCache[hash];
-      delete this._getUniforms[hash];
-      delete this._useCounts[hash];
+    createComputePipeline(props) {
+        const allProps = { ...ComputePipeline.defaultProps, ...props };
+        const hash = this._hashComputePipeline(allProps);
+        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;
     }
-  }
-
-  getUniforms(pipeline) {
-    return this._getUniforms[pipeline.hash] || null;
-  }
-
-  _createRenderPipeline(props) {
-    const platformInfo = {
-      gpu: this.device.info.gpu,
-      features: this.device.features
-    };
-
-    if (!props.fs) {
-      throw new Error('fs');
+    release(pipeline) {
+        const hash = pipeline.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];
+        }
     }
-
-    const assembled = assembleShaders(platformInfo, { ...props,
-      fs: props.fs,
-      hookFunctions: this._hookFunctions
-    });
-    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
-      }) : null
-    });
-    return {
-      pipeline,
-      getUniforms: assembled.getUniforms
-    };
-  }
-
-  _hashRenderPipeline(props) {
-    const {
-      modules = [],
-      varyings = [],
-      defines = [],
-      inject = [],
-      parameters = []
-    } = props;
-
-    const vsHash = this._getHash(props.vs);
-
-    const fsHash = props.fs ? this._getHash(props.fs) : 0;
-    const moduleHashes = modules.map(m => this._getHash(typeof m === 'string' ? m : m.name)).sort();
-    const varyingHashes = varyings.map(v => this._getHash(v));
-    const defineKeys = Object.keys(defines).sort();
-    const injectKeys = Object.keys(inject).sort();
-    const defineHashes = [];
-    const injectHashes = [];
-
-    for (const key of defineKeys) {
-      defineHashes.push(this._getHash(key));
-      defineHashes.push(this._getHash(defines[key]));
+    // PRIVATE
+    _hashComputePipeline(props) {
+        const shaderHash = this._getHash(props.shader.source);
+        return `${shaderHash}`;
     }
-
-    for (const key of injectKeys) {
-      injectHashes.push(this._getHash(key));
-      injectHashes.push(this._getHash(inject[key]));
+    /** Calculate a hash based on all the inputs for a render pipeline */
+    _hashRenderPipeline(props) {
+        const vsHash = this._getHash(props.vs.source);
+        const fsHash = props.fs ? this._getHash(props.fs.source) : 0;
+        // WebGL specific
+        // const {varyings = [], bufferMode = {}} = props;
+        // const varyingHashes = varyings.map((v) => this._getHash(v));
+        const varyingHash = '-'; // `${varyingHashes.join('/')}B${bufferMode}`
+        const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
+        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}`;
+        }
     }
-
-    const parameterHash = JSON.stringify(parameters);
-    return "".concat(vsHash, "/").concat(fsHash, "D").concat(defineHashes.join('/'), "M").concat(moduleHashes.join('/'), "I").concat(injectHashes.join('/'), "V").concat(varyingHashes.join('/'), "H").concat(this.stateHash, "B").concat(props.bufferMode).concat(props.transpileToGLSL100 ? 'T' : '', "P").concat(parameterHash);
-  }
-
-  _getHash(key) {
-    if (this._hashes[key] === undefined) {
-      this._hashes[key] = this._hashCounter++;
+    _getHash(key) {
+        if (this._hashes[key] === undefined) {
+            this._hashes[key] = this._hashCounter++;
+        }
+        return this._hashes[key];
     }
-
-    return this._hashes[key];
-  }
-
-  _getModuleList(appModules = []) {
-    const modules = new Array(this._defaultModules.length + appModules.length);
-    const seen = {};
-    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;
-  }
-
 }
-//# sourceMappingURL=pipeline-factory.js.map

package/dist/lib/shader-factory.d.ts

@@ -0,0 +1,17 @@
+import { Device, Shader, ShaderProps } from '@luma.gl/core';
+/** Manages a cached pool of Shaders for reuse. */
+export declare class ShaderFactory {
+    static readonly defaultProps: Required<ShaderProps>;
+    readonly device: Device;
+    private readonly _cache;
+    /** Returns the default ShaderFactory for the given {@link Device}, creating one if necessary. */
+    static getDefaultShaderFactory(device: Device): ShaderFactory;
+    /** @internal */
+    constructor(device: Device);
+    /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */
+    createShader(props: ShaderProps): Shader;
+    /** Releases a previously-requested {@link Shader}, destroying it if no users remain. */
+    release(shader: Shader): void;
+    private _hashShader;
+}
+//# sourceMappingURL=shader-factory.d.ts.map

package/dist/lib/shader-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader-factory.d.ts","sourceRoot":"","sources":["../../src/lib/shader-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1D,kDAAkD;AAClD,qBAAa,aAAa;IACxB,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,WAAW,CAAC,CAA4B;IAE/E,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0D;IAEjF,iGAAiG;IACjG,MAAM,CAAC,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa;IAK7D,gBAAgB;gBACJ,MAAM,EAAE,MAAM;IAI1B,yFAAyF;IACzF,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM;IAgBxC,wFAAwF;IACxF,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAc7B,OAAO,CAAC,WAAW;CAGpB"}

package/dist/lib/shader-factory.js

@@ -0,0 +1,46 @@
+import { Shader } from '@luma.gl/core';
+/** Manages a cached pool of Shaders for reuse. */
+export class ShaderFactory {
+    static defaultProps = { ...Shader.defaultProps };
+    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` : 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) {
+        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
+    _hashShader(value) {
+        return `${value.stage}:${value.source}`;
+    }
+}