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

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(dist_exports, {
   combineInjects: () => combineInjects,
   convertToVec4: () => convertToVec4,
   dirlight: () => dirlight,
+  floatColors: () => floatColors,
   fp32: () => fp32,
   fp64: () => fp64,
   fp64LowPart: () => fp64LowPart,
@@ -42,6 +43,7 @@ __export(dist_exports, {
   fp64ifyMatrix4: () => fp64ifyMatrix4,
   fromHalfFloat: () => fromHalfFloat,
   generateShaderForModule: () => generateShaderForModule,
+  getGLSLUniformBlocks: () => getGLSLUniformBlocks,
   getPassthroughFS: () => getPassthroughFS,
   getQualifierDetails: () => getQualifierDetails,
   getShaderInfo: () => getShaderInfo,
@@ -57,16 +59,21 @@ __export(dist_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
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -386,6 +393,8 @@ function resolveModules(modules) {
 }
 
 // dist/lib/shader-module/shader-module-uniform-layout.js
+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(module2) {
   return `${module2.name}Uniforms`;
 }
@@ -428,6 +437,39 @@ function validateShaderModuleUniformLayout(module2, stage, options = {}) {
   }
   return validationResult;
 }
+function getGLSLUniformBlocks(shaderSource) {
+  var _a;
+  const blocks = [];
+  const uncommentedSource = stripShaderComments(shaderSource);
+  for (const sourceMatch of uncommentedSource.matchAll(GLSL_UNIFORM_BLOCK_REGEXP)) {
+    const layoutQualifier = ((_a = sourceMatch[1]) == null ? void 0 : _a.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) {
+  var _a;
+  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 == null ? void 0 : 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.`;
+    (_a = log2 == null ? void 0 : log2.warn) == null ? void 0 : _a.call(log2, message, block)();
+  }
+  return nonStd140Blocks;
+}
 function extractShaderUniformBlockFieldNames(shaderSource, language, uniformBlockName) {
   const sourceBody = language === "wgsl" ? extractWGSLStructBody(shaderSource, uniformBlockName) : extractGLSLUniformBlockBody(shaderSource, uniformBlockName);
   if (!sourceBody) {
@@ -439,7 +481,7 @@ function extractShaderUniformBlockFieldNames(shaderSource, language, uniformBloc
     if (!line || line.startsWith("#")) {
       continue;
     }
-    const fieldMatch = language === "wgsl" ? line.match(/^([A-Za-z0-9_]+)\s*:/) : line.match(/^(?:uniform\s+)?[A-Za-z0-9_]+(?:<[^>]+>)?\s+([A-Za-z0-9_]+)(?:\s*\[[^\]]+\])?\s*;/);
+    const fieldMatch = language === "wgsl" ? line.match(/^([A-Za-z0-9_]+)\s*:/) : line.match(GLSL_UNIFORM_BLOCK_FIELD_REGEXP);
     if (fieldMatch) {
       fieldNames.push(fieldMatch[1]);
     }
@@ -473,8 +515,8 @@ function extractWGSLStructBody(shaderSource, uniformBlockName) {
   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"));
-  return (sourceMatch == null ? void 0 : sourceMatch[1]) || null;
+  const block = getGLSLUniformBlocks(shaderSource).find((candidate) => candidate.blockName === uniformBlockName);
+  return (block == null ? void 0 : block.body) || null;
 }
 function areStringArraysEqual(leftValues, rightValues) {
   if (leftValues.length !== rightValues.length) {
@@ -488,9 +530,55 @@ function areStringArraysEqual(leftValues, rightValues) {
   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)`;
 }
 
 // dist/lib/shader-assembly/platform-defines.js
@@ -678,13 +766,158 @@ function getShaderVersion(source4) {
   return version;
 }
 
+// dist/lib/shader-assembly/wgsl-binding-scan.js
+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) {
+  var _a;
+  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: (_a = match[3]) == null ? void 0 : _a.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");
+}
+
 // dist/lib/shader-assembly/wgsl-binding-debug.js
 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 = []) {
   var _a;
+  const maskedSource = maskWGSLComments(source4);
   const assignmentMap = /* @__PURE__ */ new Map();
   for (const bindingAssignment of bindingAssignments) {
     assignmentMap.set(getBindingAssignmentKey(bindingAssignment.name, bindingAssignment.group, bindingAssignment.location), bindingAssignment.moduleName);
@@ -693,7 +926,8 @@ function getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments = []) {
   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]);
@@ -710,6 +944,7 @@ function getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments = []) {
         accessDeclaration,
         resourceType
       }));
+      match = regex.exec(maskedSource);
     }
   }
   return rows.sort((left, right) => {
@@ -821,14 +1056,6 @@ var INJECT_SHADER_DECLARATIONS = `
 
 ${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 */
@@ -909,7 +1136,8 @@ function assembleShaderWGSL(platformInfo, options) {
     }
   }
   const modulesToInject = modules;
-  const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(coreSource);
+  const applicationRelocation = relocateWGSLApplicationBindings(coreSource);
+  const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(applicationRelocation.source);
   const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(modulesToInject, options._bindingRegistry, usedBindingsByGroup);
   const bindingAssignments = [];
   for (const module2 of modulesToInject) {
@@ -942,7 +1170,7 @@ function assembleShaderWGSL(platformInfo, options) {
   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 };
@@ -1034,6 +1262,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) {
@@ -1091,44 +1322,57 @@ function getShaderModuleSource(module2, stage, log2) {
 }
 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, module2, context) {
   const bindingAssignments = [];
+  const declarationMatches = getWGSLBindingDeclarationMatches(moduleSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES);
   const relocationState = {
-    sawSupportedBindingDeclaration: false,
+    sawSupportedBindingDeclaration: declarationMatches.length > 0,
     nextHintedBindingLocation: typeof module2.firstBindingSlot === "number" ? module2.firstBindingSlot : null
   };
-  let relocatedSource = relocateWGSLModuleBindingsWithRegex(moduleSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES[0], { isBindingFirst: true, module: module2, context, bindingAssignments, relocationState });
-  relocatedSource = relocateWGSLModuleBindingsWithRegex(relocatedSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES[1], { isBindingFirst: false, module: module2, context, bindingAssignments, relocationState });
-  if (moduleSource.includes("@binding(auto)") && !relocationState.sawSupportedBindingDeclaration) {
-    throw new Error(`Unsupported @binding(auto) declaration form in module "${module2.name}". Use "@group(N) @binding(auto) var ..." or "@binding(auto) @group(N) var ..." on a single line.`);
+  const relocatedSource = replaceWGSLBindingDeclarationMatches(moduleSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES, (declarationMatch) => relocateWGSLModuleBindingMatch(declarationMatch, {
+    module: module2,
+    context,
+    bindingAssignments,
+    relocationState
+  }));
+  if (hasWGSLAutoBinding(moduleSource) && !relocationState.sawSupportedBindingDeclaration) {
+    throw new Error(`Unsupported @binding(auto) declaration form in module "${module2.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) {
+function relocateWGSLModuleBindingMatch(declarationMatch, params) {
   var _a, _b;
-  const { isBindingFirst, module: module2, 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];
+  const { module: module2, context, bindingAssignments, relocationState } = params;
+  const { match, bindingToken, groupToken, name } = declarationMatch;
   const group = Number(groupToken);
   if (bindingToken === "auto") {
     const registryKey = getBindingRegistryKey(group, module2.name, name);
@@ -1153,6 +1397,18 @@ function relocateWGSLModuleBindingMatch(replaceArguments, params) {
   bindingAssignments.push({ moduleName: module2.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) {
@@ -1193,16 +1449,11 @@ function claimReservedBindingLocation(reservedBindingKeysByGroup, group, locatio
 function getModuleWGSLBindingDeclarations(module2) {
   const declarations = [];
   const moduleSource = module2.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;
 }
@@ -1232,10 +1483,27 @@ function allocateAutoBindingLocation(group, usedBindingsByGroup, preferredBindin
   }
   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) {
@@ -1252,6 +1520,24 @@ function formatWGSLBindingAssignmentComments(bindingAssignments) {
 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();
+}
 
 // dist/lib/preprocessor/preprocessor.js
 var DEFINE_NAME_PATTERN = "([a-zA-Z_][a-zA-Z0-9_]*)";
@@ -1533,7 +1819,7 @@ function generateGLSLUniformDeclarations(module2, options) {
   switch (options.uniforms) {
     case "scoped-interface-blocks":
     case "unscoped-interface-blocks":
-      glsl.push(`uniform ${capitalize(module2.name)} {`);
+      glsl.push(`layout(std140) uniform ${capitalize(module2.name)} {`);
       break;
     case "uniforms":
   }
@@ -1730,6 +2016,28 @@ function fp64ifyMatrix4(matrix) {
   return matrixFP64;
 }
 
+// dist/lib/color/normalize-byte-colors.js
+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
+  ];
+}
+
 // dist/modules/math/random/random.js
 var source = (
   /* wgsl */
@@ -1916,7 +2224,7 @@ var fp32 = {
 var fp64arithmeticShader = (
   /* glsl */
   `
-uniform fp64arithmeticUniforms {
+layout(std140) uniform fp64arithmeticUniforms {
   uniform float ONE;
   uniform float SPLIT;
 } fp64;
@@ -3034,15 +3342,99 @@ var fp64 = {
   fp64ifyMatrix4
 };
 
+// dist/modules/color/float-colors.js
+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
+  }
+};
+
 // dist/modules/engine/picking/picking.js
 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;
@@ -3051,12 +3443,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) {
@@ -3113,11 +3505,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;
@@ -3179,7 +3571,7 @@ var picking = {
     isActive: "f32",
     isAttribute: "f32",
     isHighlightActive: "f32",
-    useFloatColors: "f32",
+    useByteColors: "f32",
     highlightedObjectColor: "vec3<f32>",
     highlightColor: "vec4<f32>"
   },
@@ -3187,7 +3579,7 @@ var picking = {
     isActive: false,
     isAttribute: false,
     isHighlightActive: false,
-    useFloatColors: true,
+    useByteColors: true,
     highlightedObjectColor: [0, 0, 0],
     highlightColor: DEFAULT_HIGHLIGHT_COLOR
   },
@@ -3197,6 +3589,7 @@ var picking = {
 };
 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;
@@ -3206,18 +3599,14 @@ function getUniforms(opts = {}, prevUniforms) {
     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;
 }
@@ -3245,7 +3634,7 @@ fn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {
 var vs2 = (
   /* glsl */
   `
-uniform skinUniforms {
+layout(std140) uniform skinUniforms {
   mat4 jointMatrix[SKIN_MAX_JOINTS];
 } skin;
 
@@ -3354,7 +3743,7 @@ struct UniformLight {
   vec2 coneCos;
 };
 
-uniform lightingUniforms {
+layout(std140) uniform lightingUniforms {
   int enabled;
   int directionalLightCount;
   int pointLightCount;
@@ -3490,7 +3879,6 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
 
 // dist/modules/lighting/lights/lighting.js
 var MAX_LIGHTS = 5;
-var COLOR_FACTOR = 255;
 var LIGHT_UNIFORM_TYPE = {
   color: "vec3<f32>",
   position: "vec3<f32>",
@@ -3529,7 +3917,7 @@ function getUniforms2(props, _prevUniforms = {}) {
   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 {
@@ -3539,14 +3927,20 @@ function getUniforms2(props, _prevUniforms = {}) {
   }
   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;
   }
   return uniforms;
 }
-function getLightSourceUniforms({ ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
+function getLightSourceUniforms({ useByteColors, ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
   const lights = createDefaultLightUniforms();
   let currentLight = 0;
   let pointLightCount = 0;
@@ -3558,7 +3952,7 @@ function getLightSourceUniforms({ ambientLight, pointLights = [], spotLights = [
     }
     lights[currentLight] = {
       ...lights[currentLight],
-      color: convertColor(pointLight),
+      color: convertColor(pointLight, useByteColors),
       position: pointLight.position,
       attenuation: pointLight.attenuation || [1, 0, 0]
     };
@@ -3571,7 +3965,7 @@ function getLightSourceUniforms({ ambientLight, pointLights = [], spotLights = [
     }
     lights[currentLight] = {
       ...lights[currentLight],
-      color: convertColor(spotLight),
+      color: convertColor(spotLight, useByteColors),
       position: spotLight.position,
       direction: spotLight.direction,
       attenuation: spotLight.attenuation || [1, 0, 0],
@@ -3586,7 +3980,7 @@ function getLightSourceUniforms({ ambientLight, pointLights = [], spotLights = [
     }
     lights[currentLight] = {
       ...lights[currentLight],
-      color: convertColor(directionalLight),
+      color: convertColor(directionalLight, useByteColors),
       direction: directionalLight.direction
     };
     currentLight++;
@@ -3596,7 +3990,7 @@ function getLightSourceUniforms({ ambientLight, pointLights = [], spotLights = [
     import_core3.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
   }
   return {
-    ambientColor: convertColor(ambientLight),
+    ambientColor: convertColor(ambientLight, useByteColors),
     directionalLightCount,
     pointLightCount,
     spotLightCount,
@@ -3625,9 +4019,10 @@ function extractLightTypes(lights) {
   }
   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 {
@@ -3695,8 +4090,7 @@ var ibl = {
 // dist/modules/lighting/no-material/dirlight.js
 var SOURCE_WGSL = (
   /* WGSL */
-  `  
-struct dirlightUniforms {
+  `struct dirlightUniforms {
   lightDirection: vec3<f32>,
 };
 
@@ -3734,7 +4128,7 @@ void dirlight_setNormal(vec3 normal) {
 );
 var FS_GLSL = (
   /* glsl */
-  `uniform dirlightUniforms {
+  `layout(std140) uniform dirlightUniforms {
   vec3 lightDirection;
 } dirlight;
 
@@ -3855,7 +4249,7 @@ fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, p
 // dist/modules/lighting/lambert-material/lambert-shaders-glsl.js
 var LAMBERT_VS = (
   /* glsl */
-  `uniform lambertMaterialUniforms {
+  `layout(std140) uniform lambertMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
@@ -3864,7 +4258,7 @@ var LAMBERT_VS = (
 );
 var LAMBERT_FS = (
   /* glsl */
-  `uniform lambertMaterialUniforms {
+  `layout(std140) uniform lambertMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
@@ -3944,7 +4338,7 @@ var lambertMaterial = {
 // dist/modules/lighting/phong-material/phong-shaders-glsl.js
 var PHONG_VS = (
   /* glsl */
-  `uniform phongMaterialUniforms {
+  `layout(std140) uniform phongMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
@@ -3955,7 +4349,7 @@ var PHONG_VS = (
 );
 var PHONG_FS = (
   /* glsl */
-  `uniform phongMaterialUniforms {
+  `layout(std140) uniform phongMaterialUniforms {
   uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
@@ -4159,19 +4553,21 @@ var gouraudMaterial = {
     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 };
   }
@@ -4195,19 +4591,21 @@ var phongMaterial = {
     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 };
   }
@@ -4217,7 +4615,8 @@ var phongMaterial = {
 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
@@ -4227,7 +4626,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;
@@ -4244,10 +4649,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;
 }
 `
 );
@@ -4255,7 +4662,7 @@ var fs4 = (
   /* glsl */
   `precision highp float;
 
-uniform pbrMaterialUniforms {
+layout(std140) uniform pbrMaterialUniforms {
   // Material is unlit
   bool unlit;
 
@@ -4323,6 +4730,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
@@ -4380,7 +4822,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
@@ -4430,14 +4873,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
@@ -4458,16 +4907,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);
@@ -4476,10 +4925,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
@@ -4767,9 +5216,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
@@ -4796,14 +5297,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
@@ -4904,7 +5405,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
@@ -4912,7 +5413,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;
@@ -4929,55 +5430,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);
@@ -4985,7 +5486,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);
@@ -4998,7 +5499,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
 
@@ -5006,7 +5507,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) {
@@ -5169,7 +5670,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
@@ -5177,7 +5678,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;
@@ -5215,14 +5716,21 @@ var source3 = (
   /* 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;
@@ -5232,7 +5740,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);
@@ -5245,7 +5754,7 @@ fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f
 #endif
 
 #ifdef HAS_UV
-  fragmentInputs.pbr_vUV = uv;
+  fragmentInputs.pbr_vUV0 = uv0;
 #endif
 }
 
@@ -5317,6 +5826,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;
@@ -5430,13 +5974,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);
@@ -5459,14 +6012,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);
@@ -5475,21 +6029,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;
@@ -5794,11 +6350,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
 
@@ -5825,15 +6432,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;
@@ -5938,8 +6545,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
@@ -5948,7 +6554,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
@@ -5969,7 +6575,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       specularIntensity *= textureSample(
         pbr_specularIntensitySampler,
         pbr_specularIntensitySamplerSampler,
-        fragmentInputs.pbr_vUV
+        specularIntensityUV
       ).a;
     }
     #endif
@@ -5981,7 +6587,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
         textureSample(
           pbr_specularColorSampler,
           pbr_specularColorSamplerSampler,
-          fragmentInputs.pbr_vUV
+          specularColorUV
         )
       ).rgb;
     }
@@ -5993,7 +6599,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       transmission *= textureSample(
         pbr_transmissionSampler,
         pbr_transmissionSamplerSampler,
-        fragmentInputs.pbr_vUV
+        transmissionUV
       ).r;
     }
     #endif
@@ -6003,7 +6609,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     thickness *= textureSample(
       pbr_thicknessSampler,
       pbr_thicknessSamplerSampler,
-      fragmentInputs.pbr_vUV
+      thicknessUV
     ).g;
     #endif
 
@@ -6014,7 +6620,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       clearcoatFactor *= textureSample(
         pbr_clearcoatSampler,
         pbr_clearcoatSamplerSampler,
-        fragmentInputs.pbr_vUV
+        clearcoatUV
       ).r;
     }
     #endif
@@ -6023,13 +6629,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;
@@ -6039,7 +6645,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
         textureSample(
           pbr_sheenColorSampler,
           pbr_sheenColorSamplerSampler,
-          fragmentInputs.pbr_vUV
+          sheenColorUV
         )
       ).rgb;
     }
@@ -6049,7 +6655,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       sheenRoughness *= textureSample(
         pbr_sheenRoughnessSampler,
         pbr_sheenRoughnessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        sheenRoughnessUV
       ).a;
     }
     #endif
@@ -6061,7 +6667,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       iridescence *= textureSample(
         pbr_iridescenceSampler,
         pbr_iridescenceSamplerSampler,
-        fragmentInputs.pbr_vUV
+        iridescenceUV
       ).r;
     }
     #endif
@@ -6078,7 +6684,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       textureSample(
         pbr_iridescenceThicknessSampler,
         pbr_iridescenceThicknessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        iridescenceThicknessUV
       ).g
     );
     #endif
@@ -6090,7 +6696,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;
@@ -6257,8 +6863,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
@@ -6267,7 +6872,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
@@ -6303,7 +6908,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
 // dist/modules/lighting/pbr-material/pbr-projection.js
 var uniformBlock = (
   /* glsl */
-  `uniform pbrProjectionUniforms {
+  `layout(std140) uniform pbrProjectionUniforms {
   mat4 modelViewProjectionMatrix;
   mat4 modelMatrix;
   mat4 normalMatrix;
@@ -6387,7 +6992,41 @@ var pbrMaterial = {
     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,
@@ -6494,7 +7133,110 @@ var pbrMaterial = {
     // 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>"
+  }
+};
+
+// dist/modules/lighting/pbr-material/pbr-scene.js
+var IDENTITY_MATRIX = [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_MATRIX,
+    projectionMatrix: IDENTITY_MATRIX
   }
 };
 //# sourceMappingURL=index.cjs.map