@luma.gl/shadertools 9.3.0-alpha.10 → 9.3.0-alpha.11

package/dist/dist.dev.js

@@ -561,11 +561,42 @@ ${inject[key]}` : inject[key];
     return true;
   }
   function formatShaderModuleUniformLayoutError(validationResult) {
-    return `${validationResult.moduleName}: ${validationResult.stage} shader uniform block ${validationResult.uniformBlockName} does not match module.uniformTypes.
-Expected: ${validationResult.expectedUniformNames.join(
-      ", "
-    )}
-Actual: ${validationResult.actualUniformNames.join(", ")}`;
+    const { expectedUniformNames, actualUniformNames } = validationResult;
+    const missingUniformNames = expectedUniformNames.filter(
+      (uniformName) => !actualUniformNames.includes(uniformName)
+    );
+    const unexpectedUniformNames = actualUniformNames.filter(
+      (uniformName) => !expectedUniformNames.includes(uniformName)
+    );
+    const mismatchDetails = [
+      `Expected ${expectedUniformNames.length} fields, found ${actualUniformNames.length}.`
+    ];
+    const firstMismatchDescription = getFirstUniformMismatchDescription(
+      expectedUniformNames,
+      actualUniformNames
+    );
+    if (firstMismatchDescription) {
+      mismatchDetails.push(firstMismatchDescription);
+    }
+    if (missingUniformNames.length) {
+      mismatchDetails.push(
+        `Missing from shader block (${missingUniformNames.length}): ${formatUniformNameList(
+          missingUniformNames
+        )}.`
+      );
+    }
+    if (unexpectedUniformNames.length) {
+      mismatchDetails.push(
+        `Unexpected in shader block (${unexpectedUniformNames.length}): ${formatUniformNameList(
+          unexpectedUniformNames
+        )}.`
+      );
+    }
+    if (expectedUniformNames.length <= 12 && actualUniformNames.length <= 12 && (missingUniformNames.length || unexpectedUniformNames.length)) {
+      mismatchDetails.push(`Expected: ${expectedUniformNames.join(", ")}.`);
+      mismatchDetails.push(`Actual: ${actualUniformNames.join(", ")}.`);
+    }
+    return `${validationResult.moduleName}: ${validationResult.stage} shader uniform block ${validationResult.uniformBlockName} does not match module.uniformTypes. ${mismatchDetails.join(" ")}`;
   }
   function stripShaderComments(shaderSource) {
     return shaderSource.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
@@ -573,6 +604,28 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
   function normalizeWhitespace(value) {
     return value.replace(/\s+/g, " ").trim();
   }
+  function getFirstUniformMismatchDescription(expectedUniformNames, actualUniformNames) {
+    const minimumLength = Math.min(expectedUniformNames.length, actualUniformNames.length);
+    for (let index = 0; index < minimumLength; index++) {
+      if (expectedUniformNames[index] !== actualUniformNames[index]) {
+        return `First mismatch at field ${index + 1}: expected ${expectedUniformNames[index]}, found ${actualUniformNames[index]}.`;
+      }
+    }
+    if (expectedUniformNames.length > actualUniformNames.length) {
+      return `Shader block ends after field ${actualUniformNames.length}; expected next field ${expectedUniformNames[actualUniformNames.length]}.`;
+    }
+    if (actualUniformNames.length > expectedUniformNames.length) {
+      return `Shader block has extra field ${actualUniformNames.length}: ${actualUniformNames[expectedUniformNames.length]}.`;
+    }
+    return null;
+  }
+  function formatUniformNameList(uniformNames, maxNames = 8) {
+    if (uniformNames.length <= maxNames) {
+      return uniformNames.join(", ");
+    }
+    const remainingCount = uniformNames.length - maxNames;
+    return `${uniformNames.slice(0, maxNames).join(", ")}, ... (${remainingCount} more)`;
+  }
 
   // src/lib/shader-assembly/platform-defines.ts
   function getPlatformShaderDefines(platformInfo) {
@@ -758,12 +811,194 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
     return version;
   }
 
+  // src/lib/shader-assembly/wgsl-binding-scan.ts
+  var WGSL_BINDABLE_VARIABLE_PATTERN = "(?:var<\\s*(uniform|storage(?:\\s*,\\s*[A-Za-z_][A-Za-z0-9_]*)?)\\s*>|var)\\s+([A-Za-z_][A-Za-z0-9_]*)";
+  var WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN = "\\s*";
+  var MODULE_WGSL_BINDING_DECLARATION_REGEXES = [
+    new RegExp(
+      `@binding\\(\\s*(auto|\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    ),
+    new RegExp(
+      `@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@binding\\(\\s*(auto|\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    )
+  ];
+  var WGSL_BINDING_DECLARATION_REGEXES = [
+    new RegExp(
+      `@binding\\(\\s*(auto|\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    ),
+    new RegExp(
+      `@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@binding\\(\\s*(auto|\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    )
+  ];
+  var WGSL_EXPLICIT_BINDING_DECLARATION_REGEXES = [
+    new RegExp(
+      `@binding\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    ),
+    new RegExp(
+      `@group\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}@binding\\(\\s*(\\d+)\\s*\\)${WGSL_BINDING_DECLARATION_SEPARATOR_PATTERN}${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    )
+  ];
+  var WGSL_AUTO_BINDING_DECLARATION_REGEXES = [
+    new RegExp(
+      `@binding\\(\\s*(auto)\\s*\\)\\s*@group\\(\\s*(\\d+)\\s*\\)\\s*${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    ),
+    new RegExp(
+      `@group\\(\\s*(\\d+)\\s*\\)\\s*@binding\\(\\s*(auto)\\s*\\)\\s*${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    ),
+    new RegExp(
+      `@binding\\(\\s*(auto)\\s*\\)\\s*@group\\(\\s*(\\d+)\\s*\\)(?:[\\s\\n\\r]*@[A-Za-z_][^\\n\\r]*)*[\\s\\n\\r]*${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    ),
+    new RegExp(
+      `@group\\(\\s*(\\d+)\\s*\\)\\s*@binding\\(\\s*(auto)\\s*\\)(?:[\\s\\n\\r]*@[A-Za-z_][^\\n\\r]*)*[\\s\\n\\r]*${WGSL_BINDABLE_VARIABLE_PATTERN}`,
+      "g"
+    )
+  ];
+  function maskWGSLComments(source4) {
+    const maskedCharacters = source4.split("");
+    let index = 0;
+    let blockCommentDepth = 0;
+    let inLineComment = false;
+    let inString = false;
+    let isEscaped = false;
+    while (index < source4.length) {
+      const character = source4[index];
+      const nextCharacter = source4[index + 1];
+      if (inString) {
+        if (isEscaped) {
+          isEscaped = false;
+        } else if (character === "\\") {
+          isEscaped = true;
+        } else if (character === '"') {
+          inString = false;
+        }
+        index++;
+        continue;
+      }
+      if (inLineComment) {
+        if (character === "\n" || character === "\r") {
+          inLineComment = false;
+        } else {
+          maskedCharacters[index] = " ";
+        }
+        index++;
+        continue;
+      }
+      if (blockCommentDepth > 0) {
+        if (character === "/" && nextCharacter === "*") {
+          maskedCharacters[index] = " ";
+          maskedCharacters[index + 1] = " ";
+          blockCommentDepth++;
+          index += 2;
+          continue;
+        }
+        if (character === "*" && nextCharacter === "/") {
+          maskedCharacters[index] = " ";
+          maskedCharacters[index + 1] = " ";
+          blockCommentDepth--;
+          index += 2;
+          continue;
+        }
+        if (character !== "\n" && character !== "\r") {
+          maskedCharacters[index] = " ";
+        }
+        index++;
+        continue;
+      }
+      if (character === '"') {
+        inString = true;
+        index++;
+        continue;
+      }
+      if (character === "/" && nextCharacter === "/") {
+        maskedCharacters[index] = " ";
+        maskedCharacters[index + 1] = " ";
+        inLineComment = true;
+        index += 2;
+        continue;
+      }
+      if (character === "/" && nextCharacter === "*") {
+        maskedCharacters[index] = " ";
+        maskedCharacters[index + 1] = " ";
+        blockCommentDepth = 1;
+        index += 2;
+        continue;
+      }
+      index++;
+    }
+    return maskedCharacters.join("");
+  }
+  function getWGSLBindingDeclarationMatches(source4, regexes) {
+    const maskedSource = maskWGSLComments(source4);
+    const matches = [];
+    for (const regex of regexes) {
+      regex.lastIndex = 0;
+      let match;
+      match = regex.exec(maskedSource);
+      while (match) {
+        const isBindingFirst = regex === regexes[0];
+        const index = match.index;
+        const length = match[0].length;
+        matches.push({
+          match: source4.slice(index, index + length),
+          index,
+          length,
+          bindingToken: match[isBindingFirst ? 1 : 2],
+          groupToken: match[isBindingFirst ? 2 : 1],
+          accessDeclaration: match[3]?.trim(),
+          name: match[4]
+        });
+        match = regex.exec(maskedSource);
+      }
+    }
+    return matches.sort((left, right) => left.index - right.index);
+  }
+  function replaceWGSLBindingDeclarationMatches(source4, regexes, replacer) {
+    const matches = getWGSLBindingDeclarationMatches(source4, regexes);
+    if (!matches.length) {
+      return source4;
+    }
+    let relocatedSource = "";
+    let lastIndex = 0;
+    for (const match of matches) {
+      relocatedSource += source4.slice(lastIndex, match.index);
+      relocatedSource += replacer(match);
+      lastIndex = match.index + match.length;
+    }
+    relocatedSource += source4.slice(lastIndex);
+    return relocatedSource;
+  }
+  function hasWGSLAutoBinding(source4) {
+    return /@binding\(\s*auto\s*\)/.test(maskWGSLComments(source4));
+  }
+  function getFirstWGSLAutoBindingDeclarationMatch(source4, regexes) {
+    const autoBindingRegexes = regexes === MODULE_WGSL_BINDING_DECLARATION_REGEXES || regexes === WGSL_BINDING_DECLARATION_REGEXES ? WGSL_AUTO_BINDING_DECLARATION_REGEXES : regexes;
+    return getWGSLBindingDeclarationMatches(source4, autoBindingRegexes).find(
+      (declarationMatch) => declarationMatch.bindingToken === "auto"
+    );
+  }
+
   // src/lib/shader-assembly/wgsl-binding-debug.ts
   var 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
+    new RegExp(
+      `@binding\\(\\s*(\\d+)\\s*\\)\\s*@group\\(\\s*(\\d+)\\s*\\)\\s*${WGSL_BINDABLE_VARIABLE_PATTERN}\\s*:\\s*([^;]+);`,
+      "g"
+    ),
+    new RegExp(
+      `@group\\(\\s*(\\d+)\\s*\\)\\s*@binding\\(\\s*(\\d+)\\s*\\)\\s*${WGSL_BINDABLE_VARIABLE_PATTERN}\\s*:\\s*([^;]+);`,
+      "g"
+    )
   ];
   function getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments = []) {
+    const maskedSource = maskWGSLComments(source4);
     const assignmentMap = /* @__PURE__ */ new Map();
     for (const bindingAssignment of bindingAssignments) {
       assignmentMap.set(
@@ -779,7 +1014,8 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
     for (const regex of WGSL_BINDING_DEBUG_REGEXES) {
       regex.lastIndex = 0;
       let match;
-      while (match = regex.exec(source4)) {
+      match = regex.exec(maskedSource);
+      while (match) {
         const isBindingFirst = regex === WGSL_BINDING_DEBUG_REGEXES[0];
         const binding = Number(match[isBindingFirst ? 1 : 2]);
         const group = Number(match[isBindingFirst ? 2 : 1]);
@@ -798,6 +1034,7 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
             resourceType
           })
         );
+        match = regex.exec(maskedSource);
       }
     }
     return rows.sort((left, right) => {
@@ -909,14 +1146,6 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
 
 ${DECLARATION_INJECT_MARKER}
 `;
-  var 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
-  ];
-  var 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
-  ];
   var RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT = 100;
   var FRAGMENT_SHADER_PROLOGUE = (
     /* glsl */
@@ -996,7 +1225,10 @@ ${DECLARATION_INJECT_MARKER}
       }
     }
     const modulesToInject = modules;
-    const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(coreSource);
+    const applicationRelocation = relocateWGSLApplicationBindings(coreSource);
+    const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(
+      applicationRelocation.source
+    );
     const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(
       modulesToInject,
       options._bindingRegistry,
@@ -1037,7 +1269,7 @@ ${DECLARATION_INJECT_MARKER}
     assembledSource = injectShader(assembledSource, stage, declInjections);
     assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
     assembledSource += formatWGSLBindingAssignmentComments(bindingAssignments);
-    assembledSource += coreSource;
+    assembledSource += applicationRelocation.source;
     assembledSource = injectShader(assembledSource, stage, mainInjections);
     assertNoUnresolvedAutoBindings(assembledSource);
     return { source: assembledSource, bindingAssignments };
@@ -1197,61 +1429,87 @@ ${getApplicationDefines(allDefines)}
   }
   function getUsedBindingsByGroupFromApplicationWGSL(source4) {
     const usedBindingsByGroup = /* @__PURE__ */ new Map();
-    for (const regex of WGSL_BINDING_DECLARATION_REGEXES) {
-      regex.lastIndex = 0;
-      let match;
-      while (match = regex.exec(source4)) {
-        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}"`
-        );
-      }
+    for (const match of getWGSLBindingDeclarationMatches(
+      source4,
+      WGSL_EXPLICIT_BINDING_DECLARATION_REGEXES
+    )) {
+      const location = Number(match.bindingToken);
+      const group = Number(match.groupToken);
+      validateApplicationWGSLBinding(group, location, match.name);
+      registerUsedBindingLocation(
+        usedBindingsByGroup,
+        group,
+        location,
+        `application binding "${match.name}"`
+      );
     }
     return usedBindingsByGroup;
   }
+  function relocateWGSLApplicationBindings(source4) {
+    const declarationMatches = getWGSLBindingDeclarationMatches(
+      source4,
+      WGSL_BINDING_DECLARATION_REGEXES
+    );
+    const usedBindingsByGroup = /* @__PURE__ */ new Map();
+    for (const declarationMatch of declarationMatches) {
+      if (declarationMatch.bindingToken === "auto") {
+        continue;
+      }
+      const location = Number(declarationMatch.bindingToken);
+      const group = Number(declarationMatch.groupToken);
+      validateApplicationWGSLBinding(group, location, declarationMatch.name);
+      registerUsedBindingLocation(
+        usedBindingsByGroup,
+        group,
+        location,
+        `application binding "${declarationMatch.name}"`
+      );
+    }
+    const relocationState = {
+      sawSupportedBindingDeclaration: declarationMatches.length > 0
+    };
+    const relocatedSource = replaceWGSLBindingDeclarationMatches(
+      source4,
+      WGSL_BINDING_DECLARATION_REGEXES,
+      (declarationMatch) => relocateWGSLApplicationBindingMatch(declarationMatch, usedBindingsByGroup, relocationState)
+    );
+    if (hasWGSLAutoBinding(source4) && !relocationState.sawSupportedBindingDeclaration) {
+      throw new Error(
+        'Unsupported @binding(auto) declaration form in application WGSL. Use adjacent "@group(N)" and "@binding(auto)" decorators followed by a bindable "var" declaration.'
+      );
+    }
+    return { source: relocatedSource };
+  }
   function relocateWGSLModuleBindings(moduleSource, module, context) {
     const bindingAssignments = [];
+    const declarationMatches = getWGSLBindingDeclarationMatches(
+      moduleSource,
+      MODULE_WGSL_BINDING_DECLARATION_REGEXES
+    );
     const relocationState = {
-      sawSupportedBindingDeclaration: false,
+      sawSupportedBindingDeclaration: declarationMatches.length > 0,
       nextHintedBindingLocation: typeof module.firstBindingSlot === "number" ? module.firstBindingSlot : null
     };
-    let relocatedSource = relocateWGSLModuleBindingsWithRegex(
+    const relocatedSource = replaceWGSLBindingDeclarationMatches(
       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 }
+      MODULE_WGSL_BINDING_DECLARATION_REGEXES,
+      (declarationMatch) => relocateWGSLModuleBindingMatch(declarationMatch, {
+        module,
+        context,
+        bindingAssignments,
+        relocationState
+      })
     );
-    if (moduleSource.includes("@binding(auto)") && !relocationState.sawSupportedBindingDeclaration) {
+    if (hasWGSLAutoBinding(moduleSource) && !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.`
+        `Unsupported @binding(auto) declaration form in module "${module.name}". Use adjacent "@group(N)" and "@binding(auto)" decorators followed by a bindable "var" declaration.`
       );
     }
     return { source: relocatedSource, bindingAssignments };
   }
-  function relocateWGSLModuleBindingsWithRegex(source4, regex, params) {
-    return source4.replace(
-      regex,
-      (...replaceArguments) => relocateWGSLModuleBindingMatch(replaceArguments, params)
-    );
-  }
-  function relocateWGSLModuleBindingMatch(replaceArguments, params) {
-    const { isBindingFirst, module, context, bindingAssignments, relocationState } = params;
-    relocationState.sawSupportedBindingDeclaration = true;
-    const match = replaceArguments[0];
-    const bindingToken = replaceArguments[isBindingFirst ? 1 : 2];
-    const groupToken = replaceArguments[isBindingFirst ? 2 : 1];
-    const name = replaceArguments[4];
+  function relocateWGSLModuleBindingMatch(declarationMatch, params) {
+    const { module, context, bindingAssignments, relocationState } = params;
+    const { match, bindingToken, groupToken, name } = declarationMatch;
     const group = Number(groupToken);
     if (bindingToken === "auto") {
       const registryKey = getBindingRegistryKey(group, module.name, name);
@@ -1290,6 +1548,23 @@ ${getApplicationDefines(allDefines)}
     bindingAssignments.push({ moduleName: module.name, name, group, location });
     return match;
   }
+  function relocateWGSLApplicationBindingMatch(declarationMatch, usedBindingsByGroup, relocationState) {
+    const { match, bindingToken, groupToken, name } = declarationMatch;
+    const group = Number(groupToken);
+    if (bindingToken === "auto") {
+      const location = allocateApplicationAutoBindingLocation(group, usedBindingsByGroup);
+      validateApplicationWGSLBinding(group, location, name);
+      registerUsedBindingLocation(
+        usedBindingsByGroup,
+        group,
+        location,
+        `application binding "${name}"`
+      );
+      return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location})`);
+    }
+    relocationState.sawSupportedBindingDeclaration = true;
+    return match;
+  }
   function reserveRegisteredModuleBindings(modules, bindingRegistry, usedBindingsByGroup) {
     const reservedBindingKeysByGroup = /* @__PURE__ */ new Map();
     if (!bindingRegistry) {
@@ -1339,16 +1614,14 @@ ${getApplicationDefines(allDefines)}
   function getModuleWGSLBindingDeclarations(module) {
     const declarations = [];
     const moduleSource = module.source || "";
-    for (const regex of MODULE_WGSL_BINDING_DECLARATION_REGEXES) {
-      regex.lastIndex = 0;
-      let match;
-      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])
-        });
-      }
+    for (const match of getWGSLBindingDeclarationMatches(
+      moduleSource,
+      MODULE_WGSL_BINDING_DECLARATION_REGEXES
+    )) {
+      declarations.push({
+        name: match.name,
+        group: Number(match.groupToken)
+      });
     }
     return declarations;
   }
