@luma.gl/engine 9.2.6 → 9.3.0-alpha.11

package/src/passes/shader-pass-renderer.ts

@@ -6,7 +6,7 @@ import {Device, RenderPass, Texture} from '@luma.gl/core';
 import type {ShaderPass} from '@luma.gl/shadertools';
 import {initializeShaderModule} from '@luma.gl/shadertools';
 import {ShaderInputs} from '../shader-inputs';
-import {AsyncTexture} from '../async-texture/async-texture';
+import {DynamicTexture} from '../dynamic-texture/dynamic-texture';
 import {ClipSpace} from '../models/clip-space';
 import {SwapFramebuffers} from '../compute/swap';
 import {BackgroundTextureModel} from '../models/billboard-texture-model';
@@ -20,7 +20,7 @@ export type ShaderPassRendererProps = {
   /** List of ShaderPasses to apply to the sourceTexture */
   shaderPasses: ShaderPass[];
   /** Optional typed ShaderInputs object for setting uniforms */
-  shaderInputs: ShaderInputs;
+  shaderInputs?: ShaderInputs;
 };
 
 /** A pass that renders a given texture into screen space */
@@ -29,8 +29,6 @@ export class ShaderPassRenderer {
   shaderInputs: ShaderInputs;
   passRenderers: PassRenderer[];
   swapFramebuffers: SwapFramebuffers;
-  /** For rendering to the screen */
-  clipSpace: ClipSpace;
   textureModel: BackgroundTextureModel;
 
   constructor(device: Device, props: ShaderPassRendererProps) {
@@ -55,33 +53,6 @@ export class ShaderPassRenderer {
       backgroundTexture: this.swapFramebuffers.current.colorAttachments[0].texture
     });
 
-    this.clipSpace = new ClipSpace(device, {
-      source: /* wgsl */ `\
-  @group(0) @binding(0) var sourceTexture: texture_2d<f32>;
-  @group(0) @binding(1) var sourceTextureSampler: sampler;
-
-@fragment
-fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4<f32> {
-	let texCoord: vec2<f32> = inputs.coordinate;
-	return textureSample(sourceTexture, sourceTextureSampler, texCoord);
-}
-`,
-
-      fs: /* glsl */ `\
-#version 300 es
-
-uniform sampler2D sourceTexture;
-in vec2 uv;
-in vec2 coordinate;
-out vec4 fragColor;
-
-void main() {
-  vec2 texCoord = coordinate;
-  fragColor = texture(sourceTexture, coordinate);
-}
-`
-    });
-
     this.passRenderers = props.shaderPasses.map(shaderPass => new PassRenderer(device, shaderPass));
   }
 
@@ -91,15 +62,19 @@ void main() {
       subPassRenderer.destroy();
     }
     this.swapFramebuffers.destroy();
-    this.clipSpace.destroy();
+    this.textureModel.destroy();
   }
 
