@luma.gl/shadertools 9.3.0-alpha.6 → 9.3.0-alpha.8

package/src/lib/shader-assembly/assemble-shaders.ts

@@ -8,13 +8,24 @@ import {getPlatformShaderDefines} from './platform-defines';
 import {injectShader, DECLARATION_INJECT_MARKER} from './shader-injections';
 import {transpileGLSLShader} from '../shader-transpiler/transpile-glsl-shader';
 import {checkShaderModuleDeprecations} from '../shader-module/shader-module';
+import {validateShaderModuleUniformLayout} from '../shader-module/shader-module-uniform-layout';
 import type {ShaderInjection} from './shader-injections';
 import type {ShaderModule} from '../shader-module/shader-module';
 import {ShaderHook, normalizeShaderHooks, getShaderHooks} from './shader-hooks';
 import {assert} from '../utils/assert';
 import {getShaderInfo} from '../glsl-utils/get-shader-info';
+import {getShaderBindingDebugRowsFromWGSL, type ShaderBindingDebugRow} from './wgsl-binding-debug';
 
 const INJECT_SHADER_DECLARATIONS = `\n\n${DECLARATION_INJECT_MARKER}\n`;
+const MODULE_WGSL_BINDING_DECLARATION_REGEXES = [
+  /@binding\(\s*(auto|\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g,
+  /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(auto|\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g
+] as const;
+const WGSL_BINDING_DECLARATION_REGEXES = [
+  /@binding\(\s*(\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g,
+  /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g
+] as const;
+const RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT = 100;
 
 /**
  * Precision prologue to inject before functions are injected in shader
@@ -78,6 +89,8 @@ type AssembleStageOptions = {
   prologue?: boolean;
   /** logger object */
   log?: any;
+  /** @internal Stable per-assembler WGSL binding assignments. */
+  _bindingRegistry?: Map<string, number>;
 };
 
 export type HookFunction = {hook: string; header: string; footer: string; signature?: string};
@@ -94,21 +107,28 @@ export function assembleWGSLShader(
   options: AssembleShaderOptions & {
     /** Single WGSL shader */
     source: string;
+    /** @internal Stable per-assembler WGSL binding assignments. */
+    _bindingRegistry?: Map<string, number>;
   }
 ): {
   source: string;
   getUniforms: GetUniformsFunc;
+  bindingAssignments: {moduleName: string; name: string; group: number; location: number}[];
+  bindingTable: ShaderBindingDebugRow[];
 } {
   const modules = getShaderModuleDependencies(options.modules || []);
+  const {source, bindingAssignments} = assembleShaderWGSL(options.platformInfo, {
+    ...options,
+    source: options.source,
+    stage: 'vertex',
+    modules
+  });
 
   return {
-    source: assembleShaderWGSL(options.platformInfo, {
-      ...options,
-      source: options.source,
-      stage: 'vertex',
-      modules
-    }),
-    getUniforms: assembleGetUniforms(modules)
+    source,
+    getUniforms: assembleGetUniforms(modules),
+    bindingAssignments,
+    bindingTable: getShaderBindingDebugRowsFromWGSL(source, bindingAssignments)
   };
 }
 
@@ -155,7 +175,10 @@ export function assembleGLSLShaderPair(
  * @param options
  * @returns
  */
-export function assembleShaderWGSL(platformInfo: PlatformInfo, options: AssembleStageOptions) {
+export function assembleShaderWGSL(
+  platformInfo: PlatformInfo,
+  options: AssembleStageOptions
+): {source: string; bindingAssignments: WGSLBindingAssignment[]} {
   const {
     // id,
     source,
@@ -226,12 +249,29 @@ export function assembleShaderWGSL(platformInfo: PlatformInfo, options: Assemble
 
   // TODO - hack until shadertool modules support WebGPU
   const modulesToInject = modules;
+  const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(coreSource);
+  const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(
+    modulesToInject,
+    options._bindingRegistry,
+    usedBindingsByGroup
+  );
+  const bindingAssignments: WGSLBindingAssignment[] = [];
 
   for (const module of modulesToInject) {
     if (log) {
       checkShaderModuleDeprecations(module, coreSource, log);
     }
-    const moduleSource = getShaderModuleSource(module, 'wgsl');
+    const relocation = relocateWGSLModuleBindings(
+      getShaderModuleSource(module, 'wgsl', log),
+      module,
+      {
+        usedBindingsByGroup,
+        bindingRegistry: options._bindingRegistry,
+        reservedBindingKeysByGroup
+      }
+    );
+    bindingAssignments.push(...relocation.bindingAssignments);
+    const moduleSource = relocation.source;
     // Add the module source, and a #define that declares it presence
     assembledSource += moduleSource;
 
@@ -256,6 +296,7 @@ export function assembleShaderWGSL(platformInfo: PlatformInfo, options: Assemble
   assembledSource = injectShader(assembledSource, stage, declInjections);
 
   assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
+  assembledSource += formatWGSLBindingAssignmentComments(bindingAssignments);
 
   // Add the version directive and actual source of this shader
   assembledSource += coreSource;
@@ -263,7 +304,9 @@ export function assembleShaderWGSL(platformInfo: PlatformInfo, options: Assemble
   // Apply any requested shader injections
   assembledSource = injectShader(assembledSource, stage, mainInjections);
 
-  return assembledSource;
+  assertNoUnresolvedAutoBindings(assembledSource);
+
+  return {source: assembledSource, bindingAssignments};
 }
 
 /**
@@ -379,7 +422,7 @@ ${getApplicationDefines(allDefines)}
     if (log) {
       checkShaderModuleDeprecations(module, coreSource, log);
     }
-    const moduleSource = getShaderModuleSource(module, stage);
+    const moduleSource = getShaderModuleSource(module, stage, log);
     // Add the module source, and a #define that declares it presence
     assembledSource += moduleSource;
 
@@ -476,7 +519,8 @@ function getApplicationDefines(defines: Record<string, boolean> = {}): string {
 /** Extracts the source code chunk for the specified shader type from the named shader module */
 export function getShaderModuleSource(
   module: ShaderModule,
-  stage: 'vertex' | 'fragment' | 'wgsl'
+  stage: 'vertex' | 'fragment' | 'wgsl',
+  log?: any
 ): string {
   let moduleSource;
   switch (stage) {
@@ -496,6 +540,9 @@ export function getShaderModuleSource(
   if (!module.name) {
     throw new Error('Shader module must have a name');
   }
+
+  validateShaderModuleUniformLayout(module, stage, {log});
+
   const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, '_');
   let source = `\
 // ----- MODULE ${module.name} ---------------
@@ -508,6 +555,324 @@ export function getShaderModuleSource(
   return source;
 }
 
+type BindingRelocationContext = {
+  usedBindingsByGroup: Map<number, Set<number>>;
+  bindingRegistry?: Map<string, number>;
+  reservedBindingKeysByGroup: Map<number, Map<number, string>>;
+};
+
+type WGSLBindingAssignment = {
+  moduleName: string;
+  name: string;
+  group: number;
+  location: number;
+};
+
+type WGSLRelocationState = {
+  sawSupportedBindingDeclaration: boolean;
+  nextHintedBindingLocation: number | null;
+};
+
+type WGSLRelocationParams = {
+  isBindingFirst: boolean;
+  module: ShaderModule;
+  context: BindingRelocationContext;
+  bindingAssignments: WGSLBindingAssignment[];
+  relocationState: WGSLRelocationState;
+};
+
+function getUsedBindingsByGroupFromApplicationWGSL(source: string): Map<number, Set<number>> {
+  const usedBindingsByGroup = new Map<number, Set<number>>();
+
+  for (const regex of WGSL_BINDING_DECLARATION_REGEXES) {
+    regex.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(source))) {
+      const isBindingFirst = regex === WGSL_BINDING_DECLARATION_REGEXES[0];
+      const location = Number(match[isBindingFirst ? 1 : 2]);
+      const group = Number(match[isBindingFirst ? 2 : 1]);
+      const name = match[4];
+
+      validateApplicationWGSLBinding(group, location, name);
+      registerUsedBindingLocation(
+        usedBindingsByGroup,
+        group,
+        location,
+        `application binding "${name}"`
+      );
+    }
+  }
+
+  return usedBindingsByGroup;
+}
+
+function relocateWGSLModuleBindings(
+  moduleSource: string,
+  module: ShaderModule,
+  context: BindingRelocationContext
+): {source: string; bindingAssignments: WGSLBindingAssignment[]} {
+  const bindingAssignments: WGSLBindingAssignment[] = [];
+  const relocationState: WGSLRelocationState = {
+    sawSupportedBindingDeclaration: false,
+    nextHintedBindingLocation:
+      typeof module.firstBindingSlot === 'number' ? module.firstBindingSlot : null
+  };
+
+  let relocatedSource = relocateWGSLModuleBindingsWithRegex(
+    moduleSource,
+    MODULE_WGSL_BINDING_DECLARATION_REGEXES[0],
+    {isBindingFirst: true, module, context, bindingAssignments, relocationState}
+  );
+  relocatedSource = relocateWGSLModuleBindingsWithRegex(
+    relocatedSource,
+    MODULE_WGSL_BINDING_DECLARATION_REGEXES[1],
+    {isBindingFirst: false, module, context, bindingAssignments, relocationState}
+  );
+
+  if (moduleSource.includes('@binding(auto)') && !relocationState.sawSupportedBindingDeclaration) {
+    throw new Error(
+      `Unsupported @binding(auto) declaration form in module "${module.name}". ` +
+        'Use "@group(N) @binding(auto) var ..." or "@binding(auto) @group(N) var ..." on a single line.'
+    );
+  }
+
+  return {source: relocatedSource, bindingAssignments};
+}
+
+function relocateWGSLModuleBindingsWithRegex(
+  source: string,
+  regex: RegExp,
+  params: WGSLRelocationParams
+): string {
+  return source.replace(regex, (...replaceArguments) =>
+    relocateWGSLModuleBindingMatch(replaceArguments, params)
+  );
+}
+
+function relocateWGSLModuleBindingMatch(
+  replaceArguments: unknown[],
+  params: WGSLRelocationParams
+): string {
+  const {isBindingFirst, module, context, bindingAssignments, relocationState} = params;
+  relocationState.sawSupportedBindingDeclaration = true;
+
+  const match = replaceArguments[0] as string;
+  const bindingToken = replaceArguments[isBindingFirst ? 1 : 2] as string;
+  const groupToken = replaceArguments[isBindingFirst ? 2 : 1] as string;
+  const name = replaceArguments[4] as string;
+  const group = Number(groupToken);
+
+  if (bindingToken === 'auto') {
+    const registryKey = getBindingRegistryKey(group, module.name, name);
+    const registryLocation = context.bindingRegistry?.get(registryKey);
+    const location =
+      registryLocation !== undefined
+        ? registryLocation
+        : relocationState.nextHintedBindingLocation === null
+          ? allocateAutoBindingLocation(group, context.usedBindingsByGroup)
+          : allocateAutoBindingLocation(
+              group,
+              context.usedBindingsByGroup,
+              relocationState.nextHintedBindingLocation
+            );
+    validateModuleWGSLBinding(module.name, group, location, name);
+    if (
+      registryLocation !== undefined &&
+      claimReservedBindingLocation(context.reservedBindingKeysByGroup, group, location, registryKey)
+    ) {
+      bindingAssignments.push({moduleName: module.name, name, group, location});
+      return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location})`);
+    }
+    registerUsedBindingLocation(
+      context.usedBindingsByGroup,
+      group,
+      location,
+      `module "${module.name}" binding "${name}"`
+    );
+    context.bindingRegistry?.set(registryKey, location);
+    bindingAssignments.push({moduleName: module.name, name, group, location});
+    if (relocationState.nextHintedBindingLocation !== null && registryLocation === undefined) {
+      relocationState.nextHintedBindingLocation = location + 1;
+    }
+    return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location})`);
+  }
+
+  const location = Number(bindingToken);
+  validateModuleWGSLBinding(module.name, group, location, name);
+  registerUsedBindingLocation(
+    context.usedBindingsByGroup,
+    group,
+    location,
+    `module "${module.name}" binding "${name}"`
+  );
+  bindingAssignments.push({moduleName: module.name, name, group, location});
+  return match;
+}
+
+function reserveRegisteredModuleBindings(
+  modules: ShaderModule[],
+  bindingRegistry: Map<string, number> | undefined,
+  usedBindingsByGroup: Map<number, Set<number>>
+): Map<number, Map<number, string>> {
+  const reservedBindingKeysByGroup = new Map<number, Map<number, string>>();
+  if (!bindingRegistry) {
+    return reservedBindingKeysByGroup;
+  }
+
+  for (const module of modules) {
+    for (const binding of getModuleWGSLBindingDeclarations(module)) {
+      const registryKey = getBindingRegistryKey(binding.group, module.name, binding.name);
+      const location = bindingRegistry.get(registryKey);
+      if (location !== undefined) {
+        const reservedBindingKeys =
+          reservedBindingKeysByGroup.get(binding.group) || new Map<number, string>();
+        const existingReservation = reservedBindingKeys.get(location);
+        if (existingReservation && existingReservation !== registryKey) {
+          throw new Error(
+            `Duplicate WGSL binding reservation for modules "${existingReservation}" and "${registryKey}": group ${binding.group}, binding ${location}.`
+          );
+        }
+
+        registerUsedBindingLocation(
+          usedBindingsByGroup,
+          binding.group,
+          location,
+          `registered module binding "${registryKey}"`
+        );
+        reservedBindingKeys.set(location, registryKey);
+        reservedBindingKeysByGroup.set(binding.group, reservedBindingKeys);
+      }
+    }
+  }
+
+  return reservedBindingKeysByGroup;
+}
+
+function claimReservedBindingLocation(
+  reservedBindingKeysByGroup: Map<number, Map<number, string>>,
+  group: number,
+  location: number,
+  registryKey: string
+): boolean {
+  const reservedBindingKeys = reservedBindingKeysByGroup.get(group);
+  if (!reservedBindingKeys) {
+    return false;
+  }
+
+  const reservedKey = reservedBindingKeys.get(location);
+  if (!reservedKey) {
+    return false;
+  }
+  if (reservedKey !== registryKey) {
+    throw new Error(
+      `Registered module binding "${registryKey}" collided with "${reservedKey}": group ${group}, binding ${location}.`
+    );
+  }
+  return true;
+}
+
+function getModuleWGSLBindingDeclarations(module: ShaderModule): {name: string; group: number}[] {
+  const declarations: {name: string; group: number}[] = [];
+  const moduleSource = module.source || '';
+
+  for (const regex of MODULE_WGSL_BINDING_DECLARATION_REGEXES) {
+    regex.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(moduleSource))) {
+      const isBindingFirst = regex === MODULE_WGSL_BINDING_DECLARATION_REGEXES[0];
+      declarations.push({
+        name: match[4],
+        group: Number(match[isBindingFirst ? 2 : 1])
+      });
+    }
+  }
+
+  return declarations;
+}
+
+function validateApplicationWGSLBinding(group: number, location: number, name: string): void {
+  if (group === 0 && location >= RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT) {
+    throw new Error(
+      `Application binding "${name}" in group 0 uses reserved binding ${location}. ` +
+        `Application-owned explicit group-0 bindings must stay below ${RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT}.`
+    );
+  }
+}
+
+function validateModuleWGSLBinding(
+  moduleName: string,
+  group: number,
+  location: number,
+  name: string
+): void {
+  if (group === 0 && location < RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT) {
+    throw new Error(
+      `Module "${moduleName}" binding "${name}" in group 0 uses reserved application binding ${location}. ` +
+        `Module-owned explicit group-0 bindings must be ${RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT} or higher.`
+    );
+  }
+}
+
+function registerUsedBindingLocation(
+  usedBindingsByGroup: Map<number, Set<number>>,
+  group: number,
+  location: number,
+  label: string
+): void {
+  const usedBindings = usedBindingsByGroup.get(group) || new Set<number>();
+  if (usedBindings.has(location)) {
+    throw new Error(
+      `Duplicate WGSL binding assignment for ${label}: group ${group}, binding ${location}.`
+    );
+  }
+  usedBindings.add(location);
+  usedBindingsByGroup.set(group, usedBindings);
+}
+
+function allocateAutoBindingLocation(
+  group: number,
+  usedBindingsByGroup: Map<number, Set<number>>,
+  preferredBindingLocation?: number
+): number {
+  const usedBindings = usedBindingsByGroup.get(group) || new Set<number>();
+  let nextBinding =
+    preferredBindingLocation ??
+    (group === 0
+      ? RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT
+      : usedBindings.size > 0
+        ? Math.max(...usedBindings) + 1
+        : 0);
+
+  while (usedBindings.has(nextBinding)) {
+    nextBinding++;
+  }
+
+  return nextBinding;
+}
+
+function assertNoUnresolvedAutoBindings(source: string): void {
+  if (/@binding\(\s*auto\s*\)/.test(source)) {
+    throw new Error('Unresolved @binding(auto) remained in assembled WGSL source.');
+  }
+}
+
+function formatWGSLBindingAssignmentComments(bindingAssignments: WGSLBindingAssignment[]): string {
+  if (bindingAssignments.length === 0) {
+    return '';
+  }
+
+  let source = '// ----- MODULE WGSL BINDING ASSIGNMENTS ---------------\n';
+  for (const bindingAssignment of bindingAssignments) {
+    source += `// ${bindingAssignment.moduleName}.${bindingAssignment.name} -> @group(${bindingAssignment.group}) @binding(${bindingAssignment.location})\n`;
+  }
+  source += '\n';
+  return source;
+}
+
+function getBindingRegistryKey(group: number, moduleName: string, bindingName: string): string {
+  return `${group}:${moduleName}:${bindingName}`;
+}
+
 /*
 function getHookFunctions(
   hookFunctions: Record<string, HookFunction>,

package/src/lib/shader-assembly/wgsl-binding-debug.ts

@@ -0,0 +1,216 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+type ShaderBindingAssignment = {
+  moduleName: string;
+  name: string;
+  group: number;
+  location: number;
+};
+
+const WGSL_BINDING_DEBUG_REGEXES = [
+  /@binding\(\s*(\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*var(?:<([^>]+)>)?\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^;]+);/g,
+  /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(\d+)\s*\)\s*var(?:<([^>]+)>)?\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^;]+);/g
+] as const;
+
+/** One debug row describing a WGSL binding in the assembled shader source. */
+export type ShaderBindingDebugRow = {
+  /** Binding name as declared in WGSL. */
+  name: string;
+  /** Bind-group index. */
+  group: number;
+  /** Binding slot within the bind group. */
+  binding: number;
+  /** Resource kind inferred from the WGSL declaration. */
+  kind:
+    | 'uniform'
+    | 'storage'
+    | 'read-only-storage'
+    | 'texture'
+    | 'sampler'
+    | 'storage-texture'
+    | 'unknown';
+  /** Whether the binding came from application WGSL or a shader module. */
+  owner: 'application' | 'module';
+  /** Shader module name when the binding was contributed by a module. */
+  moduleName?: string;
+  /** Full WGSL resource type text from the declaration. */
+  resourceType?: string;
+  /** WGSL access mode when cheaply available. */
+  access?: string;
+  /** Texture view dimension when cheaply available. */
+  viewDimension?: string;
+  /** Texture sample type when cheaply available. */
+  sampleType?: string;
+  /** Sampler kind when cheaply available. */
+  samplerKind?: string;
+  /** Whether the texture is multisampled when cheaply available. */
+  multisampled?: boolean;
+};
+
+/** Builds a stable, table-friendly binding summary from assembled WGSL source. */
+export function getShaderBindingDebugRowsFromWGSL(
+  source: string,
+  bindingAssignments: ShaderBindingAssignment[] = []
+): ShaderBindingDebugRow[] {
+  const assignmentMap = new Map<string, string>();
+  for (const bindingAssignment of bindingAssignments) {
+    assignmentMap.set(
+      getBindingAssignmentKey(
+        bindingAssignment.name,
+        bindingAssignment.group,
+        bindingAssignment.location
+      ),
+      bindingAssignment.moduleName
+    );
+  }
+
+  const rows: ShaderBindingDebugRow[] = [];
+  for (const regex of WGSL_BINDING_DEBUG_REGEXES) {
+    regex.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(source))) {
+      const isBindingFirst = regex === WGSL_BINDING_DEBUG_REGEXES[0];
+      const binding = Number(match[isBindingFirst ? 1 : 2]);
+      const group = Number(match[isBindingFirst ? 2 : 1]);
+      const accessDeclaration = match[3]?.trim();
+      const name = match[4];
+      const resourceType = match[5].trim();
+      const moduleName = assignmentMap.get(getBindingAssignmentKey(name, group, binding));
+
+      rows.push(
+        normalizeShaderBindingDebugRow({
+          name,
+          group,
+          binding,
+          owner: moduleName ? 'module' : 'application',
+          moduleName,
+          accessDeclaration,
+          resourceType
+        })
+      );
+    }
+  }
+
+  return rows.sort((left, right) => {
+    if (left.group !== right.group) {
+      return left.group - right.group;
+    }
+    if (left.binding !== right.binding) {
+      return left.binding - right.binding;
+    }
+    return left.name.localeCompare(right.name);
+  });
+}
+
+function normalizeShaderBindingDebugRow(row: {
+  name: string;
+  group: number;
+  binding: number;
+  owner: 'application' | 'module';
+  moduleName?: string;
+  accessDeclaration?: string;
+  resourceType: string;
+}): ShaderBindingDebugRow {
+  const baseRow: ShaderBindingDebugRow = {
+    name: row.name,
+    group: row.group,
+    binding: row.binding,
+    owner: row.owner,
+    kind: 'unknown',
+    moduleName: row.moduleName,
+    resourceType: row.resourceType
+  };
+
+  if (row.accessDeclaration) {
+    const access = row.accessDeclaration.split(',').map(value => value.trim());
+    if (access[0] === 'uniform') {
+      return {...baseRow, kind: 'uniform', access: 'uniform'};
+    }
+    if (access[0] === 'storage') {
+      const storageAccess = access[1] || 'read_write';
+      return {
+        ...baseRow,
+        kind: storageAccess === 'read' ? 'read-only-storage' : 'storage',
+        access: storageAccess
+      };
+    }
+  }
+
+  if (row.resourceType === 'sampler' || row.resourceType === 'sampler_comparison') {
+    return {
+      ...baseRow,
+      kind: 'sampler',
+      samplerKind: row.resourceType === 'sampler_comparison' ? 'comparison' : 'filtering'
+    };
+  }
+
+  if (row.resourceType.startsWith('texture_storage_')) {
+    return {
+      ...baseRow,
+      kind: 'storage-texture',
+      access: getStorageTextureAccess(row.resourceType),
+      viewDimension: getTextureViewDimension(row.resourceType)
+    };
+  }
+
+  if (row.resourceType.startsWith('texture_')) {
+    return {
+      ...baseRow,
+      kind: 'texture',
+      viewDimension: getTextureViewDimension(row.resourceType),
+      sampleType: getTextureSampleType(row.resourceType),
+      multisampled: row.resourceType.startsWith('texture_multisampled_')
+    };
+  }
+
+  return baseRow;
+}
+
+function getBindingAssignmentKey(name: string, group: number, binding: number): string {
+  return `${group}:${binding}:${name}`;
+}
+
+function getTextureViewDimension(resourceType: string): string | undefined {
+  if (resourceType.includes('cube_array')) {
+    return 'cube-array';
+  }
+  if (resourceType.includes('2d_array')) {
+    return '2d-array';
+  }
+  if (resourceType.includes('cube')) {
+    return 'cube';
+  }
+  if (resourceType.includes('3d')) {
+    return '3d';
+  }
+  if (resourceType.includes('2d')) {
+    return '2d';
+  }
+  if (resourceType.includes('1d')) {
+    return '1d';
+  }
+  return undefined;
+}
+
+function getTextureSampleType(resourceType: string): string | undefined {
+  if (resourceType.startsWith('texture_depth_')) {
+    return 'depth';
+  }
+  if (resourceType.includes('<i32>')) {
+    return 'sint';
+  }
+  if (resourceType.includes('<u32>')) {
+    return 'uint';
+  }
+  if (resourceType.includes('<f32>')) {
+    return 'float';
+  }
+  return undefined;
+}
+
+function getStorageTextureAccess(resourceType: string): string | undefined {
+  const match = /,\s*([A-Za-z_][A-Za-z0-9_]*)\s*>$/.exec(resourceType);
+  return match?.[1];
+}