@@ -1384,10 +1657,36 @@ ${getApplicationDefines(allDefines)}
     }
     return nextBinding;
   }
+  function allocateApplicationAutoBindingLocation(group, usedBindingsByGroup) {
+    const usedBindings = usedBindingsByGroup.get(group) || /* @__PURE__ */ new Set();
+    let nextBinding = 0;
+    while (usedBindings.has(nextBinding)) {
+      nextBinding++;
+    }
+    return nextBinding;
+  }
   function assertNoUnresolvedAutoBindings(source4) {
-    if (/@binding\(\s*auto\s*\)/.test(source4)) {
-      throw new Error("Unresolved @binding(auto) remained in assembled WGSL source.");
+    const unresolvedBinding = getFirstWGSLAutoBindingDeclarationMatch(
+      source4,
+      MODULE_WGSL_BINDING_DECLARATION_REGEXES
+    );
+    if (!unresolvedBinding) {
+      return;
+    }
+    const moduleName = getWGSLModuleNameAtIndex(source4, unresolvedBinding.index);
+    if (moduleName) {
+      throw new Error(
+        `Unresolved @binding(auto) for module "${moduleName}" binding "${unresolvedBinding.name}" remained in assembled WGSL source.`
+      );
     }
+    if (isInApplicationWGSLSection(source4, unresolvedBinding.index)) {
+      throw new Error(
+        `Unresolved @binding(auto) for application binding "${unresolvedBinding.name}" remained in assembled WGSL source.`
+      );
+    }
+    throw new Error(
+      `Unresolved @binding(auto) remained in assembled WGSL source near "${formatWGSLSourceSnippet(unresolvedBinding.match)}".`
+    );
   }
   function formatWGSLBindingAssignmentComments(bindingAssignments) {
     if (bindingAssignments.length === 0) {
@@ -1404,6 +1703,24 @@ ${getApplicationDefines(allDefines)}
   function getBindingRegistryKey(group, moduleName, bindingName) {
     return `${group}:${moduleName}:${bindingName}`;
   }
+  function getWGSLModuleNameAtIndex(source4, index) {
+    const moduleHeaderRegex = /^\/\/ ----- MODULE ([^\n]+) ---------------$/gm;
+    let moduleName;
+    let match;
+    match = moduleHeaderRegex.exec(source4);
+    while (match && match.index <= index) {
+      moduleName = match[1];
+      match = moduleHeaderRegex.exec(source4);
+    }
+    return moduleName;
+  }
+  function isInApplicationWGSLSection(source4, index) {
+    const injectionMarkerIndex = source4.indexOf(INJECT_SHADER_DECLARATIONS);
+    return injectionMarkerIndex >= 0 ? index > injectionMarkerIndex : true;
+  }
+  function formatWGSLSourceSnippet(source4) {
+    return source4.replace(/\s+/g, " ").trim();
+  }
 
   // src/lib/preprocessor/preprocessor.ts
   var DEFINE_NAME_PATTERN = "([a-zA-Z_][a-zA-Z0-9_]*)";
@@ -5546,8 +5863,7 @@ uniform sampler2D pbr_brdfLUT;
   // src/modules/lighting/no-material/dirlight.ts
   var SOURCE_WGSL = (
     /* WGSL */
-    `  
-struct dirlightUniforms {
+    `struct dirlightUniforms {
   lightDirection: vec3<f32>,
 };
 
@@ -6068,7 +6384,8 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
   var vs3 = (
     /* glsl */
     `out vec3 pbr_vPosition;
-out vec2 pbr_vUV;
+out vec2 pbr_vUV0;
+out vec2 pbr_vUV1;
 
 #ifdef HAS_NORMALS
 # ifdef HAS_TANGENTS
@@ -6078,7 +6395,13 @@ out vec3 pbr_vNormal;
 # endif
 #endif
 
-void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
+void pbr_setPositionNormalTangentUV(
+  vec4 position,
+  vec4 normal,
+  vec4 tangent,
+  vec2 uv0,
+  vec2 uv1
+)
 {
   vec4 pos = pbrProjection.modelMatrix * position;
   pbr_vPosition = vec3(pos.xyz) / pos.w;
@@ -6095,10 +6418,12 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 #endif
 
 #ifdef HAS_UV
-  pbr_vUV = uv;
+  pbr_vUV0 = uv0;
 #else
-  pbr_vUV = vec2(0.,0.);
+  pbr_vUV0 = vec2(0.,0.);
 #endif
+
+  pbr_vUV1 = uv1;
 }
 `
   );
@@ -6174,6 +6499,41 @@ layout(std140) uniform pbrMaterialUniforms {
   vec4 scaleDiffBaseMR;
   vec4 scaleFGDSpec;
   // #endif
+
+  int baseColorUVSet;
+  mat3 baseColorUVTransform;
+  int metallicRoughnessUVSet;
+  mat3 metallicRoughnessUVTransform;
+  int normalUVSet;
+  mat3 normalUVTransform;
+  int occlusionUVSet;
+  mat3 occlusionUVTransform;
+  int emissiveUVSet;
+  mat3 emissiveUVTransform;
+  int specularColorUVSet;
+  mat3 specularColorUVTransform;
+  int specularIntensityUVSet;
+  mat3 specularIntensityUVTransform;
+  int transmissionUVSet;
+  mat3 transmissionUVTransform;
+  int thicknessUVSet;
+  mat3 thicknessUVTransform;
+  int clearcoatUVSet;
+  mat3 clearcoatUVTransform;
+  int clearcoatRoughnessUVSet;
+  mat3 clearcoatRoughnessUVTransform;
+  int clearcoatNormalUVSet;
+  mat3 clearcoatNormalUVTransform;
+  int sheenColorUVSet;
+  mat3 sheenColorUVTransform;
+  int sheenRoughnessUVSet;
+  mat3 sheenRoughnessUVTransform;
+  int iridescenceUVSet;
+  mat3 iridescenceUVTransform;
+  int iridescenceThicknessUVSet;
+  mat3 iridescenceThicknessUVTransform;
+  int anisotropyUVSet;
+  mat3 anisotropyUVTransform;
 } pbrMaterial;
 
 // Samplers
@@ -6231,7 +6591,8 @@ uniform sampler2D pbr_anisotropySampler;
 // Inputs from vertex shader
 
 in vec3 pbr_vPosition;
-in vec2 pbr_vUV;
+in vec2 pbr_vUV0;
+in vec2 pbr_vUV1;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
@@ -6281,14 +6642,20 @@ vec4 SRGBtoLINEAR(vec4 srgbIn)
 #endif //MANUAL_SRGB
 }
 
+vec2 getMaterialUV(int uvSet, mat3 uvTransform)
+{
+  vec2 baseUV = uvSet == 1 ? pbr_vUV1 : pbr_vUV0;
+  return (uvTransform * vec3(baseUV, 1.0)).xy;
+}
+
 // Build the tangent basis from interpolated attributes or screen-space derivatives.
-mat3 getTBN()
+mat3 getTBN(vec2 uv)
 {
 #ifndef HAS_TANGENTS
   vec3 pos_dx = dFdx(pbr_vPosition);
   vec3 pos_dy = dFdy(pbr_vPosition);
-  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));
-  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));
+  vec3 tex_dx = dFdx(vec3(uv, 0.0));
+  vec3 tex_dy = dFdy(vec3(uv, 0.0));
   vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
 
 #ifdef HAS_NORMALS
