@luma.gl/engine 9.3.0-alpha.4 → 9.3.0-alpha.6

package/src/factories/pipeline-factory.ts

@@ -2,15 +2,14 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {RenderPipelineProps, ComputePipelineProps} from '@luma.gl/core';
-import {Device, RenderPipeline, ComputePipeline, log} from '@luma.gl/core';
+import type {RenderPipelineProps, ComputePipelineProps, SharedRenderPipeline} from '@luma.gl/core';
+import {Device, RenderPipeline, ComputePipeline, Resource, log} from '@luma.gl/core';
 import type {EngineModuleState} from '../types';
 import {uid} from '../utils/uid';
 
 export type PipelineFactoryProps = RenderPipelineProps;
 
-type RenderPipelineCacheItem = {pipeline: RenderPipeline; useCount: number};
-type ComputePipelineCacheItem = {pipeline: ComputePipeline; useCount: number};
+type CacheItem<ResourceT extends Resource<any>> = {resource: ResourceT; useCount: number};
 
 /**
  * Efficiently creates / caches pipelines
@@ -26,14 +25,12 @@ export class PipelineFactory {
   }
 
   readonly device: Device;
-  readonly cachingEnabled: boolean;
-  readonly destroyPolicy: 'unused' | 'never';
-  readonly debug: boolean;
 
   private _hashCounter: number = 0;
   private readonly _hashes: Record<string, number> = {};
-  private readonly _renderPipelineCache: Record<string, RenderPipelineCacheItem> = {};
-  private readonly _computePipelineCache: Record<string, ComputePipelineCacheItem> = {};
+  private readonly _renderPipelineCache: Record<string, CacheItem<RenderPipeline>> = {};
+  private readonly _computePipelineCache: Record<string, CacheItem<ComputePipeline>> = {};
+  private readonly _sharedRenderPipelineCache: Record<string, CacheItem<SharedRenderPipeline>> = {};
 
   get [Symbol.toStringTag](): string {
     return 'PipelineFactory';
@@ -45,14 +42,11 @@ export class PipelineFactory {
 
   constructor(device: Device) {
     this.device = device;
-    this.cachingEnabled = device.props._cachePipelines;
-    this.destroyPolicy = device.props._cacheDestroyPolicy;
-    this.debug = device.props.debugFactories;
   }
 
   /** Return a RenderPipeline matching supplied props. Reuses an equivalent pipeline if already created. */
   createRenderPipeline(props: RenderPipelineProps): RenderPipeline {
-    if (!this.cachingEnabled) {
+    if (!this.device.props._cachePipelines) {
       return this.device.createRenderPipeline(props);
     }
 
@@ -61,23 +55,28 @@ export class PipelineFactory {
     const cache = this._renderPipelineCache;
     const hash = this._hashRenderPipeline(allProps);
 
-    let pipeline: RenderPipeline = cache[hash]?.pipeline;
+    let pipeline: RenderPipeline = cache[hash]?.resource;
     if (!pipeline) {
+      const sharedRenderPipeline =
+        this.device.type === 'webgl' && this.device.props._sharePipelines
+          ? this.createSharedRenderPipeline(allProps)
+          : undefined;
       pipeline = this.device.createRenderPipeline({
         ...allProps,
-        id: allProps.id ? `${allProps.id}-cached` : uid('unnamed-cached')
+        id: allProps.id ? `${allProps.id}-cached` : uid('unnamed-cached'),
+        _sharedRenderPipeline: sharedRenderPipeline
       });
       pipeline.hash = hash;
-      cache[hash] = {pipeline, useCount: 1};
-      if (this.debug) {
+      cache[hash] = {resource: pipeline, useCount: 1};
+      if (this.device.props.debugFactories) {
         log.log(3, `${this}: ${pipeline} created, count=${cache[hash].useCount}`)();
       }
     } else {
       cache[hash].useCount++;
-      if (this.debug) {
+      if (this.device.props.debugFactories) {
         log.log(
           3,
-          `${this}: ${cache[hash].pipeline} reused, count=${cache[hash].useCount}, (id=${props.id})`
+          `${this}: ${cache[hash].resource} reused, count=${cache[hash].useCount}, (id=${props.id})`
         )();
       }
     }
@@ -87,7 +86,7 @@ export class PipelineFactory {
 
   /** Return a ComputePipeline matching supplied props. Reuses an equivalent pipeline if already created. */
   createComputePipeline(props: ComputePipelineProps): ComputePipeline {
-    if (!this.cachingEnabled) {
+    if (!this.device.props._cachePipelines) {
       return this.device.createComputePipeline(props);
     }
 
@@ -96,23 +95,23 @@ export class PipelineFactory {
     const cache = this._computePipelineCache;
     const hash = this._hashComputePipeline(allProps);
 
-    let pipeline: ComputePipeline = cache[hash]?.pipeline;
+    let pipeline: ComputePipeline = cache[hash]?.resource;
     if (!pipeline) {
       pipeline = this.device.createComputePipeline({
         ...allProps,
         id: allProps.id ? `${allProps.id}-cached` : undefined
       });
       pipeline.hash = hash;
-      cache[hash] = {pipeline, useCount: 1};
-      if (this.debug) {
+      cache[hash] = {resource: pipeline, useCount: 1};
+      if (this.device.props.debugFactories) {
         log.log(3, `${this}: ${pipeline} created, count=${cache[hash].useCount}`)();
       }
     } else {
       cache[hash].useCount++;
-      if (this.debug) {
+      if (this.device.props.debugFactories) {
         log.log(
           3,
-          `${this}: ${cache[hash].pipeline} reused, count=${cache[hash].useCount}, (id=${props.id})`
+          `${this}: ${cache[hash].resource} reused, count=${cache[hash].useCount}, (id=${props.id})`
         )();
       }
     }
@@ -121,7 +120,7 @@ export class PipelineFactory {
   }
 
   release(pipeline: RenderPipeline | ComputePipeline): void {
-    if (!this.cachingEnabled) {
+    if (!this.device.props._cachePipelines) {
       pipeline.destroy();
       return;
     }
@@ -132,40 +131,72 @@ export class PipelineFactory {
     cache[hash].useCount--;
     if (cache[hash].useCount === 0) {
       this._destroyPipeline(pipeline);
-      if (this.debug) {
+      if (this.device.props.debugFactories) {
         log.log(3, `${this}: ${pipeline} released and destroyed`)();
       }
     } else if (cache[hash].useCount < 0) {
       log.error(`${this}: ${pipeline} released, useCount < 0, resetting`)();
       cache[hash].useCount = 0;
-    } else if (this.debug) {
+    } else if (this.device.props.debugFactories) {
       log.log(3, `${this}: ${pipeline} released, count=${cache[hash].useCount}`)();
     }
   }
 
+  createSharedRenderPipeline(props: RenderPipelineProps): SharedRenderPipeline {
+    const sharedPipelineHash = this._hashSharedRenderPipeline(props);
+    let sharedCacheItem = this._sharedRenderPipelineCache[sharedPipelineHash];
+    if (!sharedCacheItem) {
+      const sharedRenderPipeline = this.device._createSharedRenderPipelineWebGL(props);
+      sharedCacheItem = {resource: sharedRenderPipeline, useCount: 0};
+      this._sharedRenderPipelineCache[sharedPipelineHash] = sharedCacheItem;
+    }
+    sharedCacheItem.useCount++;
+    return sharedCacheItem.resource;
+  }
+
+  releaseSharedRenderPipeline(pipeline: RenderPipeline): void {
+    if (!pipeline.sharedRenderPipeline) {
+      return;
+    }
+
+    const sharedPipelineHash = this._hashSharedRenderPipeline(pipeline.sharedRenderPipeline.props);
+    const sharedCacheItem = this._sharedRenderPipelineCache[sharedPipelineHash];
+    if (!sharedCacheItem) {
+      return;
+    }
+
+    sharedCacheItem.useCount--;
+    if (sharedCacheItem.useCount === 0) {
+      sharedCacheItem.resource.destroy();
+      delete this._sharedRenderPipelineCache[sharedPipelineHash];
+    }
+  }
+
   // PRIVATE
 
-  /** Destroy a cached pipeline, removing it from the cache (depending on destroy policy) */
+  /** Destroy a cached pipeline, removing it from the cache if configured to do so. */
   private _destroyPipeline(pipeline: RenderPipeline | ComputePipeline): boolean {
     const cache = this._getCache(pipeline);
 
-    switch (this.destroyPolicy) {
-      case 'never':
-        return false;
-      case 'unused':
-        delete cache[pipeline.hash];
-        pipeline.destroy();
-        return true;
+    if (!this.device.props._destroyPipelines) {
+      return false;
+    }
+
+    delete cache[pipeline.hash];
+    pipeline.destroy();
+    if (pipeline instanceof RenderPipeline) {
+      this.releaseSharedRenderPipeline(pipeline);
     }
+    return true;
   }
 
   /** Get the appropriate cache for the type of pipeline */
   private _getCache(
     pipeline: RenderPipeline | ComputePipeline
-  ): Record<string, RenderPipelineCacheItem> | Record<string, ComputePipelineCacheItem> {
+  ): Record<string, CacheItem<RenderPipeline>> | Record<string, CacheItem<ComputePipeline>> {
     let cache:
-      | Record<string, RenderPipelineCacheItem>
-      | Record<string, ComputePipelineCacheItem>
+      | Record<string, CacheItem<RenderPipeline>>
+      | Record<string, CacheItem<ComputePipeline>>
       | undefined;
     if (pipeline instanceof ComputePipeline) {
       cache = this._computePipelineCache;
@@ -193,18 +224,16 @@ export class PipelineFactory {
   private _hashRenderPipeline(props: RenderPipelineProps): string {
     const vsHash = props.vs ? this._getHash(props.vs.source) : 0;
     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 varyingHash = this._getWebGLVaryingHash(props);
     const bufferLayoutHash = this._getHash(JSON.stringify(props.bufferLayout));
 
     const {type} = this.device;
     switch (type) {
       case 'webgl':
-        // WebGL is more dynamic
-        return `${type}/R/${vsHash}/${fsHash}V${varyingHash}BL${bufferLayoutHash}`;
+        // WebGL wrappers preserve default topology and parameter semantics for direct
+        // callers, even though the underlying linked program may be shared separately.
+        const webglParameterHash = this._getHash(JSON.stringify(props.parameters));
+        return `${type}/R/${vsHash}/${fsHash}V${varyingHash}T${props.topology}P${webglParameterHash}BL${bufferLayoutHash}`;
 
       case 'webgpu':
       default:
@@ -216,10 +245,22 @@ export class PipelineFactory {
     }
   }
 
+  private _hashSharedRenderPipeline(props: RenderPipelineProps): string {
+    const vsHash = props.vs ? this._getHash(props.vs.source) : 0;
+    const fsHash = props.fs ? this._getHash(props.fs.source) : 0;
+    const varyingHash = this._getWebGLVaryingHash(props);
+    return `webgl/S/${vsHash}/${fsHash}V${varyingHash}`;
+  }
+
   private _getHash(key: string): number {
     if (this._hashes[key] === undefined) {
       this._hashes[key] = this._hashCounter++;
     }
     return this._hashes[key];
   }
+
+  private _getWebGLVaryingHash(props: RenderPipelineProps): number {
+    const {varyings = [], bufferMode = null} = props;
+    return this._getHash(JSON.stringify({varyings, bufferMode}));
+  }
 }

package/src/factories/shader-factory.ts

@@ -5,6 +5,8 @@
 import {Device, Shader, ShaderProps, log} from '@luma.gl/core';
 import type {EngineModuleState} from '../types';
 
+type CacheItem = {resource: Shader; useCount: number};
+
 /** Manages a cached pool of Shaders for reuse. */
 export class ShaderFactory {
   static readonly defaultProps: Required<ShaderProps> = {...Shader.defaultProps};
@@ -17,11 +19,8 @@ export class ShaderFactory {
   }
 
   public readonly device: Device;
-  readonly cachingEnabled: boolean;
-  readonly destroyPolicy: 'unused' | 'never';
-  readonly debug: boolean;
 
-  private readonly _cache: Record<string, {shader: Shader; useCount: number}> = {};
+  private readonly _cache: Record<string, CacheItem> = {};
 
   get [Symbol.toStringTag](): string {
     return 'ShaderFactory';
@@ -34,14 +33,11 @@ export class ShaderFactory {
   /** @internal */
   constructor(device: Device) {
     this.device = device;
-    this.cachingEnabled = device.props._cacheShaders;
-    this.destroyPolicy = device.props._cacheDestroyPolicy;
-    this.debug = true; // device.props.debugFactories;
   }
 
   /** Requests a {@link Shader} from the cache, creating a new Shader only if necessary. */
   createShader(props: ShaderProps): Shader {
-    if (!this.cachingEnabled) {
+    if (!this.device.props._cacheShaders) {
       return this.device.createShader(props);
     }
 
@@ -49,30 +45,30 @@ export class ShaderFactory {
 
     let cacheEntry = this._cache[key];
     if (!cacheEntry) {
-      const shader = this.device.createShader({
+      const resource = this.device.createShader({
         ...props,
         id: props.id ? `${props.id}-cached` : undefined
       });
-      this._cache[key] = cacheEntry = {shader, useCount: 1};
-      if (this.debug) {
-        log.log(3, `${this}: Created new shader ${shader.id}`)();
+      this._cache[key] = cacheEntry = {resource, useCount: 1};
+      if (this.device.props.debugFactories) {
+        log.log(3, `${this}: Created new shader ${resource.id}`)();
       }
     } else {
       cacheEntry.useCount++;
-      if (this.debug) {
+      if (this.device.props.debugFactories) {
         log.log(
           3,
-          `${this}: Reusing shader ${cacheEntry.shader.id} count=${cacheEntry.useCount}`
+          `${this}: Reusing shader ${cacheEntry.resource.id} count=${cacheEntry.useCount}`
         )();
       }
     }
 
-    return cacheEntry.shader;
+    return cacheEntry.resource;
   }
 
   /** Releases a previously-requested {@link Shader}, destroying it if no users remain. */
   release(shader: Shader): void {
-    if (!this.cachingEnabled) {
+    if (!this.device.props._cacheShaders) {
       shader.destroy();
       return;
     }
@@ -82,16 +78,16 @@ export class ShaderFactory {
     if (cacheEntry) {
       cacheEntry.useCount--;
       if (cacheEntry.useCount === 0) {
-        if (this.destroyPolicy === 'unused') {
+        if (this.device.props._destroyShaders) {
           delete this._cache[key];
-          cacheEntry.shader.destroy();
-          if (this.debug) {
+          cacheEntry.resource.destroy();
+          if (this.device.props.debugFactories) {
             log.log(3, `${this}: Releasing shader ${shader.id}, destroyed`)();
           }
         }
       } else if (cacheEntry.useCount < 0) {
         throw new Error(`ShaderFactory: Shader ${shader.id} released too many times`);
-      } else if (this.debug) {
+      } else if (this.device.props.debugFactories) {
         log.log(3, `${this}: Releasing shader ${shader.id} count=${cacheEntry.useCount}`)();
       }
     }

package/src/geometries/cone-geometry.ts

@@ -2,13 +2,18 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {TruncatedConeGeometryProps} from './truncated-cone-geometry';
 import {TruncatedConeGeometry} from './truncated-cone-geometry';
 import {uid} from '../utils/uid';
 
-export type ConeGeometryProps = {
+export type ConeGeometryProps = Omit<
+  TruncatedConeGeometryProps,
+  'topRadius' | 'bottomRadius' | 'topCap' | 'bottomCap'
+> & {
   id?: string;
   radius?: number;
   cap?: boolean;
+  attributes?: any;
 };
 
 export class ConeGeometry extends TruncatedConeGeometry {

package/src/geometries/cylinder-geometry.ts

@@ -2,10 +2,14 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {TruncatedConeGeometryProps} from './truncated-cone-geometry';
 import {TruncatedConeGeometry} from './truncated-cone-geometry';
 import {uid} from '../utils/uid';
 
-export type CylinderGeometryProps = {
+export type CylinderGeometryProps = Omit<
+  TruncatedConeGeometryProps,
+  'topRadius' | 'bottomRadius'
+> & {
   id?: string;
   radius?: number;
   attributes?: any;

package/src/model/model.ts

@@ -64,6 +64,8 @@ export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs' | 'bindings'> & {
   shaderInputs?: ShaderInputs;
   /** Bindings */
   bindings?: Record<string, Binding | DynamicTexture>;
+  /** WebGL-only uniforms */
+  uniforms?: Record<string, unknown>;
   /** Parameters that are built into the pipeline */
   parameters?: RenderPipelineParameters;
 
@@ -114,7 +116,7 @@ export type ModelProps = Omit<RenderPipelineProps, 'vs' | 'fs' | 'bindings'> & {
  * - Reuses and lazily recompiles {@link RenderPipeline | pipelines} as needed.
  * - Integrates with `@luma.gl/shadertools` to assemble GLSL or WGSL from shader modules.
  * - Manages geometry attributes and buffer bindings.
- * - Accepts textures, samplers and uniform buffers as bindings, including `AsyncTexture`.
+ * - Accepts textures, samplers and uniform buffers as bindings, including `DynamicTexture`.
  * - Provides detailed debug logging and optional shader source inspection.
  */
 export class Model {
@@ -132,6 +134,8 @@ export class Model {
     indexBuffer: null,
     attributes: {},
     constantAttributes: {},
+    bindings: {},
+    uniforms: {},
     varyings: [],
 
     isInstanced: undefined!,
@@ -357,7 +361,7 @@ export class Model {
       this.pipelineFactory.release(this.pipeline);
       // Release the shaders
       this.shaderFactory.release(this.pipeline.vs);
-      if (this.pipeline.fs) {
+      if (this.pipeline.fs && this.pipeline.fs !== this.pipeline.vs) {
         this.shaderFactory.release(this.pipeline.fs);
       }
       this._uniformStore.destroy();
@@ -422,14 +426,7 @@ export class Model {
       // Application can call Model.predraw() to avoid this.
       this.pipeline = this._updatePipeline();
 
-      // 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
-      // TODO this is a busy initialized check for all bindings every frame
-
       const syncBindings = this._getBindings();
-      this.pipeline.setBindings(syncBindings, {
-        disableWarnings: this.props.disableWarnings
-      });
 
       const {indexBuffer} = this.vertexArray;
       const indexCount = indexBuffer
@@ -444,6 +441,11 @@ export class Model {
         instanceCount: this.instanceCount,
         indexCount,
         transformFeedback: this.transformFeedback || undefined,
+        // Pipelines may be shared across models when caching is enabled, so bindings
+        // and WebGL uniforms must be supplied on every draw instead of being stored
+        // on the pipeline instance.
+        bindings: syncBindings,
+        uniforms: this.props.uniforms,
         // WebGL shares underlying cached pipelines even for models that have different parameters and topology,
         // so we must provide our unique parameters to each draw
         // (In WebGPU most parameters are encoded in the pipeline and cannot be changed per draw call)
@@ -827,7 +829,9 @@ export class Model {
       );
 
       if (prevShaderVs) this.shaderFactory.release(prevShaderVs);
-      if (prevShaderFs) this.shaderFactory.release(prevShaderFs);
+      if (prevShaderFs && prevShaderFs !== prevShaderVs) {
+        this.shaderFactory.release(prevShaderFs);
+      }
     }
     return this.pipeline;
   }

package/src/models/billboard-texture-model.ts

@@ -22,15 +22,15 @@ struct backgroundUniforms {
 };
 @group(0) @binding(2) var<uniform> background: backgroundUniforms;
 
-fn billboardTexture_getTextureUV(coordinates: vec2<f32>) -> vec2<f32> {
+fn billboardTexture_getTextureUV(uv: vec2<f32>) -> vec2<f32> {
         let scale: vec2<f32> = background.scale;
-        var position: vec2<f32> = (coordinates - vec2<f32>(0.5, 0.5)) / scale + vec2<f32>(0.5, 0.5);
+        var position: vec2<f32> = (uv - vec2<f32>(0.5, 0.5)) / scale + vec2<f32>(0.5, 0.5);
         return position;
 }
 
 @fragment
 fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4<f32> {
-        let position: vec2<f32> = billboardTexture_getTextureUV(inputs.coordinate);
+        let position: vec2<f32> = billboardTexture_getTextureUV(inputs.uv);
         return textureSample(backgroundTexture, backgroundTextureSampler, position);
 }
 `;
@@ -79,21 +79,23 @@ export class BackgroundTextureModel extends ClipSpace {
 
   constructor(device: Device, props: BackgroundTextureModelProps) {
     super(device, {
+      ...props,
       id: props.id || 'background-texture-model',
       source: BACKGROUND_FS_WGSL,
       fs: BACKGROUND_FS,
-      modules: [backgroundModule],
+      modules: [...(props.modules || []), backgroundModule],
       parameters: {
         depthWriteEnabled: false,
+        ...(props.parameters || {}),
         ...(props.blend
           ? {
               blend: true,
               blendColorOperation: 'add',
               blendAlphaOperation: 'add',
-              blendColorSrcFactor: 'one',
-              blendColorDstFactor: 'one-minus-src',
-              blendAlphaSrcFactor: 'one',
-              blendAlphaDstFactor: 'one-minus-src-alpha'
+              blendColorSrcFactor: 'one-minus-dst-alpha',
+              blendColorDstFactor: 'one',
+              blendAlphaSrcFactor: 'one-minus-dst-alpha',
+              blendAlphaDstFactor: 'one'
             }
           : {})
       }

package/src/models/clip-space.ts

@@ -10,9 +10,9 @@ import {uid} from '../utils/uid';
 
 const CLIPSPACE_VERTEX_SHADER_WGSL = /* wgsl */ `\
 struct VertexInputs {
-  @location(0) clipSpacePosition: vec2<f32>,
-  @location(1) texCoord: vec2<f32>,
-  @location(2) coordinate: vec2<f32>  
+  @location(0) clipSpacePositions: vec2<f32>,
+  @location(1) texCoords: vec2<f32>,
+  @location(2) coordinates: vec2<f32>
 }
 
 struct FragmentInputs {
@@ -25,10 +25,10 @@ struct FragmentInputs {
 @vertex
 fn vertexMain(inputs: VertexInputs) -> FragmentInputs {
   var outputs: FragmentInputs;
-  outputs.Position = vec4(inputs.clipSpacePosition, 0., 1.);
-  outputs.position = inputs.clipSpacePosition;
-  outputs.coordinate = inputs.coordinate;
-  outputs.uv = inputs.texCoord;
+  outputs.Position = vec4(inputs.clipSpacePositions, 0., 1.);
+  outputs.position = inputs.clipSpacePositions;
+  outputs.coordinate = inputs.coordinates;
+  outputs.uv = inputs.texCoords;
   return outputs;
 }
 `;

package/src/modules/picking/index-picking.ts

@@ -16,12 +16,6 @@ const INDEX_PICKING_MODE_INSTANCE = 0;
 const INDEX_PICKING_MODE_CUSTOM = 1;
 const INDEX_PICKING_INVALID_INDEX = ${INVALID_INDEX}; // 2^32 - 1
 
-struct indexPickingFragmentInputs = {
-  objectIndex: int32;
-};
-
-let indexPickingFragmentInputs: indexPickingFragmentInputs;
-
 /**
  * Vertex shaders should call this function to set the object index.
  * If using instance or vertex mode, argument will be ignored, 0 can be supplied.

package/src/passes/get-fragment-shader.ts

@@ -36,26 +36,16 @@ export function getFragmentShaderForRenderPass(options: {
 /** Get a filtering WGSL fragment shader */
 function getFilterShaderWGSL(func: string) {
   return /* wgsl */ `\
-// Binding 0:1 is reserved for shader passes
-// @group(0) @binding(0) var<uniform> brightnessContrast : brightnessContrastUniforms;
-@group(0) @binding(1) var texture: texture_2d<f32>;
-@group(0) @binding(2) var textureSampler: sampler;
-
-// This needs to be aligned with
-// struct FragmentInputs {
-//   @location(0) fragUV: vec2f,
-//   @location(1) fragPosition: vec4f,
-//   @location(2) fragCoordinate: vec4f
-// };
+@group(0) @binding(0) var sourceTexture: texture_2d<f32>;
+@group(0) @binding(2) var sourceTextureSampler: sampler;
 
 @fragment
 fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
-  let fragUV = inputs.uv;
-  let fragCoordinate = inputs.coordinate;
-  let texSize = vec2f(textureDimensions(texture, 0));
+  let texCoord = inputs.coordinate;
+  let texSize = vec2f(textureDimensions(sourceTexture));
 
-  var fragColor = textureSample(texture, textureSampler, fragUV);
-  fragColor = ${func}(fragColor, texSize, fragCoordinate);
+  var fragColor = textureSample(sourceTexture, sourceTextureSampler, texCoord);
+  fragColor = ${func}(fragColor, texSize, texCoord);
   return fragColor;
 }
 `;
@@ -64,23 +54,14 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
 /** Get a sampling WGSL fragment shader */
 function getSamplerShaderWGSL(func: string) {
   return /* wgsl */ `\
-// Binding 0:1 is reserved for shader passes
-@group(0) @binding(0) var<uniform> brightnessContrast : brightnessContrastUniforms;
-@group(0) @binding(1) var texture: texture_2d<f32>;
-@group(0) @binding(2) var sampler: sampler;
-
-struct FragmentInputs = {
-  @location(0) fragUV: vec2f,
-  @location(1) fragPosition: vec4f,
-  @location(2) fragCoordinate: vec4f
-};
+@group(0) @binding(0) var sourceTexture: texture_2d<f32>;
+@group(0) @binding(2) var sourceTextureSampler: sampler;
 
 @fragment
 fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
-  let texSize = vec2f(textureDimensions(texture, 0));
-  var fragColor = textureSample(texture, sampler, fragUV);
-  fragColor = ${func}(fragColor, texSize, texCoord);
-  return fragColor;
+  let texCoord = inputs.coordinate;
+  let texSize = vec2f(textureDimensions(sourceTexture));
+  return ${func}(sourceTexture, sourceTextureSampler, texSize, texCoord);
 }
 `;
 }