@luma.gl/shadertools 9.3.0-alpha.9 → 9.3.1

package/dist/dist.dev.js

@@ -62,6 +62,7 @@ var __exports__ = (() => {
     combineInjects: () => combineInjects,
     convertToVec4: () => convertToVec4,
     dirlight: () => dirlight,
+    floatColors: () => floatColors,
     fp32: () => fp32,
     fp64: () => fp64,
     fp64LowPart: () => fp64LowPart,
@@ -70,6 +71,7 @@ var __exports__ = (() => {
     fp64ifyMatrix4: () => fp64ifyMatrix4,
     fromHalfFloat: () => fromHalfFloat,
     generateShaderForModule: () => generateShaderForModule,
+    getGLSLUniformBlocks: () => getGLSLUniformBlocks,
     getPassthroughFS: () => getPassthroughFS,
     getQualifierDetails: () => getQualifierDetails,
     getShaderInfo: () => getShaderInfo,
@@ -85,16 +87,21 @@ var __exports__ = (() => {
     initializeShaderModules: () => initializeShaderModules,
     lambertMaterial: () => lambertMaterial,
     lighting: () => lighting,
+    normalizeByteColor3: () => normalizeByteColor3,
+    normalizeByteColor4: () => normalizeByteColor4,
     pbrMaterial: () => pbrMaterial,
+    pbrScene: () => pbrScene,
     phongMaterial: () => phongMaterial,
     picking: () => picking,
     preprocess: () => preprocess,
     random: () => random,
+    resolveUseByteColors: () => resolveUseByteColors,
     skin: () => skin,
     toHalfFloat: () => toHalfFloat,
     typeToChannelCount: () => typeToChannelCount,
     typeToChannelSuffix: () => typeToChannelSuffix,
-    validateShaderModuleUniformLayout: () => validateShaderModuleUniformLayout
+    validateShaderModuleUniformLayout: () => validateShaderModuleUniformLayout,
+    warnIfGLSLUniformBlocksAreNotStd140: () => warnIfGLSLUniformBlocksAreNotStd140
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
@@ -417,6 +424,7 @@ ${inject[key]}` : inject[key];
 
   // src/lib/shader-module/shader-module-uniform-layout.ts
   var GLSL_UNIFORM_BLOCK_FIELD_REGEXP = /^(?:uniform\s+)?(?:(?:lowp|mediump|highp)\s+)?[A-Za-z0-9_]+(?:<[^>]+>)?\s+([A-Za-z0-9_]+)(?:\s*\[[^\]]+\])?\s*;/;
+  var GLSL_UNIFORM_BLOCK_REGEXP = /((?:layout\s*\([^)]*\)\s*)*)uniform\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{([\s\S]*?)\}\s*([A-Za-z_][A-Za-z0-9_]*)?\s*;/g;
   function getShaderModuleUniformBlockName(module) {
     return `${module.name}Uniforms`;
   }
@@ -462,6 +470,39 @@ ${inject[key]}` : inject[key];
     }
     return validationResult;
   }
+  function getGLSLUniformBlocks(shaderSource) {
+    const blocks = [];
+    const uncommentedSource = stripShaderComments(shaderSource);
+    for (const sourceMatch of uncommentedSource.matchAll(GLSL_UNIFORM_BLOCK_REGEXP)) {
+      const layoutQualifier = sourceMatch[1]?.trim() || null;
+      blocks.push({
+        blockName: sourceMatch[2],
+        body: sourceMatch[3],
+        instanceName: sourceMatch[4] || null,
+        layoutQualifier,
+        hasLayoutQualifier: Boolean(layoutQualifier),
+        isStd140: Boolean(
+          layoutQualifier && /\blayout\s*\([^)]*\bstd140\b[^)]*\)/.exec(layoutQualifier)
+        )
+      });
+    }
+    return blocks;
+  }
+  function warnIfGLSLUniformBlocksAreNotStd140(shaderSource, stage, log2, context) {
+    const nonStd140Blocks = getGLSLUniformBlocks(shaderSource).filter((block) => !block.isStd140);
+    const seenBlockNames = /* @__PURE__ */ new Set();
+    for (const block of nonStd140Blocks) {
+      if (seenBlockNames.has(block.blockName)) {
+        continue;
+      }
+      seenBlockNames.add(block.blockName);
+      const shaderLabel = context?.label ? `${context.label} ` : "";
+      const actualLayout = block.hasLayoutQualifier ? `declares ${normalizeWhitespace(block.layoutQualifier)} instead of layout(std140)` : "does not declare layout(std140)";
+      const message = `${shaderLabel}${stage} shader uniform block ${block.blockName} ${actualLayout}. luma.gl host-side shader block packing assumes explicit layout(std140) for GLSL uniform blocks. Add \`layout(std140)\` to the block declaration.`;
+      log2?.warn?.(message, block)();
+    }
+    return nonStd140Blocks;
+  }
   function extractShaderUniformBlockFieldNames(shaderSource, language, uniformBlockName) {
     const sourceBody = language === "wgsl" ? extractWGSLStructBody(shaderSource, uniformBlockName) : extractGLSLUniformBlockBody(shaderSource, uniformBlockName);
     if (!sourceBody) {
@@ -507,10 +548,10 @@ ${inject[key]}` : inject[key];
     return null;
   }
   function extractGLSLUniformBlockBody(shaderSource, uniformBlockName) {
-    const sourceMatch = shaderSource.match(
-      new RegExp(`uniform\\s+${uniformBlockName}\\s*\\{([\\s\\S]*?)\\}\\s*[A-Za-z0-9_]+\\s*;`, "m")
+    const block = getGLSLUniformBlocks(shaderSource).find(
+      (candidate) => candidate.blockName === uniformBlockName
     );
-    return sourceMatch?.[1] || null;
+    return block?.body || null;
   }
   function areStringArraysEqual(leftValues, rightValues) {
     if (leftValues.length !== rightValues.length) {
@@ -524,11 +565,70 @@ ${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, "");
+  }
+  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
@@ -715,12 +815,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(
@@ -736,7 +1018,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]);
@@ -755,6 +1038,7 @@ Actual: ${validationResult.actualUniformNames.join(", ")}`;
             resourceType
           })
         );
+        match = regex.exec(maskedSource);
       }
     }
     return rows.sort((left, right) => {
@@ -866,14 +1150,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 */
@@ -953,7 +1229,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,
@@ -994,7 +1273,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 };
@@ -1095,6 +1374,9 @@ ${getApplicationDefines(allDefines)}
     if (language === "glsl" && sourceVersion !== targetVersion) {
       assembledSource = transpileGLSLShader(assembledSource, stage);
     }
+    if (language === "glsl") {
+      warnIfGLSLUniformBlocksAreNotStd140(assembledSource, stage, log2);
+    }
     return assembledSource.trim();
   }
   function assembleGetUniforms(modules) {
@@ -1151,61 +1433,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);
@@ -1244,6 +1552,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) {
@@ -1293,16 +1618,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;
   }