@@ -6309,16 +6676,16 @@ mat3 getTBN()
 
 // Find the normal for this fragment, pulling either from a predefined normal map
 // or from the interpolated mesh normal and tangent attributes.
-vec3 getMappedNormal(sampler2D normalSampler, mat3 tbn, float normalScale)
+vec3 getMappedNormal(sampler2D normalSampler, mat3 tbn, float normalScale, vec2 uv)
 {
-  vec3 n = texture(normalSampler, pbr_vUV).rgb;
+  vec3 n = texture(normalSampler, uv).rgb;
   return normalize(tbn * ((2.0 * n - 1.0) * vec3(normalScale, normalScale, 1.0)));
 }
 
-vec3 getNormal(mat3 tbn)
+vec3 getNormal(mat3 tbn, vec2 uv)
 {
 #ifdef HAS_NORMALMAP
-  vec3 n = getMappedNormal(pbr_normalSampler, tbn, pbrMaterial.normalScale);
+  vec3 n = getMappedNormal(pbr_normalSampler, tbn, pbrMaterial.normalScale, uv);
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   vec3 n = normalize(tbn[2].xyz);
@@ -6327,10 +6694,10 @@ vec3 getNormal(mat3 tbn)
   return n;
 }
 
-vec3 getClearcoatNormal(mat3 tbn, vec3 baseNormal)
+vec3 getClearcoatNormal(mat3 tbn, vec3 baseNormal, vec2 uv)
 {
 #ifdef HAS_CLEARCOATNORMALMAP
-  return getMappedNormal(pbr_clearcoatNormalSampler, tbn, 1.0);
+  return getMappedNormal(pbr_clearcoatNormalSampler, tbn, 1.0, uv);
 #else
   return baseNormal;
 #endif
@@ -6618,9 +6985,61 @@ vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
 
 vec4 pbr_filterColor(vec4 colorUnused)
 {
+  vec2 baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
+  vec2 metallicRoughnessUV = getMaterialUV(
+    pbrMaterial.metallicRoughnessUVSet,
+    pbrMaterial.metallicRoughnessUVTransform
+  );
+  vec2 normalUV = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+  vec2 occlusionUV = getMaterialUV(pbrMaterial.occlusionUVSet, pbrMaterial.occlusionUVTransform);
+  vec2 emissiveUV = getMaterialUV(pbrMaterial.emissiveUVSet, pbrMaterial.emissiveUVTransform);
+  vec2 specularColorUV = getMaterialUV(
+    pbrMaterial.specularColorUVSet,
+    pbrMaterial.specularColorUVTransform
+  );
+  vec2 specularIntensityUV = getMaterialUV(
+    pbrMaterial.specularIntensityUVSet,
+    pbrMaterial.specularIntensityUVTransform
+  );
+  vec2 transmissionUV = getMaterialUV(
+    pbrMaterial.transmissionUVSet,
+    pbrMaterial.transmissionUVTransform
+  );
+  vec2 thicknessUV = getMaterialUV(pbrMaterial.thicknessUVSet, pbrMaterial.thicknessUVTransform);
+  vec2 clearcoatUV = getMaterialUV(pbrMaterial.clearcoatUVSet, pbrMaterial.clearcoatUVTransform);
+  vec2 clearcoatRoughnessUV = getMaterialUV(
+    pbrMaterial.clearcoatRoughnessUVSet,
+    pbrMaterial.clearcoatRoughnessUVTransform
+  );
+  vec2 clearcoatNormalUV = getMaterialUV(
+    pbrMaterial.clearcoatNormalUVSet,
+    pbrMaterial.clearcoatNormalUVTransform
+  );
+  vec2 sheenColorUV = getMaterialUV(
+    pbrMaterial.sheenColorUVSet,
+    pbrMaterial.sheenColorUVTransform
+  );
+  vec2 sheenRoughnessUV = getMaterialUV(
+    pbrMaterial.sheenRoughnessUVSet,
+    pbrMaterial.sheenRoughnessUVTransform
+  );
+  vec2 iridescenceUV = getMaterialUV(
+    pbrMaterial.iridescenceUVSet,
+    pbrMaterial.iridescenceUVTransform
+  );
+  vec2 iridescenceThicknessUV = getMaterialUV(
+    pbrMaterial.iridescenceThicknessUVSet,
+    pbrMaterial.iridescenceThicknessUVTransform
+  );
+  vec2 anisotropyUV = getMaterialUV(
+    pbrMaterial.anisotropyUVSet,
+    pbrMaterial.anisotropyUVTransform
+  );
+
   // The albedo may be defined from a base texture or a flat color
 #ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
+  vec4 baseColor =
+    SRGBtoLINEAR(texture(pbr_baseColorSampler, baseColorUV)) * pbrMaterial.baseColorFactor;
 #else
   vec4 baseColor = pbrMaterial.baseColorFactor;
 #endif
@@ -6647,14 +7066,14 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, metallicRoughnessUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
 #endif
     perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
     metallic = clamp(metallic, 0.0, 1.0);
-    mat3 tbn = getTBN();
-    vec3 n = getNormal(tbn);                          // normal at surface point
+    mat3 tbn = getTBN(normalUV);
+    vec3 n = getNormal(tbn, normalUV);                          // normal at surface point
     vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
     float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
 #ifdef USE_MATERIAL_EXTENSIONS
@@ -6755,7 +7174,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
 #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled) {
-        float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+        float ao = texture(pbr_occlusionSampler, occlusionUV).r;
         color = mix(color, color * ao, pbrMaterial.occlusionStrength);
       }
 #endif
@@ -6763,7 +7182,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
       vec3 emissive = pbrMaterial.emissiveFactor;
 #ifdef HAS_EMISSIVEMAP
       if (pbrMaterial.emissiveMapEnabled) {
-        emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb;
+        emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, emissiveUV)).rgb;
       }
 #endif
       color += emissive * pbrMaterial.emissiveStrength;