-  resize(width: number, height: number): void {
-    this.swapFramebuffers.resize({width, height});
-    // this.props.passes.forEach(pass => pass.resize(width, height));
+  resize(size?: [width: number, height: number]): void {
+    size ||= this.device.getCanvasContext().getDrawingBufferSize();
+    this.swapFramebuffers.resize({width: size[0], height: size[1]});
   }
 
-  renderToScreen(options: {sourceTexture: AsyncTexture; uniforms?: any; bindings?: any}): boolean {
+  renderToScreen(options: {
+    sourceTexture: DynamicTexture;
+    uniforms?: any;
+    bindings?: any;
+  }): boolean {
     // Run the shader passes and generate an output texture
     const outputTexture = this.renderToTexture(options);
     if (!outputTexture) {
@@ -109,16 +84,15 @@ void main() {
 
     const framebuffer = this.device
       .getDefaultCanvasContext()
-      // @ts-expect-error TODO - remove after republish
-      .getCurrentFramebuffer({depthStencilAttachment: false});
+      .getCurrentFramebuffer({depthStencilFormat: false});
     const renderPass = this.device.beginRenderPass({
       id: 'shader-pass-renderer-to-screen',
       framebuffer,
-      clearColor: [0, 0, 0, 1],
-      clearDepth: 1
+      // clearColor: [1, 1, 0, 1],
+      clearDepth: false
     });
-    this.clipSpace.setBindings({sourceTexture: outputTexture});
-    this.clipSpace.draw(renderPass);
+    this.textureModel.setProps({backgroundTexture: outputTexture});
+    this.textureModel.draw(renderPass);
     renderPass.end();
     return true;
   }
@@ -127,7 +101,7 @@ void main() {
    * @returns null if the the sourceTexture has not yet been loaded
    */
   renderToTexture(options: {
-    sourceTexture: AsyncTexture;
+    sourceTexture: DynamicTexture;
     uniforms?: any;
     bindings?: any;
   }): Texture | null {
@@ -136,20 +110,23 @@ void main() {
       return null;
     }
 
-    this.textureModel.destroy();
-    this.textureModel = new BackgroundTextureModel(this.device, {
-      backgroundTexture: sourceTexture
-    });
+    // If no shader passes are provided, just return the original texture
+    if (this.passRenderers.length === 0) {
+      return sourceTexture.texture;
+    }
+
+    this.textureModel.setProps({backgroundTexture: sourceTexture});
 
     // Clear the current texture before we begin
     const clearTexturePass = this.device.beginRenderPass({
       id: 'shader-pass-renderer-clear-texture',
       framebuffer: this.swapFramebuffers.current,
-      clearColor: [0, 0, 0, 1]
+      clearColor: [1, 0, 0, 1]
     });
     this.textureModel.draw(clearTexturePass);
     clearTexturePass.end();
 
+    // Copy the texture contents
     // const commandEncoder = this.device.createCommandEncoder();
     // commandEncoder.copyTextureToTexture({
     //   sourceTexture: sourceTexture.texture,

package/src/scenegraph/group-node.ts

@@ -108,4 +108,20 @@ export class GroupNode extends ScenegraphNode {
       }
     }
   }
+
+  preorderTraversal(
+    visitor: (node: ScenegraphNode, context: {worldMatrix: Matrix4}) => void,
+    {worldMatrix = new Matrix4()} = {}
+  ) {
+    const modelMatrix = new Matrix4(worldMatrix).multiplyRight(this.matrix);
+    visitor(this, {worldMatrix: modelMatrix});
+
+    for (const child of this.children) {
+      if (child instanceof GroupNode) {
+        child.preorderTraversal(visitor, {worldMatrix: modelMatrix});
+      } else {
+        visitor(child, {worldMatrix: modelMatrix});
+      }
+    }
+  }
 }

package/src/scenegraph/model-node.ts

@@ -9,12 +9,12 @@ import {Model} from '../model/model';
 export type ModelNodeProps = ScenegraphNodeProps & {
   model: Model;
   managedResources?: any[];
-  bounds?: [number[], number[]];
+  bounds?: [[number, number, number], [number, number, number]];
 };
 
 export class ModelNode extends ScenegraphNode {
   readonly model: Model;
-  bounds: [number[], number[]] | null = null;
+  bounds: [[number, number, number], [number, number, number]] | null = null;
   managedResources: any[];
 
   // TODO - is this used? override callbacks to make sure we call them with this

package/src/scenegraph/scenegraph-node.ts

@@ -5,6 +5,12 @@
 import {Vector3, Matrix4, NumericArray} from '@math.gl/core';
 import {uid} from '../utils/uid';
 
+function assert(condition: boolean, message?: string): asserts condition {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
 /** Properties for creating a new Scenegraph */
 export type ScenegraphNodeProps = {
   id?: string;
@@ -57,19 +63,19 @@ export class ScenegraphNode {
   }
 
   setPosition(position: any): this {
-    // assert(position.length === 3, 'setPosition requires vector argument');
+    assert(position.length === 3, 'setPosition requires vector argument');
     this.position = position;
     return this;
   }
 
   setRotation(rotation: any): this {
-    // assert(rotation.length === 3, 'setRotation requires vector argument');
+    assert(rotation.length === 3 || rotation.length === 4, 'setRotation requires vector argument');
     this.rotation = rotation;
     return this;
   }
 
   setScale(scale: any): this {
-    // assert(scale.length === 3, 'setScale requires vector argument');
+    assert(scale.length === 3, 'setScale requires vector argument');
     this.scale = scale;
     return this;
   }
@@ -105,19 +111,20 @@ export class ScenegraphNode {
   }
 
   updateMatrix(): this {
-    const pos = this.position;
-    const rot = this.rotation;
-    const scale = this.scale;
-
     this.matrix.identity();
-    this.matrix.translate(pos);
-    this.matrix.rotateXYZ(rot);
-    this.matrix.scale(scale);
+    this.matrix.translate(this.position);
+    if (this.rotation.length === 4) {
+      const rotationMatrix = new Matrix4().fromQuaternion(this.rotation);
+      this.matrix.multiplyRight(rotationMatrix);
+    } else {
+      this.matrix.rotateXYZ(this.rotation);
+    }
+    this.matrix.scale(this.scale);
+
     return this;
   }
 
-  update(options: {position?: any; rotation?: any; scale?: any} = {}): this {
-    const {position, rotation, scale} = options;
+  update({position, rotation, scale}: {position?: any; rotation?: any; scale?: any} = {}): this {
     if (position) {
       this.setPosition(position);
     }
@@ -127,7 +134,9 @@ export class ScenegraphNode {
     if (scale) {
       this.setScale(scale);
     }
+
     this.updateMatrix();
+
     return this;
   }
 
@@ -188,18 +197,20 @@ export class ScenegraphNode {
     //   this.display = props.display;
     // }
 
-    if ('position' in props) {
+    if (props?.position) {
       this.setPosition(props.position);
     }
-    if ('rotation' in props) {
+    if (props?.rotation) {
       this.setRotation(props.rotation);
     }
-    if ('scale' in props) {
+    if (props?.scale) {
       this.setScale(props.scale);
     }
 
+    this.updateMatrix();
+
     // Matrix overwrites other props
-    if ('matrix' in props) {
+    if (props?.matrix) {
       this.setMatrix(props.matrix);
     }
 

package/src/shader-inputs.ts

@@ -2,16 +2,25 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Binding, UniformValue} from '@luma.gl/core';
+import type {Binding, CompositeShaderType} from '@luma.gl/core';
 import {log} from '@luma.gl/core';
 // import type {VariableShaderType, UniformValue, UniformFormat, UniformInfoDevice, Texture, Sampler} from '@luma.gl/core';
-import {getShaderModuleDependencies, ShaderModule} from '@luma.gl/shadertools';
+import {
+  getShaderModuleDependencies,
+  ShaderModule,
+  ShaderModuleUniformValue
+} from '@luma.gl/shadertools';
 import {splitUniformsAndBindings} from './model/split-uniforms-and-bindings';
 
 export type ShaderInputsOptions = {
   disableWarnings?: boolean;
 };
 
+type ShaderInputsModule = Pick<
+  ShaderModule<any, any, any>,
+  'bindingLayout' | 'defaultUniforms' | 'dependencies' | 'getUniforms' | 'name' | 'uniformTypes'
+>;
+
 /**
  * ShaderInputs holds uniform and binding values for one or more shader modules,
  * - It can generate binary data for any uniform buffer
@@ -33,10 +42,10 @@ export class ShaderInputs<
    * @todo should should this include the resolved dependencies?
    */
   // @ts-ignore Fix typings
-  modules: Readonly<{[P in keyof ShaderPropsT]: ShaderModule<ShaderPropsT[P]>}>;
+  modules: Readonly<{[P in keyof ShaderPropsT]: ShaderInputsModule}>;
 
   /** Stores the uniform values for each module */
-  moduleUniforms: Record<keyof ShaderPropsT, Record<string, UniformValue>>;
+  moduleUniforms: Record<keyof ShaderPropsT, Record<string, ShaderModuleUniformValue>>;
   /** Stores the uniform bindings for each module  */
   moduleBindings: Record<keyof ShaderPropsT, Record<string, Binding>>;
   /** Tracks if uniforms have changed */
@@ -48,14 +57,14 @@ export class ShaderInputs<
    */
   constructor(
     // @ts-ignore Fix typings
-    modules: {[P in keyof ShaderPropsT]?: ShaderModule<ShaderPropsT[P], any>},
+    modules: {[P in keyof ShaderPropsT]?: ShaderInputsModule},
     options?: ShaderInputsOptions
   ) {
     Object.assign(this.options, options);
 
     // Extract modules with dependencies
     const resolvedModules = getShaderModuleDependencies(
-      Object.values(modules).filter(module => module.dependencies)
+      Object.values(modules).filter(isShaderInputsModuleWithDependencies)
     );
     for (const resolvedModule of resolvedModules) {
       // @ts-ignore
@@ -66,15 +75,20 @@ export class ShaderInputs<
 
     // Store the module definitions and create storage for uniform values and binding values, per module
     // @ts-ignore Fix typings
-    this.modules = modules as {[P in keyof ShaderPropsT]: ShaderModule<ShaderPropsT[P]>};
-    this.moduleUniforms = {} as Record<keyof ShaderPropsT, Record<string, UniformValue>>;
+    this.modules = modules as {[P in keyof ShaderPropsT]: ShaderInputsModule};
+    this.moduleUniforms = {} as Record<
+      keyof ShaderPropsT,
+      Record<string, ShaderModuleUniformValue>
+    >;
     this.moduleBindings = {} as Record<keyof ShaderPropsT, Record<string, Binding>>;
 
     // Initialize the modules
     for (const [name, module] of Object.entries(modules)) {
-      this._addModule(module);
-      if (module.name && name !== module.name && !this.options.disableWarnings) {
-        log.warn(`Module name: ${name} vs ${module.name}`)();
+      if (module) {
+        this._addModule(module);
+        if (module.name && name !== module.name && !this.options.disableWarnings) {
+          log.warn(`Module name: ${name} vs ${module.name}`)();
+        }
       }
     }
   }
@@ -95,18 +109,24 @@ export class ShaderInputs<
         if (!this.options.disableWarnings) {
           log.warn(`Module ${name} not found`)();
         }
-        continue; // eslint-disable-line no-continue
-      }
+      } else {
+        const oldUniforms = this.moduleUniforms[moduleName];
+        const oldBindings = this.moduleBindings[moduleName];
+        const uniformsAndBindings =
+          module.getUniforms?.(moduleProps, oldUniforms) || (moduleProps as any);
 
-      const oldUniforms = this.moduleUniforms[moduleName] as (typeof module)['uniforms'];
-      const oldBindings = this.moduleBindings[moduleName];
-      const uniformsAndBindings =
-        module.getUniforms?.(moduleProps, oldUniforms) || (moduleProps as any);
-
-      const {uniforms, bindings} = splitUniformsAndBindings(uniformsAndBindings);
-      this.moduleUniforms[moduleName] = {...oldUniforms, ...uniforms};
-      this.moduleBindings[moduleName] = {...oldBindings, ...bindings};
-      // this.moduleUniformsChanged ||= moduleName;
+        const {uniforms, bindings} = splitUniformsAndBindings(
+          uniformsAndBindings,
+          module.uniformTypes as Readonly<Record<string, CompositeShaderType>>
+        );
+        this.moduleUniforms[moduleName] = mergeModuleUniforms(
+          oldUniforms as Record<string, ShaderModuleUniformValue>,
+          uniforms,
+          module.uniformTypes as Readonly<Record<string, CompositeShaderType>>
+        );
+        this.moduleBindings[moduleName] = {...oldBindings, ...bindings};
+        // this.moduleUniformsChanged ||= moduleName;
+      }
 
       // console.log(`setProps(${String(moduleName)}`, moduleName, this.moduleUniforms[moduleName])
     }
@@ -117,11 +137,13 @@ export class ShaderInputs<
    * @todo should should this include the resolved dependencies?
    */
   getModules(): ShaderModule[] {
-    return Object.values(this.modules);
+    return Object.values(this.modules) as ShaderModule[];
   }
 
   /** Get all uniform values for all modules */
-  getUniformValues(): Partial<Record<keyof ShaderPropsT, Record<string, UniformValue>>> {
+  getUniformValues(): Partial<
+    Record<keyof ShaderPropsT, Record<string, ShaderModuleUniformValue>>
+  > {
     return this.moduleUniforms;
   }
 
@@ -150,10 +172,129 @@ export class ShaderInputs<
     return table;
   }
 
-  _addModule(module: ShaderModule): void {
+  _addModule(module: ShaderInputsModule): void {
     const moduleName = module.name as keyof ShaderPropsT;
     // Get default uniforms from module
-    this.moduleUniforms[moduleName] = module.defaultUniforms || {};
+    this.moduleUniforms[moduleName] = mergeModuleUniforms(
+      {},
+      (module.defaultUniforms || {}) as Record<string, ShaderModuleUniformValue>,
+      module.uniformTypes as Readonly<Record<string, CompositeShaderType>>
+    );
     this.moduleBindings[moduleName] = {};
   }
 }
+
+function mergeModuleUniforms(
+  currentUniforms: Record<string, ShaderModuleUniformValue> = {},
+  nextUniforms: Record<string, ShaderModuleUniformValue> = {},
+  uniformTypes: Readonly<Record<string, CompositeShaderType>> = {}
+): Record<string, ShaderModuleUniformValue> {
+  const mergedUniforms = {...currentUniforms};
+  for (const [key, value] of Object.entries(nextUniforms)) {
+    if (value !== undefined) {
+      mergedUniforms[key] = mergeModuleUniformValue(currentUniforms[key], value, uniformTypes[key]);
+    }
+  }
+  return mergedUniforms;
+}
+
+function mergeModuleUniformValue(
+  currentValue: ShaderModuleUniformValue | undefined,
+  nextValue: ShaderModuleUniformValue,
+  uniformType: CompositeShaderType | undefined
+): ShaderModuleUniformValue {
+  if (!uniformType || typeof uniformType === 'string') {
+    return cloneModuleUniformValue(nextValue);
+  }
+
+  if (Array.isArray(uniformType)) {
+    if (isPackedUniformArrayValue(nextValue) || !Array.isArray(nextValue)) {
+      return cloneModuleUniformValue(nextValue);
+    }
+
+    const currentArray: Array<ShaderModuleUniformValue | undefined> =
+      Array.isArray(currentValue) && !isPackedUniformArrayValue(currentValue)
+        ? [...currentValue]
+        : [];
+    const mergedArray = currentArray.slice();
+    for (let index = 0; index < nextValue.length; index++) {
+      const elementValue = nextValue[index];
+      if (elementValue !== undefined) {
+        mergedArray[index] = mergeModuleUniformValue(
+          currentArray[index],
+          elementValue,
+          uniformType[0] as CompositeShaderType
+        );
+      }
+    }
+    return mergedArray;
+  }
+
+  if (!isPlainUniformObject(nextValue)) {
+    return cloneModuleUniformValue(nextValue);
+  }
+
+  const uniformStruct = uniformType as Record<string, CompositeShaderType>;
+  const currentObject = isPlainUniformObject(currentValue) ? currentValue : {};
+  const mergedObject: Record<string, ShaderModuleUniformValue | undefined> = {...currentObject};
+  for (const [key, value] of Object.entries(nextValue)) {
+    if (value !== undefined) {
+      mergedObject[key] = mergeModuleUniformValue(currentObject[key], value, uniformStruct[key]);
+    }
+  }
+  return mergedObject as ShaderModuleUniformValue;
+}
+
+function cloneModuleUniformValue(value: ShaderModuleUniformValue): ShaderModuleUniformValue {
+  if (ArrayBuffer.isView(value)) {
+    return Array.prototype.slice.call(value) as ShaderModuleUniformValue;
+  }
+
+  if (Array.isArray(value)) {
+    if (isPackedUniformArrayValue(value)) {
+      return value.slice() as ShaderModuleUniformValue;
+    }
+
+    const compositeArray = value as ReadonlyArray<ShaderModuleUniformValue | undefined>;
+    return compositeArray.map(element =>
+      element === undefined ? undefined : cloneModuleUniformValue(element)
+    ) as ShaderModuleUniformValue;
+  }
+
+  if (isPlainUniformObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nestedValue]) => [
+        key,
+        nestedValue === undefined ? undefined : cloneModuleUniformValue(nestedValue)
+      ])
+    ) as ShaderModuleUniformValue;
+  }
+
+  return value;
+}
+
+function isPackedUniformArrayValue(
+  value: unknown
+): value is ReadonlyArray<number> | ArrayBufferView {
+  return (
+    ArrayBuffer.isView(value) ||
+    (Array.isArray(value) && (value.length === 0 || typeof value[0] === 'number'))
+  );
+}
+
+function isPlainUniformObject(
+  value: unknown
+): value is Record<string, ShaderModuleUniformValue | undefined> {
+  return (
+    Boolean(value) &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    !ArrayBuffer.isView(value)
+  );
+}
+
+function isShaderInputsModuleWithDependencies(
+  module: ShaderInputsModule | undefined
+): module is ShaderInputsModule & {dependencies: NonNullable<ShaderInputsModule['dependencies']>} {
+  return Boolean(module?.dependencies);
+}

package/src/utils/buffer-layout-order.ts

@@ -4,6 +4,22 @@
 
 import {type BufferLayout, type ShaderLayout} from '@luma.gl/core';
 
+function getMinLocation(
+  attributeNames: string[],
+  shaderLayoutMap: Record<string, number | undefined>
+): number {
+  let minLocation = Infinity;
+
+  for (const name of attributeNames) {
+    const location = shaderLayoutMap[name];
+    if (location !== undefined) {
+      minLocation = Math.min(minLocation, location);
+    }
+  }
+
+  return minLocation;
+}
+
 export function sortedBufferLayoutByShaderSourceLocations(
   shaderLayout: ShaderLayout,
   bufferLayout: BufferLayout[]
@@ -16,8 +32,8 @@ export function sortedBufferLayoutByShaderSourceLocations(
   sortedLayout.sort((a, b) => {
     const attributeNamesA = a.attributes ? a.attributes.map(attr => attr.attribute) : [a.name];
     const attributeNamesB = b.attributes ? b.attributes.map(attr => attr.attribute) : [b.name];
-    const minLocationA = Math.min(...attributeNamesA.map(name => shaderLayoutMap[name]));
-    const minLocationB = Math.min(...attributeNamesB.map(name => shaderLayoutMap[name]));
+    const minLocationA = getMinLocation(attributeNamesA, shaderLayoutMap);
+    const minLocationB = getMinLocation(attributeNamesB, shaderLayoutMap);
 
     return minLocationA - minLocationB;
   });

package/src/utils/shader-module-utils.ts

@@ -0,0 +1,65 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {ComputeShaderLayout, ShaderLayout} from '@luma.gl/core';
+import type {ShaderModule} from '@luma.gl/shadertools';
+
+type AnyShaderLayout = ShaderLayout | ComputeShaderLayout;
+
+export function mergeShaderModuleBindingsIntoLayout<TShaderLayout extends AnyShaderLayout>(
+  shaderLayout: TShaderLayout | null | undefined,
+  modules: ShaderModule[]
+): TShaderLayout | null | undefined {
+  if (!shaderLayout || !modules.some(module => module.bindingLayout?.length)) {
+    return shaderLayout;
+  }
+
+  const mergedLayout = {
+    ...shaderLayout,
+    bindings: shaderLayout.bindings.map(binding => ({...binding}))
+  } as TShaderLayout;
+
+  if ('attributes' in (shaderLayout || {})) {
+    (mergedLayout as ShaderLayout).attributes = (shaderLayout as ShaderLayout)?.attributes || [];
+  }
+
+  for (const module of modules) {
+    for (const bindingLayout of module.bindingLayout || []) {
+      for (const relatedBindingName of getRelatedBindingNames(bindingLayout.name)) {
+        const binding = mergedLayout.bindings.find(
+          candidate => candidate.name === relatedBindingName
+        );
+        if (binding?.group === 0) {
+          binding.group = bindingLayout.group;
+        }
+      }
+    }
+  }
+
+  return mergedLayout;
+}
+
+export function shaderModuleHasUniforms(module: ShaderModule): boolean {
+  return Boolean(module.uniformTypes && !isObjectEmpty(module.uniformTypes));
+}
+
+/** Returns binding-name aliases that should share the module-declared bind group. */
+function getRelatedBindingNames(bindingName: string): string[] {
+  const bindingNames = new Set<string>([bindingName, `${bindingName}Uniforms`]);
+
+  if (!bindingName.endsWith('Uniforms')) {
+    bindingNames.add(`${bindingName}Sampler`);
+  }
+
+  return [...bindingNames];
+}
+
+function isObjectEmpty(obj: object): boolean {
+  // @ts-ignore key is intentionally unused
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  for (const key in obj) {
+    return false;
+  }
+  return true;
+}