@@ -1338,10 +1661,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) {
@@ -1358,6 +1707,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_]*)";
@@ -1642,7 +2009,7 @@ void main() {
     switch (options.uniforms) {
       case "scoped-interface-blocks":
       case "unscoped-interface-blocks":
-        glsl.push(`uniform ${capitalize(module.name)} {`);
+        glsl.push(`layout(std140) uniform ${capitalize(module.name)} {`);
         break;
       case "uniforms":
     }
@@ -3533,6 +3900,28 @@ void main() {
     return matrixFP64;
   }
 
+  // src/lib/color/normalize-byte-colors.ts
+  function resolveUseByteColors(useByteColors, defaultUseByteColors = true) {
+    return useByteColors ?? defaultUseByteColors;
+  }
+  function normalizeByteColor3(color = [0, 0, 0], useByteColors = true) {
+    if (!useByteColors) {
+      return [...color];
+    }
+    return color.map((component) => component / 255);
+  }
+  function normalizeByteColor4(color, useByteColors = true) {
+    const normalizedColor = normalizeByteColor3(color.slice(0, 3), useByteColors);
+    const hasAlpha = Number.isFinite(color[3]);
+    const alpha = hasAlpha ? color[3] : 1;
+    return [
+      normalizedColor[0],
+      normalizedColor[1],
+      normalizedColor[2],
+      useByteColors && hasAlpha ? alpha / 255 : alpha
+    ];
+  }
+
   // src/modules/math/random/random.ts
   var source = (
     /* wgsl */
@@ -3719,7 +4108,7 @@ float tan_fp32(float a) {
   var fp64arithmeticShader = (
     /* glsl */
     `
-uniform fp64arithmeticUniforms {
+layout(std140) uniform fp64arithmeticUniforms {
   uniform float ONE;
   uniform float SPLIT;
 } fp64;
@@ -4837,15 +5226,99 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
     fp64ifyMatrix4
   };
 
+  // src/modules/color/float-colors.ts
+  var GLSL_UNIFORMS = (
+    /* glsl */
+    `layout(std140) uniform floatColorsUniforms {
+  float useByteColors;
+} floatColors;
+
+vec3 floatColors_normalize(vec3 inputColor) {
+  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+}
+
+vec4 floatColors_normalize(vec4 inputColor) {
+  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+}
+
+vec4 floatColors_premultiplyAlpha(vec4 inputColor) {
+  return vec4(inputColor.rgb * inputColor.a, inputColor.a);
+}
+
+vec4 floatColors_unpremultiplyAlpha(vec4 inputColor) {
+  return inputColor.a > 0.0 ? vec4(inputColor.rgb / inputColor.a, inputColor.a) : vec4(0.0);
+}
+
+vec4 floatColors_premultiply_alpha(vec4 inputColor) {
+  return floatColors_premultiplyAlpha(inputColor);
+}
+
+vec4 floatColors_unpremultiply_alpha(vec4 inputColor) {
+  return floatColors_unpremultiplyAlpha(inputColor);
+}
+`
+  );
+  var WGSL_UNIFORMS = (
+    /* wgsl */
+    `struct floatColorsUniforms {
+  useByteColors: f32
+};
+
+@group(0) @binding(auto) var<uniform> floatColors : floatColorsUniforms;
+
+fn floatColors_normalize(inputColor: vec3<f32>) -> vec3<f32> {
+  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+}
+
+fn floatColors_normalize4(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+}
+
+fn floatColors_premultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return vec4<f32>(inputColor.rgb * inputColor.a, inputColor.a);
+}
+
+fn floatColors_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(
+    vec4<f32>(0.0),
+    vec4<f32>(inputColor.rgb / inputColor.a, inputColor.a),
+    inputColor.a > 0.0
+  );
+}
+
+fn floatColors_premultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return floatColors_premultiplyAlpha(inputColor);
+}
+
+fn floatColors_unpremultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return floatColors_unpremultiplyAlpha(inputColor);
+}
+`
+  );
+  var floatColors = {
+    name: "floatColors",
+    props: {},
+    uniforms: {},
+    vs: GLSL_UNIFORMS,
+    fs: GLSL_UNIFORMS,
+    source: WGSL_UNIFORMS,
+    uniformTypes: {
+      useByteColors: "f32"
+    },
+    defaultUniforms: {
+      useByteColors: true
+    }
+  };
+
   // src/modules/engine/picking/picking.ts
   var DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
   var vs = (
     /* glsl */
-    `uniform pickingUniforms {
+    `layout(std140) uniform pickingUniforms {
   float isActive;
   float isAttribute;
   float isHighlightActive;
-  float useFloatColors;
+  float useByteColors;
   vec3 highlightedObjectColor;
   vec4 highlightColor;
 } picking;
@@ -4854,12 +5327,12 @@ out vec4 picking_vRGBcolor_Avalid;
 
 // Normalize unsigned byte color to 0-1 range
 vec3 picking_normalizeColor(vec3 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
 }
 
 // Normalize unsigned byte color to 0-1 range
 vec4 picking_normalizeColor(vec4 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
 }
 
 bool picking_isColorZero(vec3 color) {
@@ -4916,11 +5389,11 @@ void picking_setPickingAttribute(vec3 value) {
   );
   var fs2 = (
     /* glsl */
-    `uniform pickingUniforms {
+    `layout(std140) uniform pickingUniforms {
   float isActive;
   float isAttribute;
   float isHighlightActive;
-  float useFloatColors;
+  float useByteColors;
   vec3 highlightedObjectColor;
   vec4 highlightColor;
 } picking;
@@ -4982,7 +5455,7 @@ vec4 picking_filterColor(vec4 color) {
       isActive: "f32",
       isAttribute: "f32",
       isHighlightActive: "f32",
-      useFloatColors: "f32",
+      useByteColors: "f32",
       highlightedObjectColor: "vec3<f32>",
       highlightColor: "vec4<f32>"
     },
@@ -4990,7 +5463,7 @@ vec4 picking_filterColor(vec4 color) {
       isActive: false,
       isAttribute: false,
       isHighlightActive: false,
-      useFloatColors: true,
+      useByteColors: true,
       highlightedObjectColor: [0, 0, 0],
       highlightColor: DEFAULT_HIGHLIGHT_COLOR
     },
@@ -5000,6 +5473,7 @@ vec4 picking_filterColor(vec4 color) {
   };
   function getUniforms(opts = {}, prevUniforms) {
     const uniforms = {};
+    const useByteColors = resolveUseByteColors(opts.useByteColors, true);
     if (opts.highlightedObjectColor === void 0) {
     } else if (opts.highlightedObjectColor === null) {
       uniforms.isHighlightActive = false;
@@ -5009,18 +5483,14 @@ vec4 picking_filterColor(vec4 color) {
       uniforms.highlightedObjectColor = highlightedObjectColor;
     }
     if (opts.highlightColor) {
-      const color = Array.from(opts.highlightColor, (x) => x / 255);
-      if (!Number.isFinite(color[3])) {
-        color[3] = 1;
-      }
-      uniforms.highlightColor = color;
+      uniforms.highlightColor = normalizeByteColor4(opts.highlightColor, useByteColors);
     }
     if (opts.isActive !== void 0) {
       uniforms.isActive = Boolean(opts.isActive);
       uniforms.isAttribute = Boolean(opts.isAttribute);
     }
-    if (opts.useFloatColors !== void 0) {
-      uniforms.useFloatColors = Boolean(opts.useFloatColors);
+    if (opts.useByteColors !== void 0) {
+      uniforms.useByteColors = Boolean(opts.useByteColors);
     }
     return uniforms;
   }
@@ -5047,7 +5517,7 @@ fn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {
   var vs2 = (
     /* glsl */
     `
-uniform skinUniforms {
+layout(std140) uniform skinUniforms {
   mat4 jointMatrix[SKIN_MAX_JOINTS];
 } skin;
 
@@ -5155,7 +5625,7 @@ struct UniformLight {
   vec2 coneCos;
 };
 
-uniform lightingUniforms {
+layout(std140) uniform lightingUniforms {
   int enabled;
   int directionalLightCount;
   int pointLightCount;
@@ -5291,7 +5761,6 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
 
   // src/modules/lighting/lights/lighting.ts
   var MAX_LIGHTS = 5;
-  var COLOR_FACTOR = 255;
   var LIGHT_UNIFORM_TYPE = {
     color: "vec3<f32>",
     position: "vec3<f32>",
@@ -5330,7 +5799,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     if (props.lights) {
       props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
     }
-    const { ambientLight, pointLights, spotLights, directionalLights } = props || {};
+    const { useByteColors, ambientLight, pointLights, spotLights, directionalLights } = props || {};
     const hasLights = ambientLight || pointLights && pointLights.length > 0 || spotLights && spotLights.length > 0 || directionalLights && directionalLights.length > 0;
     if (!hasLights) {
       return {
@@ -5340,7 +5809,13 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     }
     const uniforms = {
       ...createDefaultLightingUniforms(),
-      ...getLightSourceUniforms({ ambientLight, pointLights, spotLights, directionalLights })
+      ...getLightSourceUniforms({
+        useByteColors,
+        ambientLight,
+        pointLights,
+        spotLights,
+        directionalLights
+      })
     };
     if (props.enabled !== void 0) {
       uniforms.enabled = props.enabled ? 1 : 0;
@@ -5348,6 +5823,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     return uniforms;
   }
   function getLightSourceUniforms({
+    useByteColors,
     ambientLight,
     pointLights = [],
     spotLights = [],
@@ -5364,7 +5840,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       }
       lights[currentLight] = {
         ...lights[currentLight],
-        color: convertColor(pointLight),
+        color: convertColor(pointLight, useByteColors),
         position: pointLight.position,
         attenuation: pointLight.attenuation || [1, 0, 0]
       };
@@ -5377,7 +5853,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       }
       lights[currentLight] = {
         ...lights[currentLight],
-        color: convertColor(spotLight),
+        color: convertColor(spotLight, useByteColors),
         position: spotLight.position,
         direction: spotLight.direction,
         attenuation: spotLight.attenuation || [1, 0, 0],
@@ -5392,7 +5868,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       }
       lights[currentLight] = {
         ...lights[currentLight],
-        color: convertColor(directionalLight),
+        color: convertColor(directionalLight, useByteColors),
         direction: directionalLight.direction
       };
       currentLight++;
@@ -5402,7 +5878,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       import_core3.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
     }
     return {
-      ambientColor: convertColor(ambientLight),
+      ambientColor: convertColor(ambientLight, useByteColors),
       directionalLightCount,
       pointLightCount,
       spotLightCount,
@@ -5430,9 +5906,10 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     }
     return lightSources;
   }
-  function convertColor(colorDef = {}) {
+  function convertColor(colorDef = {}, useByteColors) {
     const { color = [0, 0, 0], intensity = 1 } = colorDef;
-    return color.map((component) => component * intensity / COLOR_FACTOR);
+    const normalizedColor = normalizeByteColor3(color, resolveUseByteColors(useByteColors, true));
+    return normalizedColor.map((component) => component * intensity);
   }
   function createDefaultLightingUniforms() {
     return {
@@ -5500,8 +5977,7 @@ uniform sampler2D pbr_brdfLUT;
   // src/modules/lighting/no-material/dirlight.ts
   var SOURCE_WGSL = (
     /* WGSL */
-    `  
-struct dirlightUniforms {
+    `struct dirlightUniforms {
   lightDirection: vec3<f32>,
 };
 
@@ -5539,7 +6015,7 @@ void dirlight_setNormal(vec3 normal) {
   );
   var FS_GLSL = (
     /* glsl */
-    `uniform dirlightUniforms {
+    `layout(std140) uniform dirlightUniforms {
   vec3 lightDirection;
 } dirlight;
 
@@ -5660,7 +6136,7 @@ fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, p
   // src/modules/lighting/lambert-material/lambert-shaders-glsl.ts
   var LAMBERT_VS = (
     /* glsl */
-    `uniform lambertMaterialUniforms {
+    `layout(std140) uniform lambertMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
@@ -5669,7 +6145,7 @@ fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, p
   );
   var LAMBERT_FS = (
     /* glsl */
-    `uniform lambertMaterialUniforms {
+    `layout(std140) uniform lambertMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
@@ -5749,7 +6225,7 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
   // src/modules/lighting/phong-material/phong-shaders-glsl.ts
   var PHONG_VS = (
     /* glsl */
-    `uniform phongMaterialUniforms {
+    `layout(std140) uniform phongMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
@@ -5760,7 +6236,7 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
   );
   var PHONG_FS = (
     /* glsl */
-    `uniform phongMaterialUniforms {
+    `layout(std140) uniform phongMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
@@ -5964,19 +6440,24 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       ambient: "f32",
       diffuse: "f32",
       shininess: "f32",
-      specularColor: "vec3<f32>"
+      specularColor: "vec3<f32>",
+      useByteColors: "i32"
     },
     defaultUniforms: {
       unlit: false,
       ambient: 0.35,
       diffuse: 0.6,
       shininess: 32,
-      specularColor: [0.15, 0.15, 0.15]
+      specularColor: [0.15, 0.15, 0.15],
+      useByteColors: true
     },
     getUniforms(props) {
       const uniforms = { ...props };
       if (uniforms.specularColor) {
-        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+        uniforms.specularColor = normalizeByteColor3(
+          uniforms.specularColor,
+          resolveUseByteColors(uniforms.useByteColors, true)
+        );
       }
       return { ...gouraudMaterial.defaultUniforms, ...uniforms };
     }
@@ -6000,19 +6481,24 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       ambient: "f32",
       diffuse: "f32",
       shininess: "f32",
-      specularColor: "vec3<f32>"
+      specularColor: "vec3<f32>",
+      useByteColors: "i32"
     },
     defaultUniforms: {
       unlit: false,
       ambient: 0.35,
       diffuse: 0.6,
       shininess: 32,
-      specularColor: [0.15, 0.15, 0.15]
+      specularColor: [0.15, 0.15, 0.15],
+      useByteColors: true
     },
     getUniforms(props) {
       const uniforms = { ...props };
       if (uniforms.specularColor) {
-        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+        uniforms.specularColor = normalizeByteColor3(
+          uniforms.specularColor,
+          resolveUseByteColors(uniforms.useByteColors, true)
+        );
       }
       return { ...phongMaterial.defaultUniforms, ...uniforms };
     }
@@ -6022,7 +6508,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
@@ -6032,7 +6519,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;
@@ -6049,10 +6542,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;
 }
 `
   );
@@ -6060,7 +6555,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
     /* glsl */
     `precision highp float;
 
-uniform pbrMaterialUniforms {
+layout(std140) uniform pbrMaterialUniforms {
   // Material is unlit
   bool unlit;
 
@@ -6128,6 +6623,41 @@ 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
@@ -6185,7 +6715,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
@@ -6235,14 +6766,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
@@ -6263,16 +6800,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);
@@ -6281,10 +6818,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
@@ -6572,9 +7109,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
@@ -6601,14 +7190,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
@@ -6709,7 +7298,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
@@ -6717,7 +7306,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;
@@ -6734,55 +7323,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);
@@ -6790,7 +7379,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);
@@ -6803,7 +7392,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
 
@@ -6811,7 +7400,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) {
@@ -6974,7 +7563,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
@@ -6982,7 +7571,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;
@@ -7020,14 +7609,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;
@@ -7037,7 +7633,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);
@@ -7050,7 +7647,7 @@ fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f
 #endif
 
 #ifdef HAS_UV
-  fragmentInputs.pbr_vUV = uv;
+  fragmentInputs.pbr_vUV0 = uv0;
 #endif
 }
 
@@ -7122,6 +7719,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;
@@ -7235,13 +7867,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);
@@ -7264,14 +7905,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);
@@ -7280,21 +7922,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;
@@ -7599,11 +8243,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
 
@@ -7630,15 +8325,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;
@@ -7743,8 +8438,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
@@ -7753,7 +8447,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
@@ -7774,7 +8468,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       specularIntensity *= textureSample(
         pbr_specularIntensitySampler,
         pbr_specularIntensitySamplerSampler,
-        fragmentInputs.pbr_vUV
+        specularIntensityUV
       ).a;
     }
     #endif
@@ -7786,7 +8480,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
         textureSample(
           pbr_specularColorSampler,
           pbr_specularColorSamplerSampler,
-          fragmentInputs.pbr_vUV
+          specularColorUV
         )
       ).rgb;
     }
@@ -7798,7 +8492,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       transmission *= textureSample(
         pbr_transmissionSampler,
         pbr_transmissionSamplerSampler,
-        fragmentInputs.pbr_vUV
+        transmissionUV
       ).r;
     }
     #endif