@@ -6780,55 +7199,55 @@ vec4 pbr_filterColor(vec4 colorUnused)
     float specularIntensity = pbrMaterial.specularIntensityFactor;
 #ifdef HAS_SPECULARINTENSITYMAP
     if (pbrMaterial.specularIntensityMapEnabled) {
-      specularIntensity *= texture(pbr_specularIntensitySampler, pbr_vUV).a;
+      specularIntensity *= texture(pbr_specularIntensitySampler, specularIntensityUV).a;
     }
 #endif
 
     vec3 specularFactor = pbrMaterial.specularColorFactor;
 #ifdef HAS_SPECULARCOLORMAP
     if (pbrMaterial.specularColorMapEnabled) {
-      specularFactor *= SRGBtoLINEAR(texture(pbr_specularColorSampler, pbr_vUV)).rgb;
+      specularFactor *= SRGBtoLINEAR(texture(pbr_specularColorSampler, specularColorUV)).rgb;
     }
 #endif
 
     transmission = pbrMaterial.transmissionFactor;
 #ifdef HAS_TRANSMISSIONMAP
     if (pbrMaterial.transmissionMapEnabled) {
-      transmission *= texture(pbr_transmissionSampler, pbr_vUV).r;
+      transmission *= texture(pbr_transmissionSampler, transmissionUV).r;
     }
 #endif
     transmission = clamp(transmission * (1.0 - metallic), 0.0, 1.0);
     float thickness = max(pbrMaterial.thicknessFactor, 0.0);
 #ifdef HAS_THICKNESSMAP
-    thickness *= texture(pbr_thicknessSampler, pbr_vUV).g;
+    thickness *= texture(pbr_thicknessSampler, thicknessUV).g;
 #endif
 
     float clearcoatFactor = pbrMaterial.clearcoatFactor;
     float clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
 #ifdef HAS_CLEARCOATMAP
     if (pbrMaterial.clearcoatMapEnabled) {
-      clearcoatFactor *= texture(pbr_clearcoatSampler, pbr_vUV).r;
+      clearcoatFactor *= texture(pbr_clearcoatSampler, clearcoatUV).r;
     }
 #endif
 #ifdef HAS_CLEARCOATROUGHNESSMAP
     if (pbrMaterial.clearcoatRoughnessMapEnabled) {
-      clearcoatRoughness *= texture(pbr_clearcoatRoughnessSampler, pbr_vUV).g;
+      clearcoatRoughness *= texture(pbr_clearcoatRoughnessSampler, clearcoatRoughnessUV).g;
     }
 #endif
     clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
     clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
-    vec3 clearcoatNormal = getClearcoatNormal(tbn, n);
+    vec3 clearcoatNormal = getClearcoatNormal(getTBN(clearcoatNormalUV), n, clearcoatNormalUV);
 
     vec3 sheenColor = pbrMaterial.sheenColorFactor;
     float sheenRoughness = pbrMaterial.sheenRoughnessFactor;
 #ifdef HAS_SHEENCOLORMAP
     if (pbrMaterial.sheenColorMapEnabled) {
-      sheenColor *= SRGBtoLINEAR(texture(pbr_sheenColorSampler, pbr_vUV)).rgb;
+      sheenColor *= SRGBtoLINEAR(texture(pbr_sheenColorSampler, sheenColorUV)).rgb;
     }
 #endif
 #ifdef HAS_SHEENROUGHNESSMAP
     if (pbrMaterial.sheenRoughnessMapEnabled) {
-      sheenRoughness *= texture(pbr_sheenRoughnessSampler, pbr_vUV).a;
+      sheenRoughness *= texture(pbr_sheenRoughnessSampler, sheenRoughnessUV).a;
     }
 #endif
     sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