@@ -7808,7 +8502,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     thickness *= textureSample(
       pbr_thicknessSampler,
       pbr_thicknessSamplerSampler,
-      fragmentInputs.pbr_vUV
+      thicknessUV
     ).g;
     #endif
 
@@ -7819,7 +8513,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       clearcoatFactor *= textureSample(
         pbr_clearcoatSampler,
         pbr_clearcoatSamplerSampler,
-        fragmentInputs.pbr_vUV
+        clearcoatUV
       ).r;
     }
     #endif
@@ -7828,13 +8522,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;
@@ -7844,7 +8538,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
         textureSample(
           pbr_sheenColorSampler,
           pbr_sheenColorSamplerSampler,
-          fragmentInputs.pbr_vUV
+          sheenColorUV
         )
       ).rgb;
     }
@@ -7854,7 +8548,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       sheenRoughness *= textureSample(
         pbr_sheenRoughnessSampler,
         pbr_sheenRoughnessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        sheenRoughnessUV
       ).a;
     }
     #endif
@@ -7866,7 +8560,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       iridescence *= textureSample(
         pbr_iridescenceSampler,
         pbr_iridescenceSamplerSampler,
-        fragmentInputs.pbr_vUV
+        iridescenceUV
       ).r;
     }
     #endif
@@ -7883,7 +8577,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       textureSample(
         pbr_iridescenceThicknessSampler,
         pbr_iridescenceThicknessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        iridescenceThicknessUV
       ).g
     );
     #endif