@@ -6836,7 +7255,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     float iridescence = pbrMaterial.iridescenceFactor;
 #ifdef HAS_IRIDESCENCEMAP
     if (pbrMaterial.iridescenceMapEnabled) {
-      iridescence *= texture(pbr_iridescenceSampler, pbr_vUV).r;
+      iridescence *= texture(pbr_iridescenceSampler, iridescenceUV).r;
     }
 #endif
     iridescence = clamp(iridescence, 0.0, 1.0);
@@ -6849,7 +7268,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     iridescenceThickness = mix(
       pbrMaterial.iridescenceThicknessRange.x,
       pbrMaterial.iridescenceThicknessRange.y,
-      texture(pbr_iridescenceThicknessSampler, pbr_vUV).g
+      texture(pbr_iridescenceThicknessSampler, iridescenceThicknessUV).g
     );
 #endif
 
@@ -6857,7 +7276,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     vec2 anisotropyDirection = normalizeDirection(pbrMaterial.anisotropyDirection);
 #ifdef HAS_ANISOTROPYMAP
     if (pbrMaterial.anisotropyMapEnabled) {
-      vec3 anisotropySample = texture(pbr_anisotropySampler, pbr_vUV).rgb;
+      vec3 anisotropySample = texture(pbr_anisotropySampler, anisotropyUV).rgb;
       anisotropyStrength *= anisotropySample.b;
       vec2 mappedDirection = anisotropySample.rg * 2.0 - 1.0;
       if (length(mappedDirection) > 0.0001) {
@@ -7020,7 +7439,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
  // Apply optional PBR terms for additional (optional) shading
 #ifdef HAS_OCCLUSIONMAP
     if (pbrMaterial.occlusionMapEnabled) {
-      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+      float ao = texture(pbr_occlusionSampler, occlusionUV).r;
       color = mix(color, color * ao, pbrMaterial.occlusionStrength);
     }
 #endif
@@ -7028,7 +7447,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     vec3 emissive = pbrMaterial.emissiveFactor;
 #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled) {
-      emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb;
+      emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, emissiveUV)).rgb;
     }
 #endif
     color += emissive * pbrMaterial.emissiveStrength;
@@ -7066,14 +7485,21 @@ vec4 pbr_filterColor(vec4 colorUnused)
     /* wgsl */
     `struct PBRFragmentInputs {
   pbr_vPosition: vec3f,
-  pbr_vUV: vec2f,
+  pbr_vUV0: vec2f,
+  pbr_vUV1: vec2f,
   pbr_vTBN: mat3x3f,
   pbr_vNormal: vec3f
 };
 
 var<private> fragmentInputs: PBRFragmentInputs;
 
-fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f, uv: vec2f)
+fn pbr_setPositionNormalTangentUV(
+  position: vec4f,
+  normal: vec4f,
+  tangent: vec4f,
+  uv0: vec2f,
+  uv1: vec2f
+)
 {
   var pos: vec4f = pbrProjection.modelMatrix * position;
   fragmentInputs.pbr_vPosition = pos.xyz / pos.w;
@@ -7083,7 +7509,8 @@ fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f
     vec3f(0.0, 1.0, 0.0),
     vec3f(0.0, 0.0, 1.0)
   );
-  fragmentInputs.pbr_vUV = vec2f(0.0, 0.0);
+  fragmentInputs.pbr_vUV0 = vec2f(0.0, 0.0);
+  fragmentInputs.pbr_vUV1 = uv1;
 
 #ifdef HAS_NORMALS
   let normalW: vec3f = normalize((pbrProjection.normalMatrix * vec4f(normal.xyz, 0.0)).xyz);
@@ -7096,7 +7523,7 @@ fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f
 #endif
 
 #ifdef HAS_UV
-  fragmentInputs.pbr_vUV = uv;
+  fragmentInputs.pbr_vUV0 = uv0;
 #endif
 }
 
@@ -7168,6 +7595,41 @@ struct pbrMaterialUniforms {
   scaleDiffBaseMR: vec4f,
   scaleFGDSpec: vec4f,
   // #endif
+
+  baseColorUVSet: i32,
+  baseColorUVTransform: mat3x3f,
+  metallicRoughnessUVSet: i32,
+  metallicRoughnessUVTransform: mat3x3f,
+  normalUVSet: i32,
+  normalUVTransform: mat3x3f,
+  occlusionUVSet: i32,
+  occlusionUVTransform: mat3x3f,
+  emissiveUVSet: i32,
+  emissiveUVTransform: mat3x3f,
+  specularColorUVSet: i32,
+  specularColorUVTransform: mat3x3f,
+  specularIntensityUVSet: i32,
+  specularIntensityUVTransform: mat3x3f,
+  transmissionUVSet: i32,
+  transmissionUVTransform: mat3x3f,
+  thicknessUVSet: i32,
+  thicknessUVTransform: mat3x3f,
+  clearcoatUVSet: i32,
+  clearcoatUVTransform: mat3x3f,
+  clearcoatRoughnessUVSet: i32,
+  clearcoatRoughnessUVTransform: mat3x3f,
+  clearcoatNormalUVSet: i32,
+  clearcoatNormalUVTransform: mat3x3f,
+  sheenColorUVSet: i32,
+  sheenColorUVTransform: mat3x3f,
+  sheenRoughnessUVSet: i32,
+  sheenRoughnessUVTransform: mat3x3f,
+  iridescenceUVSet: i32,
+  iridescenceUVTransform: mat3x3f,
+  iridescenceThicknessUVSet: i32,
+  iridescenceThicknessUVTransform: mat3x3f,
+  anisotropyUVSet: i32,
+  anisotropyUVTransform: mat3x3f,
 }
 
 @group(3) @binding(auto) var<uniform> pbrMaterial : pbrMaterialUniforms;
@@ -7281,13 +7743,22 @@ fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
   return vec4f(linOut, srgbIn.w);
 }
 
+fn getMaterialUV(uvSet: i32, uvTransform: mat3x3f) -> vec2f
+{
+  var baseUV = fragmentInputs.pbr_vUV0;
+  if (uvSet == 1) {
+    baseUV = fragmentInputs.pbr_vUV1;
+  }
+  return (uvTransform * vec3f(baseUV, 1.0)).xy;
+}
+
 // Build the tangent basis from interpolated attributes or screen-space derivatives.
-fn getTBN() -> mat3x3f
+fn getTBN(uv: vec2f) -> mat3x3f
 {
   let pos_dx: vec3f = dpdx(fragmentInputs.pbr_vPosition);
   let pos_dy: vec3f = dpdy(fragmentInputs.pbr_vPosition);
-  let tex_dx: vec3f = dpdx(vec3f(fragmentInputs.pbr_vUV, 0.0));
-  let tex_dy: vec3f = dpdy(vec3f(fragmentInputs.pbr_vUV, 0.0));
+  let tex_dx: vec3f = dpdx(vec3f(uv, 0.0));
+  let tex_dy: vec3f = dpdy(vec3f(uv, 0.0));
   var t: vec3f = (tex_dy.y * pos_dx - tex_dx.y * pos_dy) / (tex_dx.x * tex_dy.y - tex_dy.x * tex_dx.y);
 
   var ng: vec3f = cross(pos_dx, pos_dy);
@@ -7310,14 +7781,15 @@ fn getMappedNormal(
   normalSampler: texture_2d<f32>,
   normalSamplerBinding: sampler,
   tbn: mat3x3f,
-  normalScale: f32
+  normalScale: f32,
+  uv: vec2f
 ) -> vec3f
 {
-  let n = textureSample(normalSampler, normalSamplerBinding, fragmentInputs.pbr_vUV).rgb;
+  let n = textureSample(normalSampler, normalSamplerBinding, uv).rgb;
   return normalize(tbn * ((2.0 * n - 1.0) * vec3f(normalScale, normalScale, 1.0)));
 }
 
-fn getNormal(tbn: mat3x3f) -> vec3f
+fn getNormal(tbn: mat3x3f, uv: vec2f) -> vec3f
 {
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   var n: vec3f = normalize(tbn[2].xyz);
@@ -7326,21 +7798,23 @@ fn getNormal(tbn: mat3x3f) -> vec3f
     pbr_normalSampler,
     pbr_normalSamplerSampler,
     tbn,
-    pbrMaterial.normalScale
+    pbrMaterial.normalScale,
+    uv
   );
 #endif
 
   return n;
 }
 
-fn getClearcoatNormal(tbn: mat3x3f, baseNormal: vec3f) -> vec3f
+fn getClearcoatNormal(tbn: mat3x3f, baseNormal: vec3f, uv: vec2f) -> vec3f
 {
 #ifdef HAS_CLEARCOATNORMALMAP
   return getMappedNormal(
     pbr_clearcoatNormalSampler,
     pbr_clearcoatNormalSamplerSampler,
     tbn,
-    1.0
+    1.0,
+    uv
   );
 #else
   return baseNormal;
@@ -7645,11 +8119,62 @@ fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
 }
 
 fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
+  let baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
+  let metallicRoughnessUV = getMaterialUV(
+    pbrMaterial.metallicRoughnessUVSet,
+    pbrMaterial.metallicRoughnessUVTransform
+  );
+  let normalUV = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+  let occlusionUV = getMaterialUV(pbrMaterial.occlusionUVSet, pbrMaterial.occlusionUVTransform);
+  let emissiveUV = getMaterialUV(pbrMaterial.emissiveUVSet, pbrMaterial.emissiveUVTransform);
+  let specularColorUV = getMaterialUV(
+    pbrMaterial.specularColorUVSet,
+    pbrMaterial.specularColorUVTransform
+  );
+  let specularIntensityUV = getMaterialUV(
+    pbrMaterial.specularIntensityUVSet,
+    pbrMaterial.specularIntensityUVTransform
+  );
+  let transmissionUV = getMaterialUV(
+    pbrMaterial.transmissionUVSet,
+    pbrMaterial.transmissionUVTransform
+  );
+  let thicknessUV = getMaterialUV(pbrMaterial.thicknessUVSet, pbrMaterial.thicknessUVTransform);
+  let clearcoatUV = getMaterialUV(pbrMaterial.clearcoatUVSet, pbrMaterial.clearcoatUVTransform);
+  let clearcoatRoughnessUV = getMaterialUV(
+    pbrMaterial.clearcoatRoughnessUVSet,
+    pbrMaterial.clearcoatRoughnessUVTransform
+  );
+  let clearcoatNormalUV = getMaterialUV(
+    pbrMaterial.clearcoatNormalUVSet,
+    pbrMaterial.clearcoatNormalUVTransform
+  );
+  let sheenColorUV = getMaterialUV(
+    pbrMaterial.sheenColorUVSet,
+    pbrMaterial.sheenColorUVTransform
+  );
+  let sheenRoughnessUV = getMaterialUV(
+    pbrMaterial.sheenRoughnessUVSet,
+    pbrMaterial.sheenRoughnessUVTransform
+  );
+  let iridescenceUV = getMaterialUV(
+    pbrMaterial.iridescenceUVSet,
+    pbrMaterial.iridescenceUVTransform
+  );
+  let iridescenceThicknessUV = getMaterialUV(
+    pbrMaterial.iridescenceThicknessUVSet,
+    pbrMaterial.iridescenceThicknessUVTransform
+  );
+  let anisotropyUV = getMaterialUV(
+    pbrMaterial.anisotropyUVSet,
+    pbrMaterial.anisotropyUVTransform
+  );
+
   // The albedo may be defined from a base texture or a flat color
   var baseColor: vec4<f32> = pbrMaterial.baseColorFactor;
   #ifdef HAS_BASECOLORMAP
   baseColor = SRGBtoLINEAR(
-    textureSample(pbr_baseColorSampler, pbr_baseColorSamplerSampler, fragmentInputs.pbr_vUV)
+    textureSample(pbr_baseColorSampler, pbr_baseColorSamplerSampler, baseColorUV)
   ) * pbrMaterial.baseColorFactor;
   #endif
 
@@ -7676,15 +8201,15 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     let mrSample = textureSample(
       pbr_metallicRoughnessSampler,
       pbr_metallicRoughnessSamplerSampler,
-      fragmentInputs.pbr_vUV
+      metallicRoughnessUV
     );
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
     #endif
     perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
     metallic = clamp(metallic, 0.0, 1.0);
-    let tbn = getTBN();
-    let n = getNormal(tbn);                          // normal at surface point
+    let tbn = getTBN(normalUV);
+    let n = getNormal(tbn, normalUV);                          // normal at surface point
     let v = normalize(pbrProjection.camera - fragmentInputs.pbr_vPosition);  // Vector from surface point to camera
     let NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
     var useExtendedPBR = false;
@@ -7789,8 +8314,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
 
       #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled != 0) {
-        let ao =
-          textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, fragmentInputs.pbr_vUV).r;
+        let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
         color = mix(color, color * ao, pbrMaterial.occlusionStrength);
       }
       #endif
@@ -7799,7 +8323,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       #ifdef HAS_EMISSIVEMAP
       if (pbrMaterial.emissiveMapEnabled != 0u) {
         emissive *= SRGBtoLINEAR(
-          textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
+          textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, emissiveUV)
         ).rgb;
       }
       #endif
@@ -7820,7 +8344,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       specularIntensity *= textureSample(
         pbr_specularIntensitySampler,
         pbr_specularIntensitySamplerSampler,
-        fragmentInputs.pbr_vUV
+        specularIntensityUV
       ).a;
     }
     #endif
@@ -7832,7 +8356,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
         textureSample(
           pbr_specularColorSampler,
           pbr_specularColorSamplerSampler,
-          fragmentInputs.pbr_vUV
+          specularColorUV
         )
       ).rgb;
     }
@@ -7844,7 +8368,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       transmission *= textureSample(
         pbr_transmissionSampler,
         pbr_transmissionSamplerSampler,
-        fragmentInputs.pbr_vUV
+        transmissionUV
       ).r;
     }
     #endif
@@ -7854,7 +8378,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     thickness *= textureSample(
       pbr_thicknessSampler,
       pbr_thicknessSamplerSampler,
-      fragmentInputs.pbr_vUV
+      thicknessUV
     ).g;
     #endif
 
@@ -7865,7 +8389,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       clearcoatFactor *= textureSample(
         pbr_clearcoatSampler,
         pbr_clearcoatSamplerSampler,
-        fragmentInputs.pbr_vUV
+        clearcoatUV
       ).r;
     }
     #endif
@@ -7874,13 +8398,13 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       clearcoatRoughness *= textureSample(
         pbr_clearcoatRoughnessSampler,
         pbr_clearcoatRoughnessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        clearcoatRoughnessUV
       ).g;
     }
     #endif
     clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
     clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
-    let clearcoatNormal = getClearcoatNormal(tbn, n);
+    let clearcoatNormal = getClearcoatNormal(getTBN(clearcoatNormalUV), n, clearcoatNormalUV);
 
     var sheenColor = pbrMaterial.sheenColorFactor;
     var sheenRoughness = pbrMaterial.sheenRoughnessFactor;
@@ -7890,7 +8414,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
         textureSample(
           pbr_sheenColorSampler,
           pbr_sheenColorSamplerSampler,
-          fragmentInputs.pbr_vUV
+          sheenColorUV
         )
       ).rgb;
     }
@@ -7900,7 +8424,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       sheenRoughness *= textureSample(
         pbr_sheenRoughnessSampler,
         pbr_sheenRoughnessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        sheenRoughnessUV
       ).a;
     }
     #endif
@@ -7912,7 +8436,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       iridescence *= textureSample(
         pbr_iridescenceSampler,
         pbr_iridescenceSamplerSampler,
-        fragmentInputs.pbr_vUV
+        iridescenceUV
       ).r;
     }
     #endif
@@ -7929,7 +8453,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       textureSample(
         pbr_iridescenceThicknessSampler,
         pbr_iridescenceThicknessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        iridescenceThicknessUV
       ).g
     );
     #endif
@@ -7941,7 +8465,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       let anisotropySample = textureSample(
         pbr_anisotropySampler,
         pbr_anisotropySamplerSampler,
-        fragmentInputs.pbr_vUV
+        anisotropyUV
       ).rgb;
       anisotropyStrength *= anisotropySample.b;
       let mappedDirection = anisotropySample.rg * 2.0 - 1.0;
@@ -8108,8 +8632,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     // Apply optional PBR terms for additional (optional) shading
     #ifdef HAS_OCCLUSIONMAP
     if (pbrMaterial.occlusionMapEnabled != 0) {
-      let ao =
-        textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, fragmentInputs.pbr_vUV).r;
+      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
       color = mix(color, color * ao, pbrMaterial.occlusionStrength);
     }
     #endif
@@ -8118,7 +8641,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled != 0u) {
       emissive *= SRGBtoLINEAR(
-        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
+        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, emissiveUV)
       ).rgb;
     }
     #endif
@@ -8238,7 +8761,41 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       anisotropyRotation: 0,
       anisotropyDirection: [1, 0],
       anisotropyMapEnabled: false,
-      emissiveStrength: 1
+      emissiveStrength: 1,
+      baseColorUVSet: 0,
+      baseColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      metallicRoughnessUVSet: 0,
+      metallicRoughnessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      normalUVSet: 0,
+      normalUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      occlusionUVSet: 0,
+      occlusionUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      emissiveUVSet: 0,
+      emissiveUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      specularColorUVSet: 0,
+      specularColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      specularIntensityUVSet: 0,
+      specularIntensityUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      transmissionUVSet: 0,
+      transmissionUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      thicknessUVSet: 0,
+      thicknessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      clearcoatUVSet: 0,
+      clearcoatUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      clearcoatRoughnessUVSet: 0,
+      clearcoatRoughnessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      clearcoatNormalUVSet: 0,
+      clearcoatNormalUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      sheenColorUVSet: 0,
+      sheenColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      sheenRoughnessUVSet: 0,
+      sheenRoughnessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      iridescenceUVSet: 0,
+      iridescenceUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      iridescenceThicknessUVSet: 0,
+      iridescenceThicknessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      anisotropyUVSet: 0,
+      anisotropyUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1]
     },
     name: "pbrMaterial",
     firstBindingSlot: 0,
@@ -8345,7 +8902,41 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       // debugging flags used for shader output of intermediate PBR variables
       // #ifdef PBR_DEBUG
       scaleDiffBaseMR: "vec4<f32>",
-      scaleFGDSpec: "vec4<f32>"
+      scaleFGDSpec: "vec4<f32>",
+      baseColorUVSet: "i32",
+      baseColorUVTransform: "mat3x3<f32>",
+      metallicRoughnessUVSet: "i32",
+      metallicRoughnessUVTransform: "mat3x3<f32>",
+      normalUVSet: "i32",
+      normalUVTransform: "mat3x3<f32>",
+      occlusionUVSet: "i32",
+      occlusionUVTransform: "mat3x3<f32>",
+      emissiveUVSet: "i32",
+      emissiveUVTransform: "mat3x3<f32>",
+      specularColorUVSet: "i32",
+      specularColorUVTransform: "mat3x3<f32>",
+      specularIntensityUVSet: "i32",
+      specularIntensityUVTransform: "mat3x3<f32>",
+      transmissionUVSet: "i32",
+      transmissionUVTransform: "mat3x3<f32>",
+      thicknessUVSet: "i32",
+      thicknessUVTransform: "mat3x3<f32>",
+      clearcoatUVSet: "i32",
+      clearcoatUVTransform: "mat3x3<f32>",
+      clearcoatRoughnessUVSet: "i32",
+      clearcoatRoughnessUVTransform: "mat3x3<f32>",
+      clearcoatNormalUVSet: "i32",
+      clearcoatNormalUVTransform: "mat3x3<f32>",
+      sheenColorUVSet: "i32",
+      sheenColorUVTransform: "mat3x3<f32>",
+      sheenRoughnessUVSet: "i32",
+      sheenRoughnessUVTransform: "mat3x3<f32>",
+      iridescenceUVSet: "i32",
+      iridescenceUVTransform: "mat3x3<f32>",
+      iridescenceThicknessUVSet: "i32",
+      iridescenceThicknessUVTransform: "mat3x3<f32>",
+      anisotropyUVSet: "i32",
+      anisotropyUVTransform: "mat3x3<f32>"
     }
   };