@@ -7895,7 +8589,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;
@@ -8062,8 +8756,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
@@ -8072,7 +8765,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
@@ -8108,7 +8801,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   // src/modules/lighting/pbr-material/pbr-projection.ts
   var uniformBlock = (
     /* glsl */
-    `uniform pbrProjectionUniforms {
+    `layout(std140) uniform pbrProjectionUniforms {
   mat4 modelViewProjectionMatrix;
   mat4 modelMatrix;
   mat4 normalMatrix;
@@ -8192,7 +8885,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,
@@ -8299,7 +9026,110 @@ 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>"
+    }
+  };
+
+  // src/modules/lighting/pbr-material/pbr-scene.ts
+  var IDENTITY_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+  var uniformBlock2 = (
+    /* glsl */
+    `layout(std140) uniform pbrSceneUniforms {
+  float exposure;
+  int toneMapMode;
+  float environmentIntensity;
+  float environmentRotation;
+  vec2 framebufferSize;
+  mat4 viewMatrix;
+  mat4 projectionMatrix;
+} pbrScene;
+
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+uniform sampler2D pbr_transmissionFramebufferSampler;
+#endif
+`
+  );
+  var wgslUniformBlock2 = (
+    /* wgsl */
+    `struct pbrSceneUniforms {
+  exposure: f32,
+  toneMapMode: i32,
+  environmentIntensity: f32,
+  environmentRotation: f32,
+  framebufferSize: vec2<f32>,
+  viewMatrix: mat4x4<f32>,
+  projectionMatrix: mat4x4<f32>
+};
+
+@group(1) @binding(auto) var<uniform> pbrScene: pbrSceneUniforms;
+
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+@group(1) @binding(auto) var pbr_transmissionFramebufferSampler: texture_2d<f32>;
+@group(1) @binding(auto) var pbr_transmissionFramebufferSamplerSampler: sampler;
+#endif
+`
+  );
+  var pbrScene = {
+    name: "pbrScene",
+    bindingLayout: [
+      { name: "pbrScene", group: 1 },
+      { name: "pbr_transmissionFramebufferSampler", group: 1 }
+    ],
+    source: wgslUniformBlock2,
+    vs: uniformBlock2,
+    fs: uniformBlock2,
+    getUniforms: (props) => props,
+    uniformTypes: {
+      exposure: "f32",
+      toneMapMode: "i32",
+      environmentIntensity: "f32",
+      environmentRotation: "f32",
+      framebufferSize: "vec2<f32>",
+      viewMatrix: "mat4x4<f32>",
+      projectionMatrix: "mat4x4<f32>"
+    },
+    defaultUniforms: {
+      exposure: 1,
+      toneMapMode: 2,
+      environmentIntensity: 1,
+      environmentRotation: Math.PI * 0.5,
+      framebufferSize: [1, 1],
+      viewMatrix: IDENTITY_MATRIX2,
+      projectionMatrix: IDENTITY_MATRIX2
     }
   };
   return __toCommonJS(bundle_exports);