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

package/dist/index.cjs

@@ -47,10 +47,15 @@ __export(dist_exports, {
   getShaderInfo: () => getShaderInfo,
   getShaderModuleDependencies: () => getShaderModuleDependencies,
   getShaderModuleSource: () => getShaderModuleSource,
+  getShaderModuleUniformBlockFields: () => getShaderModuleUniformBlockFields,
+  getShaderModuleUniformBlockName: () => getShaderModuleUniformBlockName,
+  getShaderModuleUniformLayoutValidationResult: () => getShaderModuleUniformLayoutValidationResult,
   getShaderModuleUniforms: () => getShaderModuleUniforms,
   gouraudMaterial: () => gouraudMaterial,
+  ibl: () => ibl,
   initializeShaderModule: () => initializeShaderModule,
   initializeShaderModules: () => initializeShaderModules,
+  lambertMaterial: () => lambertMaterial,
   lighting: () => lighting,
   pbrMaterial: () => pbrMaterial,
   phongMaterial: () => phongMaterial,
@@ -60,7 +65,8 @@ __export(dist_exports, {
   skin: () => skin,
   toHalfFloat: () => toHalfFloat,
   typeToChannelCount: () => typeToChannelCount,
-  typeToChannelSuffix: () => typeToChannelSuffix
+  typeToChannelSuffix: () => typeToChannelSuffix,
+  validateShaderModuleUniformLayout: () => validateShaderModuleUniformLayout
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -379,6 +385,114 @@ function resolveModules(modules) {
   return getShaderDependencies(modules);
 }
 
+// dist/lib/shader-module/shader-module-uniform-layout.js
+function getShaderModuleUniformBlockName(module2) {
+  return `${module2.name}Uniforms`;
+}
+function getShaderModuleUniformBlockFields(module2, stage) {
+  const shaderSource = stage === "wgsl" ? module2.source : stage === "vertex" ? module2.vs : module2.fs;
+  if (!shaderSource) {
+    return null;
+  }
+  const uniformBlockName = getShaderModuleUniformBlockName(module2);
+  return extractShaderUniformBlockFieldNames(shaderSource, stage === "wgsl" ? "wgsl" : "glsl", uniformBlockName);
+}
+function getShaderModuleUniformLayoutValidationResult(module2, stage) {
+  const expectedUniformNames = Object.keys(module2.uniformTypes || {});
+  if (!expectedUniformNames.length) {
+    return null;
+  }
+  const actualUniformNames = getShaderModuleUniformBlockFields(module2, stage);
+  if (!actualUniformNames) {
+    return null;
+  }
+  return {
+    moduleName: module2.name,
+    uniformBlockName: getShaderModuleUniformBlockName(module2),
+    stage,
+    expectedUniformNames,
+    actualUniformNames,
+    matches: areStringArraysEqual(expectedUniformNames, actualUniformNames)
+  };
+}
+function validateShaderModuleUniformLayout(module2, stage, options = {}) {
+  var _a, _b;
+  const validationResult = getShaderModuleUniformLayoutValidationResult(module2, stage);
+  if (!validationResult || validationResult.matches) {
+    return validationResult;
+  }
+  const message = formatShaderModuleUniformLayoutError(validationResult);
+  (_b = (_a = options.log) == null ? void 0 : _a.error) == null ? void 0 : _b.call(_a, message, validationResult)();
+  if (options.throwOnError !== false) {
+    assert(false, message);
+  }
+  return validationResult;
+}
+function extractShaderUniformBlockFieldNames(shaderSource, language, uniformBlockName) {
+  const sourceBody = language === "wgsl" ? extractWGSLStructBody(shaderSource, uniformBlockName) : extractGLSLUniformBlockBody(shaderSource, uniformBlockName);
+  if (!sourceBody) {
+    return null;
+  }
+  const fieldNames = [];
+  for (const sourceLine of sourceBody.split("\n")) {
+    const line = sourceLine.replace(/\/\/.*$/, "").trim();
+    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*;/);
+    if (fieldMatch) {
+      fieldNames.push(fieldMatch[1]);
+    }
+  }
+  return fieldNames;
+}
+function extractWGSLStructBody(shaderSource, uniformBlockName) {
+  const structMatch = new RegExp(`\\bstruct\\s+${uniformBlockName}\\b`, "m").exec(shaderSource);
+  if (!structMatch) {
+    return null;
+  }
+  const openBraceIndex = shaderSource.indexOf("{", structMatch.index);
+  if (openBraceIndex < 0) {
+    return null;
+  }
+  let braceDepth = 0;
+  for (let index = openBraceIndex; index < shaderSource.length; index++) {
+    const character = shaderSource[index];
+    if (character === "{") {
+      braceDepth++;
+      continue;
+    }
+    if (character !== "}") {
+      continue;
+    }
+    braceDepth--;
+    if (braceDepth === 0) {
+      return shaderSource.slice(openBraceIndex + 1, index);
+    }
+  }
+  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;
+}
+function areStringArraysEqual(leftValues, rightValues) {
+  if (leftValues.length !== rightValues.length) {
+    return false;
+  }
+  for (let valueIndex = 0; valueIndex < leftValues.length; valueIndex++) {
+    if (leftValues[valueIndex] !== rightValues[valueIndex]) {
+      return false;
+    }
+  }
+  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(", ")}`;
+}
+
 // dist/lib/shader-assembly/platform-defines.js
 function getPlatformShaderDefines(platformInfo) {
   switch (platformInfo == null ? void 0 : platformInfo.gpu.toLowerCase()) {
@@ -564,11 +678,158 @@ function getShaderVersion(source4) {
   return version;
 }
 
+// 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
+];
+function getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments = []) {
+  var _a;
+  const assignmentMap = /* @__PURE__ */ new Map();
+  for (const bindingAssignment of bindingAssignments) {
+    assignmentMap.set(getBindingAssignmentKey(bindingAssignment.name, bindingAssignment.group, bindingAssignment.location), bindingAssignment.moduleName);
+  }
+  const rows = [];
+  for (const regex of WGSL_BINDING_DEBUG_REGEXES) {
+    regex.lastIndex = 0;
+    let match;
+    while (match = regex.exec(source4)) {
+      const isBindingFirst = regex === WGSL_BINDING_DEBUG_REGEXES[0];
+      const binding = Number(match[isBindingFirst ? 1 : 2]);
+      const group = Number(match[isBindingFirst ? 2 : 1]);
+      const accessDeclaration = (_a = match[3]) == null ? void 0 : _a.trim();
+      const name = match[4];
+      const resourceType = match[5].trim();
+      const moduleName = assignmentMap.get(getBindingAssignmentKey(name, group, binding));
+      rows.push(normalizeShaderBindingDebugRow({
+        name,
+        group,
+        binding,
+        owner: moduleName ? "module" : "application",
+        moduleName,
+        accessDeclaration,
+        resourceType
+      }));
+    }
+  }
+  return rows.sort((left, right) => {
+    if (left.group !== right.group) {
+      return left.group - right.group;
+    }
+    if (left.binding !== right.binding) {
+      return left.binding - right.binding;
+    }
+    return left.name.localeCompare(right.name);
+  });
+}
+function normalizeShaderBindingDebugRow(row) {
+  const baseRow = {
+    name: row.name,
+    group: row.group,
+    binding: row.binding,
+    owner: row.owner,
+    kind: "unknown",
+    moduleName: row.moduleName,
+    resourceType: row.resourceType
+  };
+  if (row.accessDeclaration) {
+    const access = row.accessDeclaration.split(",").map((value) => value.trim());
+    if (access[0] === "uniform") {
+      return { ...baseRow, kind: "uniform", access: "uniform" };
+    }
+    if (access[0] === "storage") {
+      const storageAccess = access[1] || "read_write";
+      return {
+        ...baseRow,
+        kind: storageAccess === "read" ? "read-only-storage" : "storage",
+        access: storageAccess
+      };
+    }
+  }
+  if (row.resourceType === "sampler" || row.resourceType === "sampler_comparison") {
+    return {
+      ...baseRow,
+      kind: "sampler",
+      samplerKind: row.resourceType === "sampler_comparison" ? "comparison" : "filtering"
+    };
+  }
+  if (row.resourceType.startsWith("texture_storage_")) {
+    return {
+      ...baseRow,
+      kind: "storage-texture",
+      access: getStorageTextureAccess(row.resourceType),
+      viewDimension: getTextureViewDimension(row.resourceType)
+    };
+  }
+  if (row.resourceType.startsWith("texture_")) {
+    return {
+      ...baseRow,
+      kind: "texture",
+      viewDimension: getTextureViewDimension(row.resourceType),
+      sampleType: getTextureSampleType(row.resourceType),
+      multisampled: row.resourceType.startsWith("texture_multisampled_")
+    };
+  }
+  return baseRow;
+}
+function getBindingAssignmentKey(name, group, binding) {
+  return `${group}:${binding}:${name}`;
+}
+function getTextureViewDimension(resourceType) {
+  if (resourceType.includes("cube_array")) {
+    return "cube-array";
+  }
+  if (resourceType.includes("2d_array")) {
+    return "2d-array";
+  }
+  if (resourceType.includes("cube")) {
+    return "cube";
+  }
+  if (resourceType.includes("3d")) {
+    return "3d";
+  }
+  if (resourceType.includes("2d")) {
+    return "2d";
+  }
+  if (resourceType.includes("1d")) {
+    return "1d";
+  }
+  return void 0;
+}
+function getTextureSampleType(resourceType) {
+  if (resourceType.startsWith("texture_depth_")) {
+    return "depth";
+  }
+  if (resourceType.includes("<i32>")) {
+    return "sint";
+  }
+  if (resourceType.includes("<u32>")) {
+    return "uint";
+  }
+  if (resourceType.includes("<f32>")) {
+    return "float";
+  }
+  return void 0;
+}
+function getStorageTextureAccess(resourceType) {
+  const match = /,\s*([A-Za-z_][A-Za-z0-9_]*)\s*>$/.exec(resourceType);
+  return match == null ? void 0 : match[1];
+}
+
 // dist/lib/shader-assembly/assemble-shaders.js
 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 */
   `precision highp float;
@@ -576,14 +837,17 @@ var FRAGMENT_SHADER_PROLOGUE = (
 );
 function assembleWGSLShader(options) {
   const modules = getShaderModuleDependencies(options.modules || []);
+  const { source: source4, bindingAssignments } = assembleShaderWGSL(options.platformInfo, {
+    ...options,
+    source: options.source,
+    stage: "vertex",
+    modules
+  });
   return {
-    source: assembleShaderWGSL(options.platformInfo, {
-      ...options,
-      source: options.source,
-      stage: "vertex",
-      modules
-    }),
-    getUniforms: assembleGetUniforms(modules)
+    source: source4,
+    getUniforms: assembleGetUniforms(modules),
+    bindingAssignments,
+    bindingTable: getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments)
   };
 }
 function assembleGLSLShaderPair(options) {
@@ -645,11 +909,20 @@ function assembleShaderWGSL(platformInfo, options) {
     }
   }
   const modulesToInject = modules;
+  const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(coreSource);
+  const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(modulesToInject, options._bindingRegistry, usedBindingsByGroup);
+  const bindingAssignments = [];
   for (const module2 of modulesToInject) {
     if (log2) {
       checkShaderModuleDeprecations(module2, coreSource, log2);
     }
-    const moduleSource = getShaderModuleSource(module2, "wgsl");
+    const relocation = relocateWGSLModuleBindings(getShaderModuleSource(module2, "wgsl", log2), module2, {
+      usedBindingsByGroup,
+      bindingRegistry: options._bindingRegistry,
+      reservedBindingKeysByGroup
+    });
+    bindingAssignments.push(...relocation.bindingAssignments);
+    const moduleSource = relocation.source;
     assembledSource += moduleSource;
     const injections = ((_a = module2.injections) == null ? void 0 : _a[stage]) || {};
     for (const key in injections) {
@@ -668,9 +941,11 @@ function assembleShaderWGSL(platformInfo, options) {
   assembledSource += INJECT_SHADER_DECLARATIONS;
   assembledSource = injectShader(assembledSource, stage, declInjections);
   assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
+  assembledSource += formatWGSLBindingAssignmentComments(bindingAssignments);
   assembledSource += coreSource;
   assembledSource = injectShader(assembledSource, stage, mainInjections);
-  return assembledSource;
+  assertNoUnresolvedAutoBindings(assembledSource);
+  return { source: assembledSource, bindingAssignments };
 }
 function assembleShaderGLSL(platformInfo, options) {
   var _a;
@@ -734,7 +1009,7 @@ ${getApplicationDefines(allDefines)}
     if (log2) {
       checkShaderModuleDeprecations(module2, coreSource, log2);
     }
-    const moduleSource = getShaderModuleSource(module2, stage);
+    const moduleSource = getShaderModuleSource(module2, stage, log2);
     assembledSource += moduleSource;
     const injections = ((_a = module2.instance) == null ? void 0 : _a.normalizedInjections[stage]) || {};
     for (const key in injections) {
@@ -783,7 +1058,7 @@ function getApplicationDefines(defines = {}) {
   }
   return sourceText;
 }
-function getShaderModuleSource(module2, stage) {
+function getShaderModuleSource(module2, stage, log2) {
   let moduleSource;
   switch (stage) {
     case "vertex":
@@ -801,6 +1076,7 @@ function getShaderModuleSource(module2, stage) {
   if (!module2.name) {
     throw new Error("Shader module must have a name");
   }
+  validateShaderModuleUniformLayout(module2, stage, { log: log2 });
   const moduleName = module2.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
   let source4 = `// ----- MODULE ${module2.name} ---------------
 
@@ -813,13 +1089,177 @@ function getShaderModuleSource(module2, stage) {
 `;
   return source4;
 }
+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}"`);
+    }
+  }
+  return usedBindingsByGroup;
+}
+function relocateWGSLModuleBindings(moduleSource, module2, context) {
+  const bindingAssignments = [];
+  const relocationState = {
+    sawSupportedBindingDeclaration: false,
+    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.`);
+  }
+  return { source: relocatedSource, bindingAssignments };
+}
+function relocateWGSLModuleBindingsWithRegex(source4, regex, params) {
+  return source4.replace(regex, (...replaceArguments) => relocateWGSLModuleBindingMatch(replaceArguments, params));
+}
+function relocateWGSLModuleBindingMatch(replaceArguments, 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 group = Number(groupToken);
+  if (bindingToken === "auto") {
+    const registryKey = getBindingRegistryKey(group, module2.name, name);
+    const registryLocation = (_a = context.bindingRegistry) == null ? void 0 : _a.get(registryKey);
+    const location2 = registryLocation !== void 0 ? registryLocation : relocationState.nextHintedBindingLocation === null ? allocateAutoBindingLocation(group, context.usedBindingsByGroup) : allocateAutoBindingLocation(group, context.usedBindingsByGroup, relocationState.nextHintedBindingLocation);
+    validateModuleWGSLBinding(module2.name, group, location2, name);
+    if (registryLocation !== void 0 && claimReservedBindingLocation(context.reservedBindingKeysByGroup, group, location2, registryKey)) {
+      bindingAssignments.push({ moduleName: module2.name, name, group, location: location2 });
+      return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location2})`);
+    }
+    registerUsedBindingLocation(context.usedBindingsByGroup, group, location2, `module "${module2.name}" binding "${name}"`);
+    (_b = context.bindingRegistry) == null ? void 0 : _b.set(registryKey, location2);
+    bindingAssignments.push({ moduleName: module2.name, name, group, location: location2 });
+    if (relocationState.nextHintedBindingLocation !== null && registryLocation === void 0) {
+      relocationState.nextHintedBindingLocation = location2 + 1;
+    }
+    return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location2})`);
+  }
+  const location = Number(bindingToken);
+  validateModuleWGSLBinding(module2.name, group, location, name);
+  registerUsedBindingLocation(context.usedBindingsByGroup, group, location, `module "${module2.name}" binding "${name}"`);
+  bindingAssignments.push({ moduleName: module2.name, name, group, location });
+  return match;
+}
+function reserveRegisteredModuleBindings(modules, bindingRegistry, usedBindingsByGroup) {
+  const reservedBindingKeysByGroup = /* @__PURE__ */ new Map();
+  if (!bindingRegistry) {
+    return reservedBindingKeysByGroup;
+  }
+  for (const module2 of modules) {
+    for (const binding of getModuleWGSLBindingDeclarations(module2)) {
+      const registryKey = getBindingRegistryKey(binding.group, module2.name, binding.name);
+      const location = bindingRegistry.get(registryKey);
+      if (location !== void 0) {
+        const reservedBindingKeys = reservedBindingKeysByGroup.get(binding.group) || /* @__PURE__ */ new Map();
+        const existingReservation = reservedBindingKeys.get(location);
+        if (existingReservation && existingReservation !== registryKey) {
+          throw new Error(`Duplicate WGSL binding reservation for modules "${existingReservation}" and "${registryKey}": group ${binding.group}, binding ${location}.`);
+        }
+        registerUsedBindingLocation(usedBindingsByGroup, binding.group, location, `registered module binding "${registryKey}"`);
+        reservedBindingKeys.set(location, registryKey);
+        reservedBindingKeysByGroup.set(binding.group, reservedBindingKeys);
+      }
+    }
+  }
+  return reservedBindingKeysByGroup;
+}
+function claimReservedBindingLocation(reservedBindingKeysByGroup, group, location, registryKey) {
+  const reservedBindingKeys = reservedBindingKeysByGroup.get(group);
+  if (!reservedBindingKeys) {
+    return false;
+  }
+  const reservedKey = reservedBindingKeys.get(location);
+  if (!reservedKey) {
+    return false;
+  }
+  if (reservedKey !== registryKey) {
+    throw new Error(`Registered module binding "${registryKey}" collided with "${reservedKey}": group ${group}, binding ${location}.`);
+  }
+  return true;
+}
+function getModuleWGSLBindingDeclarations(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])
+      });
+    }
+  }
+  return declarations;
+}
+function validateApplicationWGSLBinding(group, location, name) {
+  if (group === 0 && location >= RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT) {
+    throw new Error(`Application binding "${name}" in group 0 uses reserved binding ${location}. Application-owned explicit group-0 bindings must stay below ${RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT}.`);
+  }
+}
+function validateModuleWGSLBinding(moduleName, group, location, name) {
+  if (group === 0 && location < RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT) {
+    throw new Error(`Module "${moduleName}" binding "${name}" in group 0 uses reserved application binding ${location}. Module-owned explicit group-0 bindings must be ${RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT} or higher.`);
+  }
+}
+function registerUsedBindingLocation(usedBindingsByGroup, group, location, label) {
+  const usedBindings = usedBindingsByGroup.get(group) || /* @__PURE__ */ new Set();
+  if (usedBindings.has(location)) {
+    throw new Error(`Duplicate WGSL binding assignment for ${label}: group ${group}, binding ${location}.`);
+  }
+  usedBindings.add(location);
+  usedBindingsByGroup.set(group, usedBindings);
+}
+function allocateAutoBindingLocation(group, usedBindingsByGroup, preferredBindingLocation) {
+  const usedBindings = usedBindingsByGroup.get(group) || /* @__PURE__ */ new Set();
+  let nextBinding = preferredBindingLocation ?? (group === 0 ? RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT : usedBindings.size > 0 ? Math.max(...usedBindings) + 1 : 0);
+  while (usedBindings.has(nextBinding)) {
+    nextBinding++;
+  }
+  return nextBinding;
+}
+function assertNoUnresolvedAutoBindings(source4) {
+  if (/@binding\(\s*auto\s*\)/.test(source4)) {
+    throw new Error("Unresolved @binding(auto) remained in assembled WGSL source.");
+  }
+}
+function formatWGSLBindingAssignmentComments(bindingAssignments) {
+  if (bindingAssignments.length === 0) {
+    return "";
+  }
+  let source4 = "// ----- MODULE WGSL BINDING ASSIGNMENTS ---------------\n";
+  for (const bindingAssignment of bindingAssignments) {
+    source4 += `// ${bindingAssignment.moduleName}.${bindingAssignment.name} -> @group(${bindingAssignment.group}) @binding(${bindingAssignment.location})
+`;
+  }
+  source4 += "\n";
+  return source4;
+}
+function getBindingRegistryKey(group, moduleName, bindingName) {
+  return `${group}:${moduleName}:${bindingName}`;
+}
 
 // dist/lib/preprocessor/preprocessor.js
-var IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
-var IFNDEF_REGEXP = /^\s*\#\s*ifndef\s*([a-zA-Z_]+)\s*(?:\/\/.*)?$/;
+var DEFINE_NAME_PATTERN = "([a-zA-Z_][a-zA-Z0-9_]*)";
+var IFDEF_REGEXP = new RegExp(`^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*$`);
+var IFNDEF_REGEXP = new RegExp(`^\\s*\\#\\s*ifndef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`);
 var ELSE_REGEXP = /^\s*\#\s*else\s*(?:\/\/.*)?$/;
 var ENDIF_REGEXP = /^\s*\#\s*endif\s*$/;
-var IFDEF_WITH_COMMENT_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*(?:\/\/.*)?$/;
+var IFDEF_WITH_COMMENT_REGEXP = new RegExp(`^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`);
 var ENDIF_WITH_COMMENT_REGEXP = /^\s*\#\s*endif\s*(?:\/\/.*)?$/;
 function preprocess(source4, options) {
   var _a, _b;
@@ -866,6 +1306,8 @@ var _ShaderAssembler = class {
   _hookFunctions = [];
   /** Shader modules */
   _defaultModules = [];
+  /** Stable per-run WGSL auto-binding assignments keyed by group/module/binding. */
+  _wgslBindingRegistry = /* @__PURE__ */ new Map();
   /**
    * A default shader assembler instance - the natural place to register default modules and hooks
    * @returns
@@ -909,10 +1351,11 @@ var _ShaderAssembler = class {
   assembleWGSLShader(props) {
     const modules = this._getModuleList(props.modules);
     const hookFunctions = this._hookFunctions;
-    const { source: source4, getUniforms: getUniforms4 } = assembleWGSLShader({
+    const { source: source4, getUniforms: getUniforms4, bindingAssignments } = assembleWGSLShader({
       ...props,
       // @ts-expect-error
       source: props.source,
+      _bindingRegistry: this._wgslBindingRegistry,
       modules,
       hookFunctions
     });
@@ -924,7 +1367,13 @@ var _ShaderAssembler = class {
       ...props.defines
     };
     const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source4, { defines }) : source4;
-    return { source: preprocessedSource, getUniforms: getUniforms4, modules };
+    return {
+      source: preprocessedSource,
+      getUniforms: getUniforms4,
+      modules,
+      bindingAssignments,
+      bindingTable: getShaderBindingDebugRowsFromWGSL(preprocessedSource, bindingAssignments)
+    };
   }
   /**
    * Assemble a pair of shaders into a single shader program
@@ -1089,6 +1538,9 @@ function generateGLSLUniformDeclarations(module2, options) {
     case "uniforms":
   }
   for (const [uniformName, uniformFormat] of Object.entries(module2.uniformTypes || {})) {
+    if (typeof uniformFormat !== "string") {
+      throw new Error(`Composite uniform types are not supported by GLSL shader generation: ${module2.name}.${uniformName}`);
+    }
     const glslUniformType = getGLSLUniformType(uniformFormat);
     switch (options.uniforms) {
       case "scoped-interface-blocks":
@@ -1149,6 +1601,9 @@ function generateWGSLUniformDeclarations(module2, options) {
   const wgsl = [];
   wgsl.push(`struct ${capitalize(module2.name)} {`);
   for (const [uniformName, uniformFormat] of Object.entries((module2 == null ? void 0 : module2.uniformTypes) || {})) {
+    if (typeof uniformFormat !== "string") {
+      throw new Error(`Composite uniform types are not supported by WGSL shader generation: ${module2.name}.${uniformName}`);
+    }
     const wgslUniformType = uniformFormat;
     wgsl.push(`  ${uniformName} : ${wgslUniformType};`);
   }
@@ -1463,6 +1918,7 @@ var fp64arithmeticShader = (
   `
 uniform fp64arithmeticUniforms {
   uniform float ONE;
+  uniform float SPLIT;
 } fp64;
 
 /*
@@ -1472,6 +1928,12 @@ The purpose of this workaround is to prevent shader compilers from
 optimizing away necessary arithmetic operations by swapping their sequences
 or transform the equation to some 'equivalent' form.
 
+These helpers implement Dekker/Veltkamp-style error tracking. If the compiler
+folds constants or reassociates the arithmetic, the high/low split can stop
+tracking the rounding error correctly. That failure mode tends to look fine in
+simple coordinate setup, but then breaks down inside iterative arithmetic such
+as fp64 Mandelbrot loops.
+
 The method is to multiply an artifical variable, ONE, which will be known to
 the compiler to be 1 only at runtime. The whole expression is then represented
 as a polynomial with respective to ONE. In the coefficients of all terms, only one a
@@ -1480,17 +1942,23 @@ and one b should appear
 err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
 */
 
-// Divide float number to high and low floats to extend fraction bits
-vec2 split(float a) {
-  const float SPLIT = 4097.0;
-  float t = a * SPLIT;
+float prevent_fp64_optimization(float value) {
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float a_hi = t * fp64.ONE - (t - a);
-  float a_lo = a * fp64.ONE - a_hi;
+  return value + fp64.ONE * 0.0;
 #else
-  float a_hi = t - (t - a);
-  float a_lo = a - a_hi;
+  return value;
 #endif
+}
+
+// Divide float number to high and low floats to extend fraction bits
+vec2 split(float a) {
+  // Keep SPLIT as a runtime uniform so the compiler cannot fold the Dekker
+  // split into a constant expression and reassociate the recovery steps.
+  float split = prevent_fp64_optimization(fp64.SPLIT);
+  float t = prevent_fp64_optimization(a * split);
+  float temp = t - a;
+  float a_hi = t - temp;
+  float a_lo = a - a_hi;
   return vec2(a_hi, a_lo);
 }
 
@@ -1554,8 +2022,26 @@ vec2 twoProd(float a, float b) {
   float prod = a * b;
   vec2 a_fp64 = split(a);
   vec2 b_fp64 = split(b);
-  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
-    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
+  // twoProd is especially sensitive because mul_fp64 and div_fp64 both depend
+  // on the split terms and cross terms staying in the original evaluation
+  // order. If the compiler folds or reassociates them, the low part tends to
+  // collapse to zero or NaN on some drivers.
+  float highProduct = prevent_fp64_optimization(a_fp64.x * b_fp64.x);
+  float crossProduct1 = prevent_fp64_optimization(a_fp64.x * b_fp64.y);
+  float crossProduct2 = prevent_fp64_optimization(a_fp64.y * b_fp64.x);
+  float lowProduct = prevent_fp64_optimization(a_fp64.y * b_fp64.y);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err1 = (highProduct - prod) * fp64.ONE;
+  float err2 = crossProduct1 * fp64.ONE * fp64.ONE;
+  float err3 = crossProduct2 * fp64.ONE * fp64.ONE * fp64.ONE;
+  float err4 = lowProduct * fp64.ONE * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err1 = highProduct - prod;
+  float err2 = crossProduct1;
+  float err3 = crossProduct2;
+  float err4 = lowProduct;
+#endif
+  float err = ((err1 + err2) + err3) + err4;
   return vec2(prod, err);
 }
 
@@ -1631,6 +2117,218 @@ vec2 sqrt_fp64(vec2 a) {
 `
 );
 
+// dist/modules/math/fp64/fp64-arithmetic-wgsl.js
+var fp64arithmeticWGSL = (
+  /* wgsl */
+  `struct Fp64ArithmeticUniforms {
+  ONE: f32,
+  SPLIT: f32,
+};
+
+@group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;
+
+fn fp64_nan(seed: f32) -> f32 {
+  let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);
+  return bitcast<f32>(nanBits);
+}
+
+fn fp64_runtime_zero() -> f32 {
+  return fp64arithmetic.ONE * 0.0;
+}
+
+fn prevent_fp64_optimization(value: f32) -> f32 {
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  return value + fp64_runtime_zero();
+#else
+  return value;
+#endif
+}
+
+fn split(a: f32) -> vec2f {
+  let splitValue = prevent_fp64_optimization(fp64arithmetic.SPLIT + fp64_runtime_zero());
+  let t = prevent_fp64_optimization(a * splitValue);
+  let temp = prevent_fp64_optimization(t - a);
+  let aHi = prevent_fp64_optimization(t - temp);
+  let aLo = prevent_fp64_optimization(a - aHi);
+  return vec2f(aHi, aLo);
+}
+
+fn split2(a: vec2f) -> vec2f {
+  var b = split(a.x);
+  b.y = b.y + a.y;
+  return b;
+}
+
+fn quickTwoSum(a: f32, b: f32) -> vec2f {
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let sum = prevent_fp64_optimization((a + b) * fp64arithmetic.ONE);
+  let err = prevent_fp64_optimization(b - (sum - a) * fp64arithmetic.ONE);
+#else
+  let sum = prevent_fp64_optimization(a + b);
+  let err = prevent_fp64_optimization(b - (sum - a));
+#endif
+  return vec2f(sum, err);
+}
+
+fn twoSum(a: f32, b: f32) -> vec2f {
+  let s = prevent_fp64_optimization(a + b);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);
+  let err =
+    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE) +
+    prevent_fp64_optimization(b - v);
+#else
+  let v = prevent_fp64_optimization(s - a);
+  let err = prevent_fp64_optimization(a - (s - v)) + prevent_fp64_optimization(b - v);
+#endif
+  return vec2f(s, err);
+}
+
+fn twoSub(a: f32, b: f32) -> vec2f {
+  let s = prevent_fp64_optimization(a - b);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);
+  let err =
+    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE) -
+    prevent_fp64_optimization(b + v);
+#else
+  let v = prevent_fp64_optimization(s - a);
+  let err = prevent_fp64_optimization(a - (s - v)) - prevent_fp64_optimization(b + v);
+#endif
+  return vec2f(s, err);
+}
+
+fn twoSqr(a: f32) -> vec2f {
+  let prod = prevent_fp64_optimization(a * a);
+  let aFp64 = split(a);
+  let highProduct = prevent_fp64_optimization(aFp64.x * aFp64.x);
+  let crossProduct = prevent_fp64_optimization(2.0 * aFp64.x * aFp64.y);
+  let lowProduct = prevent_fp64_optimization(aFp64.y * aFp64.y);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let err =
+    (prevent_fp64_optimization(highProduct - prod) * fp64arithmetic.ONE +
+      crossProduct * fp64arithmetic.ONE * fp64arithmetic.ONE) +
+    lowProduct * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;
+#else
+  let err = ((prevent_fp64_optimization(highProduct - prod) + crossProduct) + lowProduct);
+#endif
+  return vec2f(prod, err);
+}
+
+fn twoProd(a: f32, b: f32) -> vec2f {
+  let prod = prevent_fp64_optimization(a * b);
+  let aFp64 = split(a);
+  let bFp64 = split(b);
+  let highProduct = prevent_fp64_optimization(aFp64.x * bFp64.x);
+  let crossProduct1 = prevent_fp64_optimization(aFp64.x * bFp64.y);
+  let crossProduct2 = prevent_fp64_optimization(aFp64.y * bFp64.x);
+  let lowProduct = prevent_fp64_optimization(aFp64.y * bFp64.y);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let err1 = (highProduct - prod) * fp64arithmetic.ONE;
+  let err2 = crossProduct1 * fp64arithmetic.ONE * fp64arithmetic.ONE;
+  let err3 = crossProduct2 * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;
+  let err4 =
+    lowProduct *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE;
+#else
+  let err1 = highProduct - prod;
+  let err2 = crossProduct1;
+  let err3 = crossProduct2;
+  let err4 = lowProduct;
+#endif
+  let err12InputA = prevent_fp64_optimization(err1);
+  let err12InputB = prevent_fp64_optimization(err2);
+  let err12 = prevent_fp64_optimization(err12InputA + err12InputB);
+  let err123InputA = prevent_fp64_optimization(err12);
+  let err123InputB = prevent_fp64_optimization(err3);
+  let err123 = prevent_fp64_optimization(err123InputA + err123InputB);
+  let err1234InputA = prevent_fp64_optimization(err123);
+  let err1234InputB = prevent_fp64_optimization(err4);
+  let err = prevent_fp64_optimization(err1234InputA + err1234InputB);
+  return vec2f(prod, err);
+}
+
+fn sum_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var s = twoSum(a.x, b.x);
+  let t = twoSum(a.y, b.y);
+  s.y = prevent_fp64_optimization(s.y + t.x);
+  s = quickTwoSum(s.x, s.y);
+  s.y = prevent_fp64_optimization(s.y + t.y);
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+fn sub_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var s = twoSub(a.x, b.x);
+  let t = twoSub(a.y, b.y);
+  s.y = prevent_fp64_optimization(s.y + t.x);
+  s = quickTwoSum(s.x, s.y);
+  s.y = prevent_fp64_optimization(s.y + t.y);
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+fn mul_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var prod = twoProd(a.x, b.x);
+  let crossProduct1 = prevent_fp64_optimization(a.x * b.y);
+  prod.y = prevent_fp64_optimization(prod.y + crossProduct1);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  let crossProduct2 = prevent_fp64_optimization(a.y * b.x);
+  prod.y = prevent_fp64_optimization(prod.y + crossProduct2);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
+}
+
+fn div_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let xn = prevent_fp64_optimization(1.0 / b.x);
+  let yn = mul_fp64(a, vec2f(xn, fp64_runtime_zero()));
+  let diff = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, yn)).x);
+  let prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+fn sqrt_fp64(a: vec2f) -> vec2f {
+  if (a.x == 0.0 && a.y == 0.0) {
+    return vec2f(0.0, 0.0);
+  }
+  if (a.x < 0.0) {
+    let nanValue = fp64_nan(a.x);
+    return vec2f(nanValue, nanValue);
+  }
+
+  let x = prevent_fp64_optimization(1.0 / sqrt(a.x));
+  let yn = prevent_fp64_optimization(a.x * x);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let ynSqr = twoSqr(yn) * fp64arithmetic.ONE;
+#else
+  let ynSqr = twoSqr(yn);
+#endif
+  let diff = prevent_fp64_optimization(sub_fp64(a, ynSqr).x);
+  let prod = twoProd(prevent_fp64_optimization(x * 0.5), diff);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2f(yn, 0.0), prod);
+#endif
+}
+`
+);
+
 // dist/modules/math/fp64/fp64-functions-glsl.js
 var fp64functionShader = (
   /* glsl */
@@ -2309,13 +3007,18 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
 // dist/modules/math/fp64/fp64.js
 var defaultUniforms = {
   // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
-  ONE: 1
+  ONE: 1,
+  // Runtime split factor for Dekker splitting. Keeping this as a uniform helps
+  // prevent aggressive constant folding in shader compilers.
+  SPLIT: 4097
 };
 var fp64arithmetic = {
   name: "fp64arithmetic",
+  source: fp64arithmeticWGSL,
+  fs: fp64arithmeticShader,
   vs: fp64arithmeticShader,
   defaultUniforms,
-  uniformTypes: { ONE: "f32" },
+  uniformTypes: { ONE: "f32", SPLIT: "f32" },
   // Additional Functions
   fp64ify,
   fp64LowPart,
@@ -2529,7 +3232,7 @@ struct skinUniforms {
   jointMatrix: array<mat4x4<f32>, ${SKIN_MAX_JOINTS}>,
 };
 
-@binding(19) @group(0) var<uniform> skin: skinUniforms;
+@group(0) @binding(auto) var<uniform> skin: skinUniforms;
 
 fn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {
   return (weights.x * skin.jointMatrix[joints.x])
@@ -2563,6 +3266,7 @@ var skin = {
   props: {},
   uniforms: {},
   name: "skin",
+  bindingLayout: [{ name: "skin", group: 0 }],
   dependencies: [],
   source: source2,
   vs: vs2,
@@ -2606,10 +3310,7 @@ var skin = {
     };
   },
   uniformTypes: {
-    jointMatrix: "mat4x4<f32>"
-  },
-  uniformSizes: {
-    jointMatrix: SKIN_MAX_JOINTS
+    jointMatrix: ["mat4x4<f32>", SKIN_MAX_JOINTS]
   }
 };
 
@@ -2632,77 +3333,51 @@ struct PointLight {
   vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 struct DirectionalLight {
   vec3 color;
   vec3 direction;
 };
 
+struct UniformLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 uniform lightingUniforms {
   int enabled;
-  int lightType;
-
   int directionalLightCount;
   int pointLightCount;
-
+  int spotLightCount;
   vec3 ambientColor;
-
-  vec3 lightColor0;
-  vec3 lightPosition0;
-  vec3 lightDirection0;
-  vec3 lightAttenuation0;
-
-  vec3 lightColor1;
-  vec3 lightPosition1;
-  vec3 lightDirection1;
-  vec3 lightAttenuation1;
-
-  vec3 lightColor2;
-  vec3 lightPosition2;
-  vec3 lightDirection2;
-  vec3 lightAttenuation2;
-
-  vec3 lightColor3;
-  vec3 lightPosition3;
-  vec3 lightDirection3;
-  vec3 lightAttenuation3;
-
-  vec3 lightColor4;
-  vec3 lightPosition4;
-  vec3 lightDirection4;
-  vec3 lightAttenuation4;
+  UniformLight lights[5];
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
-  switch (index) {
-    case 0:
-      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
-    case 1:
-      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
-    case 2:
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
-    case 3:
-      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
-    case 4:
-    default:  
-      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
-  }
+  UniformLight light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+SpotLight lighting_getSpotLight(int index) {
+  UniformLight light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
 }
 
 DirectionalLight lighting_getDirectionalLight(int index) {
-  switch (index) {
-    case 0:
-      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
-    case 1:
-      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
-    case 2:
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-    case 3:
-      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
-    case 4:
-    default:   
-      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
-  }
-} 
+  UniformLight light =
+    lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {
   return pointLight.attenuation.x
@@ -2710,6 +3385,20 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
        + pointLight.attenuation.z * distance * distance;
 }
 
+float getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {
+  vec3 light_direction = normalize(positionWorldspace - spotLight.position);
+  float coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), light_direction)
+  );
+  float distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
+
 // #endif
 `
 );
@@ -2730,105 +3419,85 @@ struct PointLight {
   attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct DirectionalLight {
   color: vec3<f32>,
   direction: vec3<f32>,
 };
 
+struct UniformLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct lightingUniforms {
   enabled: i32,
-  lightType: i32,
-
   directionalLightCount: i32,
   pointLightCount: i32,
-
+  spotLightCount: i32,
   ambientColor: vec3<f32>,
-
-  lightColor0: vec3<f32>,
-  lightPosition0: vec3<f32>,
-  lightDirection0: vec3<f32>,
-  lightAttenuation0: vec3<f32>,
-
-  lightColor1: vec3<f32>,
-  lightPosition1: vec3<f32>,
-  lightDirection1: vec3<f32>,
-  lightAttenuation1: vec3<f32>,
-
-  lightColor2: vec3<f32>,
-  lightPosition2: vec3<f32>,
-  lightDirection2: vec3<f32>,
-  lightAttenuation2: vec3<f32>,
-
-  lightColor3: vec3<f32>,
-  lightPosition3: vec3<f32>,
-  lightDirection3: vec3<f32>,
-  lightAttenuation3: vec3<f32>,
-
-  lightColor4: vec3<f32>,
-  lightPosition4: vec3<f32>,
-  lightDirection4: vec3<f32>,
-  lightAttenuation4: vec3<f32>,
+  lights: array<UniformLight, 5>,
 };
 
-// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
-@binding(1) @group(0) var<uniform> lighting : lightingUniforms;
+@group(2) @binding(auto) var<uniform> lighting : lightingUniforms;
 
 fn lighting_getPointLight(index: i32) -> PointLight {
-  switch (index) {
-    case 0: {
-      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
-    }
-    case 1: {
-      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
-    }
-    case 2: {
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
-    }
-    case 3: {
-      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
-    }
-    case 4, default: {
-      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
-    }
-  }
+  let light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+fn lighting_getSpotLight(index: i32) -> SpotLight {
+  let light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
 }
 
 fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
-  switch (index) {
-    case 0: {
-      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
-    }
-    case 1: {
-      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
-    }
-    case 2: {
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-    }
-    case 3: {
-      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
-    }
-    case 4, default: {
-      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
-    }
-  }
-} 
+  let light = lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
   return pointLight.attenuation.x
        + pointLight.attenuation.y * distance
        + pointLight.attenuation.z * distance * distance;
 }
+
+fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>) -> f32 {
+  let lightDirection = normalize(positionWorldspace - spotLight.position);
+  let coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), lightDirection)
+  );
+  let distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
 `
 );
 
 // dist/modules/lighting/lights/lighting.js
 var MAX_LIGHTS = 5;
 var COLOR_FACTOR = 255;
-var LIGHT_TYPE;
-(function(LIGHT_TYPE2) {
-  LIGHT_TYPE2[LIGHT_TYPE2["POINT"] = 0] = "POINT";
-  LIGHT_TYPE2[LIGHT_TYPE2["DIRECTIONAL"] = 1] = "DIRECTIONAL";
-})(LIGHT_TYPE || (LIGHT_TYPE = {}));
+var LIGHT_UNIFORM_TYPE = {
+  color: "vec3<f32>",
+  position: "vec3<f32>",
+  direction: "vec3<f32>",
+  attenuation: "vec3<f32>",
+  coneCos: "vec2<f32>"
+};
 var lighting = {
   props: {},
   uniforms: {},
@@ -2838,128 +3507,105 @@ var lighting = {
   },
   uniformTypes: {
     enabled: "i32",
-    lightType: "i32",
     directionalLightCount: "i32",
     pointLightCount: "i32",
+    spotLightCount: "i32",
     ambientColor: "vec3<f32>",
-    // TODO define as arrays once we have appropriate uniformTypes
-    lightColor0: "vec3<f32>",
-    lightPosition0: "vec3<f32>",
-    // TODO - could combine direction and attenuation
-    lightDirection0: "vec3<f32>",
-    lightAttenuation0: "vec3<f32>",
-    lightColor1: "vec3<f32>",
-    lightPosition1: "vec3<f32>",
-    lightDirection1: "vec3<f32>",
-    lightAttenuation1: "vec3<f32>",
-    lightColor2: "vec3<f32>",
-    lightPosition2: "vec3<f32>",
-    lightDirection2: "vec3<f32>",
-    lightAttenuation2: "vec3<f32>",
-    lightColor3: "vec3<f32>",
-    lightPosition3: "vec3<f32>",
-    lightDirection3: "vec3<f32>",
-    lightAttenuation3: "vec3<f32>",
-    lightColor4: "vec3<f32>",
-    lightPosition4: "vec3<f32>",
-    lightDirection4: "vec3<f32>",
-    lightAttenuation4: "vec3<f32>"
-  },
-  defaultUniforms: {
-    enabled: 1,
-    lightType: LIGHT_TYPE.POINT,
-    directionalLightCount: 0,
-    pointLightCount: 0,
-    ambientColor: [0.1, 0.1, 0.1],
-    lightColor0: [1, 1, 1],
-    lightPosition0: [1, 1, 2],
-    // TODO - could combine direction and attenuation
-    lightDirection0: [1, 1, 1],
-    lightAttenuation0: [1, 0, 0],
-    lightColor1: [1, 1, 1],
-    lightPosition1: [1, 1, 2],
-    lightDirection1: [1, 1, 1],
-    lightAttenuation1: [1, 0, 0],
-    lightColor2: [1, 1, 1],
-    lightPosition2: [1, 1, 2],
-    lightDirection2: [1, 1, 1],
-    lightAttenuation2: [1, 0, 0],
-    lightColor3: [1, 1, 1],
-    lightPosition3: [1, 1, 2],
-    lightDirection3: [1, 1, 1],
-    lightAttenuation3: [1, 0, 0],
-    lightColor4: [1, 1, 1],
-    lightPosition4: [1, 1, 2],
-    lightDirection4: [1, 1, 1],
-    lightAttenuation4: [1, 0, 0]
+    lights: [LIGHT_UNIFORM_TYPE, MAX_LIGHTS]
   },
+  defaultUniforms: createDefaultLightingUniforms(),
+  bindingLayout: [{ name: "lighting", group: 2 }],
+  firstBindingSlot: 0,
   source: lightingUniformsWGSL,
   vs: lightingUniformsGLSL,
   fs: lightingUniformsGLSL,
   getUniforms: getUniforms2
 };
-function getUniforms2(props, prevUniforms = {}) {
+function getUniforms2(props, _prevUniforms = {}) {
   props = props ? { ...props } : props;
   if (!props) {
-    return { ...lighting.defaultUniforms };
+    return createDefaultLightingUniforms();
   }
   if (props.lights) {
     props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
   }
-  const { ambientLight, pointLights, directionalLights } = props || {};
-  const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
+  const { ambientLight, pointLights, spotLights, directionalLights } = props || {};
+  const hasLights = ambientLight || pointLights && pointLights.length > 0 || spotLights && spotLights.length > 0 || directionalLights && directionalLights.length > 0;
   if (!hasLights) {
-    return { ...lighting.defaultUniforms, enabled: 0 };
+    return {
+      ...createDefaultLightingUniforms(),
+      enabled: 0
+    };
   }
   const uniforms = {
-    ...lighting.defaultUniforms,
-    ...prevUniforms,
-    ...getLightSourceUniforms({ ambientLight, pointLights, directionalLights })
+    ...createDefaultLightingUniforms(),
+    ...getLightSourceUniforms({ ambientLight, pointLights, spotLights, directionalLights })
   };
   if (props.enabled !== void 0) {
     uniforms.enabled = props.enabled ? 1 : 0;
   }
   return uniforms;
 }
-function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {
-  const lightSourceUniforms = {};
-  lightSourceUniforms.ambientColor = convertColor(ambientLight);
+function getLightSourceUniforms({ ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
+  const lights = createDefaultLightUniforms();
   let currentLight = 0;
   let pointLightCount = 0;
+  let spotLightCount = 0;
   let directionalLightCount = 0;
   for (const pointLight of pointLights) {
     if (currentLight >= MAX_LIGHTS) {
       break;
     }
-    lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
-    const i = currentLight;
-    lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
-    lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
-    lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
+    lights[currentLight] = {
+      ...lights[currentLight],
+      color: convertColor(pointLight),
+      position: pointLight.position,
+      attenuation: pointLight.attenuation || [1, 0, 0]
+    };
     currentLight++;
     pointLightCount++;
   }
+  for (const spotLight of spotLights) {
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
+    lights[currentLight] = {
+      ...lights[currentLight],
+      color: convertColor(spotLight),
+      position: spotLight.position,
+      direction: spotLight.direction,
+      attenuation: spotLight.attenuation || [1, 0, 0],
+      coneCos: getSpotConeCos(spotLight)
+    };
+    currentLight++;
+    spotLightCount++;
+  }
   for (const directionalLight of directionalLights) {
     if (currentLight >= MAX_LIGHTS) {
       break;
     }
-    lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;
-    const i = currentLight;
-    lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
-    lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
+    lights[currentLight] = {
+      ...lights[currentLight],
+      color: convertColor(directionalLight),
+      direction: directionalLight.direction
+    };
     currentLight++;
     directionalLightCount++;
   }
-  if (pointLights.length + directionalLights.length > MAX_LIGHTS) {
+  if (pointLights.length + spotLights.length + directionalLights.length > MAX_LIGHTS) {
     import_core3.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
   }
-  lightSourceUniforms.directionalLightCount = directionalLightCount;
-  lightSourceUniforms.pointLightCount = pointLightCount;
-  return lightSourceUniforms;
+  return {
+    ambientColor: convertColor(ambientLight),
+    directionalLightCount,
+    pointLightCount,
+    spotLightCount,
+    lights
+  };
 }
 function extractLightTypes(lights) {
-  var _a, _b;
-  const lightSources = { pointLights: [], directionalLights: [] };
+  var _a, _b, _c;
+  const lightSources = { pointLights: [], spotLights: [], directionalLights: [] };
   for (const light of lights || []) {
     switch (light.type) {
       case "ambient":
@@ -2971,6 +3617,9 @@ function extractLightTypes(lights) {
       case "point":
         (_b = lightSources.pointLights) == null ? void 0 : _b.push(light);
         break;
+      case "spot":
+        (_c = lightSources.spotLights) == null ? void 0 : _c.push(light);
+        break;
       default:
     }
   }
@@ -2980,6 +3629,68 @@ function convertColor(colorDef = {}) {
   const { color = [0, 0, 0], intensity = 1 } = colorDef;
   return color.map((component) => component * intensity / COLOR_FACTOR);
 }
+function createDefaultLightingUniforms() {
+  return {
+    enabled: 1,
+    directionalLightCount: 0,
+    pointLightCount: 0,
+    spotLightCount: 0,
+    ambientColor: [0.1, 0.1, 0.1],
+    lights: createDefaultLightUniforms()
+  };
+}
+function createDefaultLightUniforms() {
+  return Array.from({ length: MAX_LIGHTS }, () => createDefaultLightUniform());
+}
+function createDefaultLightUniform() {
+  return {
+    color: [1, 1, 1],
+    position: [1, 1, 2],
+    direction: [1, 1, 1],
+    attenuation: [1, 0, 0],
+    coneCos: [1, 0]
+  };
+}
+function getSpotConeCos(spotLight) {
+  const innerConeAngle = spotLight.innerConeAngle ?? 0;
+  const outerConeAngle = spotLight.outerConeAngle ?? Math.PI / 4;
+  return [Math.cos(innerConeAngle), Math.cos(outerConeAngle)];
+}
+
+// dist/modules/lighting/ibl/ibl.js
+var iblWGSL = (
+  /* wgsl */
+  `#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`
+);
+var iblGLSL = (
+  /* glsl */
+  `#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`
+);
+var ibl = {
+  name: "ibl",
+  firstBindingSlot: 32,
+  bindingLayout: [
+    { name: "pbr_diffuseEnvSampler", group: 2 },
+    { name: "pbr_specularEnvSampler", group: 2 },
+    { name: "pbr_brdfLUT", group: 2 }
+  ],
+  source: iblWGSL,
+  vs: iblGLSL,
+  fs: iblGLSL
+};
 
 // dist/modules/lighting/no-material/dirlight.js
 var SOURCE_WGSL = (
@@ -2995,7 +3706,7 @@ struct DirlightInputs {
   normal: DirlightNormal,
 };
 
-@binding(1) @group(0) var<uniform> dirlight : dirlightUniforms;
+@group(2) @binding(auto) var<uniform> dirlight : dirlightUniforms;
 
 // For vertex
 fn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {
@@ -3040,6 +3751,8 @@ var dirlight = {
   props: {},
   uniforms: {},
   name: "dirlight",
+  bindingLayout: [{ name: "dirlight", group: 2 }],
+  firstBindingSlot: 16,
   dependencies: [],
   source: SOURCE_WGSL,
   vs: VS_GLSL,
@@ -3066,10 +3779,173 @@ function getUniforms3(opts = dirlight.defaultUniforms) {
   return uniforms;
 }
 
+// dist/modules/lighting/lambert-material/lambert-shaders-wgsl.js
+var LAMBERT_WGSL = (
+  /* wgsl */
+  `struct lambertMaterialUniforms {
+  unlit: u32,
+  ambient: f32,
+  diffuse: f32,
+};
+
+@group(3) @binding(auto) var<uniform> lambertMaterial : lambertMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let lambertian: f32 = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * lambertMaterial.diffuse * surfaceColor * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lambertMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = lambertMaterial.ambient * surfaceColor * lighting.ambientColor;
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight: PointLight = lighting_getPointLight(i);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(light_position_worldspace, position_worldspace)
+    );
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      pointLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight: SpotLight = lighting_getSpotLight(i);
+    let light_position_worldspace: vec3<f32> = spotLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      spotLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      -directionalLight.direction,
+      normal_worldspace,
+      directionalLight.color
+    );
+  }
+
+  return lightColor;
+}
+`
+);
+
+// dist/modules/lighting/lambert-material/lambert-shaders-glsl.js
+var LAMBERT_VS = (
+  /* glsl */
+  `uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+`
+);
+var LAMBERT_FS = (
+  /* glsl */
+  `uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 normal_worldspace, vec3 color) {
+  float lambertian = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * material.diffuse * surfaceColor * color;
+}
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+  vec3 lightColor = surfaceColor;
+
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, normal_worldspace, directionalLight.color);
+  }
+
+  return lightColor;
+}
+`
+);
+
+// dist/modules/lighting/lambert-material/lambert-material.js
+var lambertMaterial = {
+  name: "lambertMaterial",
+  firstBindingSlot: 0,
+  bindingLayout: [{ name: "lambertMaterial", group: 3 }],
+  dependencies: [lighting],
+  source: LAMBERT_WGSL,
+  vs: LAMBERT_VS,
+  fs: LAMBERT_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    unlit: "i32",
+    ambient: "f32",
+    diffuse: "f32"
+  },
+  defaultUniforms: {
+    unlit: false,
+    ambient: 0.35,
+    diffuse: 0.6
+  },
+  getUniforms(props) {
+    return { ...lambertMaterial.defaultUniforms, ...props };
+  }
+};
+
 // dist/modules/lighting/phong-material/phong-shaders-glsl.js
 var PHONG_VS = (
   /* glsl */
   `uniform phongMaterialUniforms {
+  uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -3079,9 +3955,8 @@ var PHONG_VS = (
 );
 var PHONG_FS = (
   /* glsl */
-  `#define MAX_LIGHTS 3
-
-uniform phongMaterialUniforms {
+  `uniform phongMaterialUniforms {
+  uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -3103,6 +3978,10 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
   vec3 lightColor = surfaceColor;
 
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
   if (lighting.enabled == 0) {
     return lightColor;
   }
@@ -3118,8 +3997,15 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
     lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
   }
 
-  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
-  for (int i = lighting.pointLightCount; i < totalLights; i++) {
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
     DirectionalLight directionalLight = lighting_getDirectionalLight(i);
     lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }
@@ -3133,13 +4019,14 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
 var PHONG_WGSL = (
   /* wgsl */
   `struct phongMaterialUniforms {
+  unlit: u32,
   ambient: f32,
   diffuse: f32,
   shininess: f32,
   specularColor: vec3<f32>,
 };
 
-@binding(2) @group(0) var<uniform> phongMaterial : phongMaterialUniforms;
+@group(3) @binding(auto) var<uniform> phongMaterial : phongMaterialUniforms;
 
 fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
   let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
@@ -3156,6 +4043,10 @@ fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, v
 fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
   var lightColor: vec3<f32> = surfaceColor;
 
+  if (phongMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
   if (lighting.enabled == 0) {
     return lightColor;
   }
@@ -3180,8 +4071,21 @@ fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, p
     );
   }
 
-  let totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
-  for (var i: i32 = lighting.pointLightCount; i < totalLights; i++) {
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight: SpotLight = lighting_getSpotLight(i);
+    let light_position_worldspace: vec3<f32> = spotLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      view_direction,
+      normal_worldspace,
+      spotLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
     let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
     lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }  
@@ -3213,8 +4117,21 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       );
     }
 
-    let totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
-    for (var i: i32 = lighting.pointLightCount; i < totalLights; i++) {
+    for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+      let spotLight: SpotLight = lighting_getSpotLight(i);
+      let light_position_worldspace: vec3<f32> = spotLight.position;
+      let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+      let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+      lightColor += lighting_getLightColor(
+        surfaceColor,
+        light_direction,
+        view_direction,
+        normal_worldspace,
+        spotLight.color / light_attenuation
+      );
+    }
+
+    for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
         let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
         lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
     }
@@ -3228,6 +4145,7 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
 var gouraudMaterial = {
   props: {},
   name: "gouraudMaterial",
+  bindingLayout: [{ name: "gouraudMaterial", group: 3 }],
   // Note these are switched between phong and gouraud
   vs: PHONG_FS.replace("phongMaterial", "gouraudMaterial"),
   fs: PHONG_VS.replace("phongMaterial", "gouraudMaterial"),
@@ -3237,12 +4155,14 @@ var gouraudMaterial = {
   },
   dependencies: [lighting],
   uniformTypes: {
+    unlit: "i32",
     ambient: "f32",
     diffuse: "f32",
     shininess: "f32",
     specularColor: "vec3<f32>"
   },
   defaultUniforms: {
+    unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,
@@ -3260,6 +4180,8 @@ var gouraudMaterial = {
 // dist/modules/lighting/phong-material/phong-material.js
 var phongMaterial = {
   name: "phongMaterial",
+  firstBindingSlot: 0,
+  bindingLayout: [{ name: "phongMaterial", group: 3 }],
   dependencies: [lighting],
   // Note these are switched between phong and gouraud
   source: PHONG_WGSL,
@@ -3269,12 +4191,14 @@ var phongMaterial = {
     LIGHTING_FRAGMENT: true
   },
   uniformTypes: {
+    unlit: "i32",
     ambient: "f32",
     diffuse: "f32",
     shininess: "f32",
     specularColor: "vec3<f32>"
   },
   defaultUniforms: {
+    unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,
@@ -3371,10 +4295,12 @@ uniform pbrMaterialUniforms {
   float clearcoatFactor;
   float clearcoatRoughnessFactor;
   bool clearcoatMapEnabled;
+  bool clearcoatRoughnessMapEnabled;
 
   vec3 sheenColorFactor;
   float sheenRoughnessFactor;
   bool sheenColorMapEnabled;
+  bool sheenRoughnessMapEnabled;
 
   float iridescenceFactor;
   float iridescenceIor;
@@ -3424,26 +4350,33 @@ uniform sampler2D pbr_specularIntensitySampler;
 #ifdef HAS_TRANSMISSIONMAP
 uniform sampler2D pbr_transmissionSampler;
 #endif
+#ifdef HAS_THICKNESSMAP
+uniform sampler2D pbr_thicknessSampler;
+#endif
 #ifdef HAS_CLEARCOATMAP
 uniform sampler2D pbr_clearcoatSampler;
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
 uniform sampler2D pbr_clearcoatRoughnessSampler;
 #endif
+#ifdef HAS_CLEARCOATNORMALMAP
+uniform sampler2D pbr_clearcoatNormalSampler;
+#endif
 #ifdef HAS_SHEENCOLORMAP
 uniform sampler2D pbr_sheenColorSampler;
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
 uniform sampler2D pbr_sheenRoughnessSampler;
 #endif
 #ifdef HAS_IRIDESCENCEMAP
 uniform sampler2D pbr_iridescenceSampler;
 #endif
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+uniform sampler2D pbr_iridescenceThicknessSampler;
+#endif
 #ifdef HAS_ANISOTROPYMAP
 uniform sampler2D pbr_anisotropySampler;
 #endif
-#ifdef USE_IBL
-uniform samplerCube pbr_diffuseEnvSampler;
-uniform samplerCube pbr_specularEnvSampler;
-uniform sampler2D pbr_brdfLUT;
-#endif
-
 // Inputs from vertex shader
 
 in vec3 pbr_vPosition;
@@ -3480,6 +4413,8 @@ struct PBRInfo {
 const float M_PI = 3.141592653589793;
 const float c_MinRoughness = 0.04;
 
+vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor);
+
 vec4 SRGBtoLINEAR(vec4 srgbIn)
 {
 #ifdef MANUAL_SRGB
@@ -3495,11 +4430,9 @@ vec4 SRGBtoLINEAR(vec4 srgbIn)
 #endif //MANUAL_SRGB
 }
 
-// Find the normal for this fragment, pulling either from a predefined normal map
-// or from the interpolated mesh normal and tangent attributes.
-vec3 getNormal()
+// Build the tangent basis from interpolated attributes or screen-space derivatives.
+mat3 getTBN()
 {
-  // Retrieve the tangent space matrix
 #ifndef HAS_TANGENTS
   vec3 pos_dx = dFdx(pbr_vPosition);
   vec3 pos_dy = dFdy(pbr_vPosition);
@@ -3520,9 +4453,21 @@ vec3 getNormal()
   mat3 tbn = pbr_vTBN;
 #endif
 
+  return tbn;
+}
+
+// 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 n = texture(normalSampler, pbr_vUV).rgb;
+  return normalize(tbn * ((2.0 * n - 1.0) * vec3(normalScale, normalScale, 1.0)));
+}
+
+vec3 getNormal(mat3 tbn)
+{
 #ifdef HAS_NORMALMAP
-  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
+  vec3 n = getMappedNormal(pbr_normalSampler, tbn, pbrMaterial.normalScale);
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   vec3 n = normalize(tbn[2].xyz);
@@ -3531,6 +4476,15 @@ vec3 getNormal()
   return n;
 }
 
+vec3 getClearcoatNormal(mat3 tbn, vec3 baseNormal)
+{
+#ifdef HAS_CLEARCOATNORMALMAP
+  return getMappedNormal(pbr_clearcoatNormalSampler, tbn, 1.0);
+#else
+  return baseNormal;
+#endif
+}
+
 // Calculation of the lighting contribution from an optional Image Based Light source.
 // Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
 // See our README.md on Environment Maps [3] for additional discussion.
@@ -3606,35 +4560,203 @@ float microfacetDistribution(PBRInfo pbrInfo)
   return roughnessSq / (M_PI * f * f);
 }
 
-void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
-  pbrInfo.NdotL = 1.0;
-  pbrInfo.NdotH = 0.0;
-  pbrInfo.LdotH = 0.0;
-  pbrInfo.VdotH = 1.0;
+float maxComponent(vec3 value)
+{
+  return max(max(value.r, value.g), value.b);
 }
 
-void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
-  vec3 n = pbrInfo.n;
-  vec3 v = pbrInfo.v;
-  vec3 l = normalize(lightDirection);             // Vector from surface point to light
-  vec3 h = normalize(l+v);                        // Half vector between both l and v
+float getDielectricF0(float ior)
+{
+  float clampedIor = max(ior, 1.0);
+  float ratio = (clampedIor - 1.0) / (clampedIor + 1.0);
+  return ratio * ratio;
+}
 
-  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
-  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
-  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
-  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
+vec2 normalizeDirection(vec2 direction)
+{
+  float directionLength = length(direction);
+  return directionLength > 0.0001 ? direction / directionLength : vec2(1.0, 0.0);
 }
 
-void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
-  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
-  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+vec2 rotateDirection(vec2 direction, float rotation)
+{
+  float s = sin(rotation);
+  float c = cos(rotation);
+  return vec2(direction.x * c - direction.y * s, direction.x * s + direction.y * c);
 }
 
-vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
-  // Calculate the shading terms for the microfacet specular shading model
-  vec3 F = specularReflection(pbrInfo);
-  float G = geometricOcclusion(pbrInfo);
-  float D = microfacetDistribution(pbrInfo);
+vec3 getIridescenceTint(float iridescence, float thickness, float NdotV)
+{
+  if (iridescence <= 0.0) {
+    return vec3(1.0);
+  }
+
+  float phase = 0.015 * thickness * pbrMaterial.iridescenceIor + (1.0 - NdotV) * 6.0;
+  vec3 thinFilmTint =
+    0.5 + 0.5 * cos(vec3(phase, phase + 2.0943951, phase + 4.1887902));
+  return mix(vec3(1.0), thinFilmTint, iridescence);
+}
+
+vec3 getVolumeAttenuation(float thickness)
+{
+  if (thickness <= 0.0) {
+    return vec3(1.0);
+  }
+
+  vec3 attenuationCoefficient =
+    -log(max(pbrMaterial.attenuationColor, vec3(0.0001))) /
+    max(pbrMaterial.attenuationDistance, 0.0001);
+  return exp(-attenuationCoefficient * thickness);
+}
+
+PBRInfo createClearcoatPBRInfo(PBRInfo basePBRInfo, vec3 clearcoatNormal, float clearcoatRoughness)
+{
+  float perceptualRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+  float alphaRoughness = perceptualRoughness * perceptualRoughness;
+  float NdotV = clamp(abs(dot(clearcoatNormal, basePBRInfo.v)), 0.001, 1.0);
+
+  return PBRInfo(
+    basePBRInfo.NdotL,
+    NdotV,
+    basePBRInfo.NdotH,
+    basePBRInfo.LdotH,
+    basePBRInfo.VdotH,
+    perceptualRoughness,
+    0.0,
+    vec3(0.04),
+    vec3(1.0),
+    alphaRoughness,
+    vec3(0.0),
+    vec3(0.04),
+    clearcoatNormal,
+    basePBRInfo.v
+  );
+}
+
+vec3 calculateClearcoatContribution(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 clearcoatNormal,
+  float clearcoatFactor,
+  float clearcoatRoughness
+) {
+  if (clearcoatFactor <= 0.0) {
+    return vec3(0.0);
+  }
+
+  PBRInfo clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return calculateFinalColor(clearcoatPBRInfo, lightColor) * clearcoatFactor;
+}
+
+#ifdef USE_IBL
+vec3 calculateClearcoatIBLContribution(
+  PBRInfo pbrInfo,
+  vec3 clearcoatNormal,
+  vec3 reflection,
+  float clearcoatFactor,
+  float clearcoatRoughness
+) {
+  if (clearcoatFactor <= 0.0) {
+    return vec3(0.0);
+  }
+
+  PBRInfo clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return getIBLContribution(clearcoatPBRInfo, clearcoatNormal, reflection) * clearcoatFactor;
+}
+#endif
+
+vec3 calculateSheenContribution(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 sheenColor,
+  float sheenRoughness
+) {
+  if (maxComponent(sheenColor) <= 0.0) {
+    return vec3(0.0);
+  }
+
+  float sheenFresnel = pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+  float sheenVisibility = mix(1.0, pbrInfo.NdotL * pbrInfo.NdotV, sheenRoughness);
+  return pbrInfo.NdotL *
+    lightColor *
+    sheenColor *
+    (0.25 + 0.75 * sheenFresnel) *
+    sheenVisibility *
+    (1.0 - pbrInfo.metalness);
+}
+
+float calculateAnisotropyBoost(
+  PBRInfo pbrInfo,
+  vec3 anisotropyTangent,
+  float anisotropyStrength
+) {
+  if (anisotropyStrength <= 0.0) {
+    return 1.0;
+  }
+
+  vec3 anisotropyBitangent = normalize(cross(pbrInfo.n, anisotropyTangent));
+  float bitangentViewAlignment = abs(dot(pbrInfo.v, anisotropyBitangent));
+  return mix(1.0, 0.65 + 0.7 * bitangentViewAlignment, anisotropyStrength);
+}
+
+vec3 calculateMaterialLightColor(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 clearcoatNormal,
+  float clearcoatFactor,
+  float clearcoatRoughness,
+  vec3 sheenColor,
+  float sheenRoughness,
+  vec3 anisotropyTangent,
+  float anisotropyStrength
+) {
+  float anisotropyBoost = calculateAnisotropyBoost(pbrInfo, anisotropyTangent, anisotropyStrength);
+  vec3 color = calculateFinalColor(pbrInfo, lightColor) * anisotropyBoost;
+  color += calculateClearcoatContribution(
+    pbrInfo,
+    lightColor,
+    clearcoatNormal,
+    clearcoatFactor,
+    clearcoatRoughness
+  );
+  color += calculateSheenContribution(pbrInfo, lightColor, sheenColor, sheenRoughness);
+  return color;
+}
+
+void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
+  pbrInfo.NdotL = 1.0;
+  pbrInfo.NdotH = 0.0;
+  pbrInfo.LdotH = 0.0;
+  pbrInfo.VdotH = 1.0;
+}
+
+void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
+  vec3 n = pbrInfo.n;
+  vec3 v = pbrInfo.v;
+  vec3 l = normalize(lightDirection);             // Vector from surface point to light
+  vec3 h = normalize(l+v);                        // Half vector between both l and v
+
+  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
+  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
+  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
+  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
+}
+
+void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
+  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
+void PBRInfo_setSpotLight(inout PBRInfo pbrInfo, SpotLight spotLight) {
+  vec3 light_direction = normalize(spotLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
+vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
+  // Calculate the shading terms for the microfacet specular shading model
+  vec3 F = specularReflection(pbrInfo);
+  float G = geometricOcclusion(pbrInfo);
+  float D = microfacetDistribution(pbrInfo);
 
   // Calculation of analytical lighting contribution
   vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
@@ -3660,6 +4782,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
   vec3 color = vec3(0, 0, 0);
 
+  float transmission = 0.0;
+
   if(pbrMaterial.unlit){
     color.rgb = baseColor.rgb;
   }
@@ -3678,14 +4802,252 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #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
+    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
+    bool useExtendedPBR =
+      pbrMaterial.specularColorMapEnabled ||
+      pbrMaterial.specularIntensityMapEnabled ||
+      abs(pbrMaterial.specularIntensityFactor - 1.0) > 0.0001 ||
+      maxComponent(abs(pbrMaterial.specularColorFactor - vec3(1.0))) > 0.0001 ||
+      abs(pbrMaterial.ior - 1.5) > 0.0001 ||
+      pbrMaterial.transmissionMapEnabled ||
+      pbrMaterial.transmissionFactor > 0.0001 ||
+      pbrMaterial.clearcoatMapEnabled ||
+      pbrMaterial.clearcoatRoughnessMapEnabled ||
+      pbrMaterial.clearcoatFactor > 0.0001 ||
+      pbrMaterial.clearcoatRoughnessFactor > 0.0001 ||
+      pbrMaterial.sheenColorMapEnabled ||
+      pbrMaterial.sheenRoughnessMapEnabled ||
+      maxComponent(pbrMaterial.sheenColorFactor) > 0.0001 ||
+      pbrMaterial.sheenRoughnessFactor > 0.0001 ||
+      pbrMaterial.iridescenceMapEnabled ||
+      pbrMaterial.iridescenceFactor > 0.0001 ||
+      abs(pbrMaterial.iridescenceIor - 1.3) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.x - 100.0) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.y - 400.0) > 0.0001 ||
+      pbrMaterial.anisotropyMapEnabled ||
+      pbrMaterial.anisotropyStrength > 0.0001 ||
+      abs(pbrMaterial.anisotropyRotation) > 0.0001 ||
+      length(pbrMaterial.anisotropyDirection - vec2(1.0, 0.0)) > 0.0001;
+#else
+    bool useExtendedPBR = false;
+#endif
+
+    if (!useExtendedPBR) {
+      // Keep the baseline metallic-roughness implementation byte-for-byte equivalent in behavior.
+      float alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+      vec3 f0 = vec3(0.04);
+      vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
+      diffuseColor *= 1.0 - metallic;
+      vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+
+      float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+      float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+      vec3 specularEnvironmentR0 = specularColor.rgb;
+      vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
+      vec3 reflection = -normalize(reflect(v, n));
+
+      PBRInfo pbrInfo = PBRInfo(
+        0.0, // NdotL
+        NdotV,
+        0.0, // NdotH
+        0.0, // LdotH
+        0.0, // VdotH
+        perceptualRoughness,
+        metallic,
+        specularEnvironmentR0,
+        specularEnvironmentR90,
+        alphaRoughness,
+        diffuseColor,
+        specularColor,
+        n,
+        v
+      );
+
+#ifdef USE_LIGHTS
+      PBRInfo_setAmbientLight(pbrInfo);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+
+      for(int i = 0; i < lighting.directionalLightCount; i++) {
+        if (i < lighting.directionalLightCount) {
+          PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        }
+      }
+
+      for(int i = 0; i < lighting.pointLightCount; i++) {
+        if (i < lighting.pointLightCount) {
+          PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+          float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        }
+      }
+
+      for(int i = 0; i < lighting.spotLightCount; i++) {
+        if (i < lighting.spotLightCount) {
+          PBRInfo_setSpotLight(pbrInfo, lighting_getSpotLight(i));
+          float attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), pbr_vPosition);
+          color += calculateFinalColor(pbrInfo, lighting_getSpotLight(i).color / attenuation);
+        }
+      }
+#endif
+
+#ifdef USE_IBL
+      if (pbrMaterial.IBLenabled) {
+        color += getIBLContribution(pbrInfo, n, reflection);
+      }
+#endif
+
+#ifdef HAS_OCCLUSIONMAP
+      if (pbrMaterial.occlusionMapEnabled) {
+        float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+        color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+      }
+#endif
+
+      vec3 emissive = pbrMaterial.emissiveFactor;
+#ifdef HAS_EMISSIVEMAP
+      if (pbrMaterial.emissiveMapEnabled) {
+        emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb;
+      }
+#endif
+      color += emissive * pbrMaterial.emissiveStrength;
+
+#ifdef PBR_DEBUG
+      color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+      color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+      color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+#endif
+
+      return vec4(pow(color, vec3(1.0 / 2.2)), baseColor.a);
+    }
+
+    float specularIntensity = pbrMaterial.specularIntensityFactor;
+#ifdef HAS_SPECULARINTENSITYMAP
+    if (pbrMaterial.specularIntensityMapEnabled) {
+      specularIntensity *= texture(pbr_specularIntensitySampler, pbr_vUV).a;
+    }
+#endif
+
+    vec3 specularFactor = pbrMaterial.specularColorFactor;
+#ifdef HAS_SPECULARCOLORMAP
+    if (pbrMaterial.specularColorMapEnabled) {
+      specularFactor *= SRGBtoLINEAR(texture(pbr_specularColorSampler, pbr_vUV)).rgb;
+    }
+#endif
+
+    transmission = pbrMaterial.transmissionFactor;
+#ifdef HAS_TRANSMISSIONMAP
+    if (pbrMaterial.transmissionMapEnabled) {
+      transmission *= texture(pbr_transmissionSampler, pbr_vUV).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;
+#endif
+
+    float clearcoatFactor = pbrMaterial.clearcoatFactor;
+    float clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
+#ifdef HAS_CLEARCOATMAP
+    if (pbrMaterial.clearcoatMapEnabled) {
+      clearcoatFactor *= texture(pbr_clearcoatSampler, pbr_vUV).r;
+    }
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
+    if (pbrMaterial.clearcoatRoughnessMapEnabled) {
+      clearcoatRoughness *= texture(pbr_clearcoatRoughnessSampler, pbr_vUV).g;
+    }
+#endif
+    clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
+    clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+    vec3 clearcoatNormal = getClearcoatNormal(tbn, n);
+
+    vec3 sheenColor = pbrMaterial.sheenColorFactor;
+    float sheenRoughness = pbrMaterial.sheenRoughnessFactor;
+#ifdef HAS_SHEENCOLORMAP
+    if (pbrMaterial.sheenColorMapEnabled) {
+      sheenColor *= SRGBtoLINEAR(texture(pbr_sheenColorSampler, pbr_vUV)).rgb;
+    }
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
+    if (pbrMaterial.sheenRoughnessMapEnabled) {
+      sheenRoughness *= texture(pbr_sheenRoughnessSampler, pbr_vUV).a;
+    }
+#endif
+    sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
+
+    float iridescence = pbrMaterial.iridescenceFactor;
+#ifdef HAS_IRIDESCENCEMAP
+    if (pbrMaterial.iridescenceMapEnabled) {
+      iridescence *= texture(pbr_iridescenceSampler, pbr_vUV).r;
+    }
+#endif
+    iridescence = clamp(iridescence, 0.0, 1.0);
+    float iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      0.5
+    );
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+    iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      texture(pbr_iridescenceThicknessSampler, pbr_vUV).g
+    );
+#endif
+
+    float anisotropyStrength = clamp(pbrMaterial.anisotropyStrength, 0.0, 1.0);
+    vec2 anisotropyDirection = normalizeDirection(pbrMaterial.anisotropyDirection);
+#ifdef HAS_ANISOTROPYMAP
+    if (pbrMaterial.anisotropyMapEnabled) {
+      vec3 anisotropySample = texture(pbr_anisotropySampler, pbr_vUV).rgb;
+      anisotropyStrength *= anisotropySample.b;
+      vec2 mappedDirection = anisotropySample.rg * 2.0 - 1.0;
+      if (length(mappedDirection) > 0.0001) {
+        anisotropyDirection = normalize(mappedDirection);
+      }
+    }
+#endif
+    anisotropyDirection = rotateDirection(anisotropyDirection, pbrMaterial.anisotropyRotation);
+    vec3 anisotropyTangent = normalize(tbn[0] * anisotropyDirection.x + tbn[1] * anisotropyDirection.y);
+    if (length(anisotropyTangent) < 0.0001) {
+      anisotropyTangent = normalize(tbn[0]);
+    }
+    float anisotropyViewAlignment = abs(dot(v, anisotropyTangent));
+    perceptualRoughness = mix(
+      perceptualRoughness,
+      clamp(perceptualRoughness * (1.0 - 0.6 * anisotropyViewAlignment), c_MinRoughness, 1.0),
+      anisotropyStrength
+    );
+
     // Roughness is authored as perceptual roughness; as is convention,
     // convert to material roughness by squaring the perceptual roughness [2].
     float alphaRoughness = perceptualRoughness * perceptualRoughness;
 
-    vec3 f0 = vec3(0.04);
-    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
-    diffuseColor *= 1.0 - metallic;
-    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+    float dielectricF0 = getDielectricF0(pbrMaterial.ior);
+    vec3 dielectricSpecularF0 = min(
+      vec3(dielectricF0) * specularFactor * specularIntensity,
+      vec3(1.0)
+    );
+    vec3 iridescenceTint = getIridescenceTint(iridescence, iridescenceThickness, NdotV);
+    dielectricSpecularF0 = mix(
+      dielectricSpecularF0,
+      dielectricSpecularF0 * iridescenceTint,
+      iridescence
+    );
+    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - dielectricSpecularF0);
+    diffuseColor *= (1.0 - metallic) * (1.0 - transmission);
+    vec3 specularColor = mix(dielectricSpecularF0, baseColor.rgb, metallic);
+
+    float baseLayerEnergy = 1.0 - clearcoatFactor * 0.25;
+    diffuseColor *= baseLayerEnergy;
+    specularColor *= baseLayerEnergy;
 
     // Compute reflectance.
     float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
@@ -3697,11 +5059,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
     vec3 specularEnvironmentR0 = specularColor.rgb;
     vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
-
-    vec3 n = getNormal();                          // 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);
     vec3 reflection = -normalize(reflect(v, n));
 
     PBRInfo pbrInfo = PBRInfo(
@@ -3725,13 +5082,33 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef USE_LIGHTS
     // Apply ambient light
     PBRInfo_setAmbientLight(pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+    color += calculateMaterialLightColor(
+      pbrInfo,
+      lighting.ambientColor,
+      clearcoatNormal,
+      clearcoatFactor,
+      clearcoatRoughness,
+      sheenColor,
+      sheenRoughness,
+      anisotropyTangent,
+      anisotropyStrength
+    );
 
     // Apply directional light
     for(int i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
         PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
-        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getDirectionalLight(i).color,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
 
@@ -3740,7 +5117,35 @@ vec4 pbr_filterColor(vec4 colorUnused)
       if (i < lighting.pointLightCount) {
         PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
         float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
-        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getPointLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
+      }
+    }
+
+    for(int i = 0; i < lighting.spotLightCount; i++) {
+      if (i < lighting.spotLightCount) {
+        PBRInfo_setSpotLight(pbrInfo, lighting_getSpotLight(i));
+        float attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), pbr_vPosition);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getSpotLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
 #endif
@@ -3748,7 +5153,16 @@ vec4 pbr_filterColor(vec4 colorUnused)
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
     if (pbrMaterial.IBLenabled) {
-      color += getIBLContribution(pbrInfo, n, reflection);
+      color += getIBLContribution(pbrInfo, n, reflection) *
+        calculateAnisotropyBoost(pbrInfo, anisotropyTangent, anisotropyStrength);
+      color += calculateClearcoatIBLContribution(
+        pbrInfo,
+        clearcoatNormal,
+        -normalize(reflect(v, clearcoatNormal)),
+        clearcoatFactor,
+        clearcoatRoughness
+      );
+      color += sheenColor * pbrMaterial.scaleIBLAmbient.x * (1.0 - sheenRoughness) * 0.25;
     }
 #endif
 
@@ -3760,12 +5174,17 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
 #endif
 
+    vec3 emissive = pbrMaterial.emissiveFactor;
 #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled) {
-      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
-      color += emissive;
+      emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb;
     }
 #endif
+    color += emissive * pbrMaterial.emissiveStrength;
+
+    if (transmission > 0.0) {
+      color = mix(color, color * getVolumeAttenuation(thickness), transmission);
+    }
 
     // This section uses mix to override final color for reference app visualization
     // of various parameters in the lighting equation.
@@ -3785,7 +5204,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
   }
 
-  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
+  float alpha = clamp(baseColor.a * (1.0 - transmission), 0.0, 1.0);
+  return vec4(pow(color,vec3(1.0/2.2)), alpha);
 }
 `
 );
@@ -3851,6 +5271,42 @@ struct pbrMaterialUniforms {
   
   alphaCutoffEnabled: i32,
   alphaCutoff: f32, // #ifdef ALPHA_CUTOFF
+
+  specularColorFactor: vec3f,
+  specularIntensityFactor: f32,
+  specularColorMapEnabled: i32,
+  specularIntensityMapEnabled: i32,
+
+  ior: f32,
+
+  transmissionFactor: f32,
+  transmissionMapEnabled: i32,
+
+  thicknessFactor: f32,
+  attenuationDistance: f32,
+  attenuationColor: vec3f,
+
+  clearcoatFactor: f32,
+  clearcoatRoughnessFactor: f32,
+  clearcoatMapEnabled: i32,
+  clearcoatRoughnessMapEnabled: i32,
+
+  sheenColorFactor: vec3f,
+  sheenRoughnessFactor: f32,
+  sheenColorMapEnabled: i32,
+  sheenRoughnessMapEnabled: i32,
+
+  iridescenceFactor: f32,
+  iridescenceIor: f32,
+  iridescenceThicknessRange: vec2f,
+  iridescenceMapEnabled: i32,
+
+  anisotropyStrength: f32,
+  anisotropyRotation: f32,
+  anisotropyDirection: vec2f,
+  anisotropyMapEnabled: i32,
+
+  emissiveStrength: f32,
   
   // IBL
   IBLenabled: i32,
@@ -3863,38 +5319,77 @@ struct pbrMaterialUniforms {
   // #endif
 }
 
-@binding(2) @group(0) var<uniform> pbrMaterial : pbrMaterialUniforms;
+@group(3) @binding(auto) var<uniform> pbrMaterial : pbrMaterialUniforms;
 
 // Samplers
 #ifdef HAS_BASECOLORMAP
-@binding(3) @group(0) var pbr_baseColorSampler: texture_2d<f32>;
-@binding(4) @group(0) var pbr_baseColorSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_baseColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_baseColorSamplerSampler: sampler;
 #endif
 #ifdef HAS_NORMALMAP
-@binding(5) @group(0) var pbr_normalSampler: texture_2d<f32>;
-@binding(6) @group(0) var pbr_normalSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_normalSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_normalSamplerSampler: sampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-@binding(7) @group(0) var pbr_emissiveSampler: texture_2d<f32>;
-@binding(8) @group(0) var pbr_emissiveSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_emissiveSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_emissiveSamplerSampler: sampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-@binding(9) @group(0) var pbr_metallicRoughnessSampler: texture_2d<f32>;
-@binding(10) @group(0) var pbr_metallicRoughnessSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_metallicRoughnessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_metallicRoughnessSamplerSampler: sampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-@binding(11) @group(0) var pbr_occlusionSampler: texture_2d<f32>;
-@binding(12) @group(0) var pbr_occlusionSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_occlusionSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_occlusionSamplerSampler: sampler;
 #endif
-#ifdef USE_IBL
-@binding(13) @group(0) var pbr_diffuseEnvSampler: texture_cube<f32>;
-@binding(14) @group(0) var pbr_diffuseEnvSamplerSampler: sampler;
-@binding(15) @group(0) var pbr_specularEnvSampler: texture_cube<f32>;
-@binding(16) @group(0) var pbr_specularEnvSamplerSampler: sampler;
-@binding(17) @group(0) var pbr_BrdfLUT: texture_2d<f32>;
-@binding(18) @group(0) var pbr_BrdfLUTSampler: sampler;
+#ifdef HAS_SPECULARCOLORMAP
+@group(3) @binding(auto) var pbr_specularColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_specularColorSamplerSampler: sampler;
+#endif
+#ifdef HAS_SPECULARINTENSITYMAP
+@group(3) @binding(auto) var pbr_specularIntensitySampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_specularIntensitySamplerSampler: sampler;
+#endif
+#ifdef HAS_TRANSMISSIONMAP
+@group(3) @binding(auto) var pbr_transmissionSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_transmissionSamplerSampler: sampler;
+#endif
+#ifdef HAS_THICKNESSMAP
+@group(3) @binding(auto) var pbr_thicknessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_thicknessSamplerSampler: sampler;
+#endif
+#ifdef HAS_CLEARCOATMAP
+@group(3) @binding(auto) var pbr_clearcoatSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_clearcoatSamplerSampler: sampler;
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
+@group(3) @binding(auto) var pbr_clearcoatRoughnessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_clearcoatRoughnessSamplerSampler: sampler;
+#endif
+#ifdef HAS_CLEARCOATNORMALMAP
+@group(3) @binding(auto) var pbr_clearcoatNormalSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_clearcoatNormalSamplerSampler: sampler;
+#endif
+#ifdef HAS_SHEENCOLORMAP
+@group(3) @binding(auto) var pbr_sheenColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_sheenColorSamplerSampler: sampler;
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
+@group(3) @binding(auto) var pbr_sheenRoughnessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_sheenRoughnessSamplerSampler: sampler;
+#endif
+#ifdef HAS_IRIDESCENCEMAP
+@group(3) @binding(auto) var pbr_iridescenceSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_iridescenceSamplerSampler: sampler;
+#endif
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+@group(3) @binding(auto) var pbr_iridescenceThicknessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_iridescenceThicknessSamplerSampler: sampler;
+#endif
+#ifdef HAS_ANISOTROPYMAP
+@group(3) @binding(auto) var pbr_anisotropySampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_anisotropySamplerSampler: sampler;
 #endif
-
 // Encapsulate the various inputs used by the various functions in the shading equation
 // We store values in this struct to simplify the integration of alternative implementations
 // of the shading terms, outlined in the Readme.MD Appendix.
@@ -3935,11 +5430,9 @@ fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
   return vec4f(linOut, srgbIn.w);
 }
 
-// Find the normal for this fragment, pulling either from a predefined normal map
-// or from the interpolated mesh normal and tangent attributes.
-fn getNormal() -> vec3f
+// Build the tangent basis from interpolated attributes or screen-space derivatives.
+fn getTBN() -> mat3x3f
 {
-  // Retrieve the tangent space matrix
   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));
@@ -3957,16 +5450,52 @@ fn getNormal() -> vec3f
   tbn = fragmentInputs.pbr_vTBN;
 #endif
 
+  return tbn;
+}
+
+// Find the normal for this fragment, pulling either from a predefined normal map
+// or from the interpolated mesh normal and tangent attributes.
+fn getMappedNormal(
+  normalSampler: texture_2d<f32>,
+  normalSamplerBinding: sampler,
+  tbn: mat3x3f,
+  normalScale: f32
+) -> vec3f
+{
+  let n = textureSample(normalSampler, normalSamplerBinding, fragmentInputs.pbr_vUV).rgb;
+  return normalize(tbn * ((2.0 * n - 1.0) * vec3f(normalScale, normalScale, 1.0)));
+}
+
+fn getNormal(tbn: mat3x3f) -> vec3f
+{
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   var n: vec3f = normalize(tbn[2].xyz);
 #ifdef HAS_NORMALMAP
-  n = textureSample(pbr_normalSampler, pbr_normalSamplerSampler, fragmentInputs.pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3f(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
+  n = getMappedNormal(
+    pbr_normalSampler,
+    pbr_normalSamplerSampler,
+    tbn,
+    pbrMaterial.normalScale
+  );
 #endif
 
   return n;
 }
 
+fn getClearcoatNormal(tbn: mat3x3f, baseNormal: vec3f) -> vec3f
+{
+#ifdef HAS_CLEARCOATNORMALMAP
+  return getMappedNormal(
+    pbr_clearcoatNormalSampler,
+    pbr_clearcoatNormalSamplerSampler,
+    tbn,
+    1.0
+  );
+#else
+  return baseNormal;
+#endif
+}
+
 // Calculation of the lighting contribution from an optional Image Based Light source.
 // Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
 // See our README.md on Environment Maps [3] for additional discussion.
@@ -3977,17 +5506,25 @@ fn getIBLContribution(pbrInfo: PBRInfo, n: vec3f, reflection: vec3f) -> vec3f
   let lod: f32 = pbrInfo.perceptualRoughness * mipCount;
   // retrieve a scale and bias to F0. See [1], Figure 3
   let brdf = SRGBtoLINEAR(
-    textureSample(
-      pbr_BrdfLUT,
-      pbr_BrdfLUTSampler,
-      vec2f(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness)
+    textureSampleLevel(
+      pbr_brdfLUT,
+      pbr_brdfLUTSampler,
+      vec2f(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness),
+      0.0
     )
   ).rgb;
   let diffuseLight =
-    SRGBtoLINEAR(textureSample(pbr_diffuseEnvSampler, pbr_diffuseEnvSamplerSampler, n)).rgb;
-  let specularLightDefault =
-    SRGBtoLINEAR(textureSample(pbr_specularEnvSampler, pbr_specularEnvSamplerSampler, reflection)).rgb;
-  var specularLight = specularLightDefault;
+    SRGBtoLINEAR(
+      textureSampleLevel(pbr_diffuseEnvSampler, pbr_diffuseEnvSamplerSampler, n, 0.0)
+    ).rgb;
+  var specularLight = SRGBtoLINEAR(
+    textureSampleLevel(
+      pbr_specularEnvSampler,
+      pbr_specularEnvSamplerSampler,
+      reflection,
+      0.0
+    )
+  ).rgb;
 #ifdef USE_TEX_LOD
   specularLight = SRGBtoLINEAR(
     textureSampleLevel(
@@ -4048,6 +5585,172 @@ fn microfacetDistribution(pbrInfo: PBRInfo) -> f32 {
   return roughnessSq / (M_PI * f * f);
 }
 
+fn maxComponent(value: vec3f) -> f32 {
+  return max(max(value.r, value.g), value.b);
+}
+
+fn getDielectricF0(ior: f32) -> f32 {
+  let clampedIor = max(ior, 1.0);
+  let ratio = (clampedIor - 1.0) / (clampedIor + 1.0);
+  return ratio * ratio;
+}
+
+fn normalizeDirection(direction: vec2f) -> vec2f {
+  let directionLength = length(direction);
+  if (directionLength > 0.0001) {
+    return direction / directionLength;
+  }
+
+  return vec2f(1.0, 0.0);
+}
+
+fn rotateDirection(direction: vec2f, rotation: f32) -> vec2f {
+  let s = sin(rotation);
+  let c = cos(rotation);
+  return vec2f(direction.x * c - direction.y * s, direction.x * s + direction.y * c);
+}
+
+fn getIridescenceTint(iridescence: f32, thickness: f32, NdotV: f32) -> vec3f {
+  if (iridescence <= 0.0) {
+    return vec3f(1.0);
+  }
+
+  let phase = 0.015 * thickness * pbrMaterial.iridescenceIor + (1.0 - NdotV) * 6.0;
+  let thinFilmTint =
+    0.5 +
+    0.5 *
+    cos(vec3f(phase, phase + 2.0943951, phase + 4.1887902));
+  return mix(vec3f(1.0), thinFilmTint, iridescence);
+}
+
+fn getVolumeAttenuation(thickness: f32) -> vec3f {
+  if (thickness <= 0.0) {
+    return vec3f(1.0);
+  }
+
+  let attenuationCoefficient =
+    -log(max(pbrMaterial.attenuationColor, vec3f(0.0001))) /
+    max(pbrMaterial.attenuationDistance, 0.0001);
+  return exp(-attenuationCoefficient * thickness);
+}
+
+fn createClearcoatPBRInfo(
+  basePBRInfo: PBRInfo,
+  clearcoatNormal: vec3f,
+  clearcoatRoughness: f32
+) -> PBRInfo {
+  let perceptualRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+  let alphaRoughness = perceptualRoughness * perceptualRoughness;
+  let NdotV = clamp(abs(dot(clearcoatNormal, basePBRInfo.v)), 0.001, 1.0);
+
+  return PBRInfo(
+    basePBRInfo.NdotL,
+    NdotV,
+    basePBRInfo.NdotH,
+    basePBRInfo.LdotH,
+    basePBRInfo.VdotH,
+    perceptualRoughness,
+    0.0,
+    vec3f(0.04),
+    vec3f(1.0),
+    alphaRoughness,
+    vec3f(0.0),
+    vec3f(0.04),
+    clearcoatNormal,
+    basePBRInfo.v
+  );
+}
+
+fn calculateClearcoatContribution(
+  pbrInfo: PBRInfo,
+  lightColor: vec3f,
+  clearcoatNormal: vec3f,
+  clearcoatFactor: f32,
+  clearcoatRoughness: f32
+) -> vec3f {
+  if (clearcoatFactor <= 0.0) {
+    return vec3f(0.0);
+  }
+
+  let clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return calculateFinalColor(clearcoatPBRInfo, lightColor) * clearcoatFactor;
+}
+
+#ifdef USE_IBL
+fn calculateClearcoatIBLContribution(
+  pbrInfo: PBRInfo,
+  clearcoatNormal: vec3f,
+  reflection: vec3f,
+  clearcoatFactor: f32,
+  clearcoatRoughness: f32
+) -> vec3f {
+  if (clearcoatFactor <= 0.0) {
+    return vec3f(0.0);
+  }
+
+  let clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return getIBLContribution(clearcoatPBRInfo, clearcoatNormal, reflection) * clearcoatFactor;
+}
+#endif
+
+fn calculateSheenContribution(
+  pbrInfo: PBRInfo,
+  lightColor: vec3f,
+  sheenColor: vec3f,
+  sheenRoughness: f32
+) -> vec3f {
+  if (maxComponent(sheenColor) <= 0.0) {
+    return vec3f(0.0);
+  }
+
+  let sheenFresnel = pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+  let sheenVisibility = mix(1.0, pbrInfo.NdotL * pbrInfo.NdotV, sheenRoughness);
+  return pbrInfo.NdotL *
+    lightColor *
+    sheenColor *
+    (0.25 + 0.75 * sheenFresnel) *
+    sheenVisibility *
+    (1.0 - pbrInfo.metalness);
+}
+
+fn calculateAnisotropyBoost(
+  pbrInfo: PBRInfo,
+  anisotropyTangent: vec3f,
+  anisotropyStrength: f32
+) -> f32 {
+  if (anisotropyStrength <= 0.0) {
+    return 1.0;
+  }
+
+  let anisotropyBitangent = normalize(cross(pbrInfo.n, anisotropyTangent));
+  let bitangentViewAlignment = abs(dot(pbrInfo.v, anisotropyBitangent));
+  return mix(1.0, 0.65 + 0.7 * bitangentViewAlignment, anisotropyStrength);
+}
+
+fn calculateMaterialLightColor(
+  pbrInfo: PBRInfo,
+  lightColor: vec3f,
+  clearcoatNormal: vec3f,
+  clearcoatFactor: f32,
+  clearcoatRoughness: f32,
+  sheenColor: vec3f,
+  sheenRoughness: f32,
+  anisotropyTangent: vec3f,
+  anisotropyStrength: f32
+) -> vec3f {
+  let anisotropyBoost = calculateAnisotropyBoost(pbrInfo, anisotropyTangent, anisotropyStrength);
+  var color = calculateFinalColor(pbrInfo, lightColor) * anisotropyBoost;
+  color += calculateClearcoatContribution(
+    pbrInfo,
+    lightColor,
+    clearcoatNormal,
+    clearcoatFactor,
+    clearcoatRoughness
+  );
+  color += calculateSheenContribution(pbrInfo, lightColor, sheenColor, sheenRoughness);
+  return color;
+}
+
 fn PBRInfo_setAmbientLight(pbrInfo: ptr<function, PBRInfo>) {
   (*pbrInfo).NdotL = 1.0;
   (*pbrInfo).NdotH = 0.0;
@@ -4072,6 +5775,11 @@ fn PBRInfo_setPointLight(pbrInfo: ptr<function, PBRInfo>, pointLight: PointLight
   PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
+fn PBRInfo_setSpotLight(pbrInfo: ptr<function, PBRInfo>, spotLight: SpotLight) {
+  let light_direction = normalize(spotLight.position - fragmentInputs.pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
 fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
   // Calculate the shading terms for the microfacet specular shading model
   let F = specularReflection(pbrInfo);
@@ -4101,6 +5809,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   #endif
 
   var color = vec3<f32>(0.0, 0.0, 0.0);
+  var transmission = 0.0;
 
   if (pbrMaterial.unlit != 0u) {
     color = baseColor.rgb;
@@ -4123,14 +5832,308 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #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 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;
+    #ifdef USE_MATERIAL_EXTENSIONS
+    useExtendedPBR =
+      pbrMaterial.specularColorMapEnabled != 0 ||
+      pbrMaterial.specularIntensityMapEnabled != 0 ||
+      abs(pbrMaterial.specularIntensityFactor - 1.0) > 0.0001 ||
+      maxComponent(abs(pbrMaterial.specularColorFactor - vec3f(1.0))) > 0.0001 ||
+      abs(pbrMaterial.ior - 1.5) > 0.0001 ||
+      pbrMaterial.transmissionMapEnabled != 0 ||
+      pbrMaterial.transmissionFactor > 0.0001 ||
+      pbrMaterial.clearcoatMapEnabled != 0 ||
+      pbrMaterial.clearcoatRoughnessMapEnabled != 0 ||
+      pbrMaterial.clearcoatFactor > 0.0001 ||
+      pbrMaterial.clearcoatRoughnessFactor > 0.0001 ||
+      pbrMaterial.sheenColorMapEnabled != 0 ||
+      pbrMaterial.sheenRoughnessMapEnabled != 0 ||
+      maxComponent(pbrMaterial.sheenColorFactor) > 0.0001 ||
+      pbrMaterial.sheenRoughnessFactor > 0.0001 ||
+      pbrMaterial.iridescenceMapEnabled != 0 ||
+      pbrMaterial.iridescenceFactor > 0.0001 ||
+      abs(pbrMaterial.iridescenceIor - 1.3) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.x - 100.0) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.y - 400.0) > 0.0001 ||
+      pbrMaterial.anisotropyMapEnabled != 0 ||
+      pbrMaterial.anisotropyStrength > 0.0001 ||
+      abs(pbrMaterial.anisotropyRotation) > 0.0001 ||
+      length(pbrMaterial.anisotropyDirection - vec2f(1.0, 0.0)) > 0.0001;
+    #endif
+
+    if (!useExtendedPBR) {
+      let alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+      let f0 = vec3<f32>(0.04);
+      var diffuseColor = baseColor.rgb * (vec3<f32>(1.0) - f0);
+      diffuseColor *= 1.0 - metallic;
+      let specularColor = mix(f0, baseColor.rgb, metallic);
+
+      let reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+      let reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+      let specularEnvironmentR0 = specularColor;
+      let specularEnvironmentR90 = vec3<f32>(1.0, 1.0, 1.0) * reflectance90;
+      let reflection = -normalize(reflect(v, n));
+
+      var pbrInfo = PBRInfo(
+        0.0, // NdotL
+        NdotV,
+        0.0, // NdotH
+        0.0, // LdotH
+        0.0, // VdotH
+        perceptualRoughness,
+        metallic,
+        specularEnvironmentR0,
+        specularEnvironmentR90,
+        alphaRoughness,
+        diffuseColor,
+        specularColor,
+        n,
+        v
+      );
+
+      #ifdef USE_LIGHTS
+      PBRInfo_setAmbientLight(&pbrInfo);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+
+      for (var i = 0; i < lighting.directionalLightCount; i++) {
+        if (i < lighting.directionalLightCount) {
+          PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
+          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        }
+      }
+
+      for (var i = 0; i < lighting.pointLightCount; i++) {
+        if (i < lighting.pointLightCount) {
+          PBRInfo_setPointLight(&pbrInfo, lighting_getPointLight(i));
+          let attenuation = getPointLightAttenuation(
+            lighting_getPointLight(i),
+            distance(lighting_getPointLight(i).position, fragmentInputs.pbr_vPosition)
+          );
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        }
+      }
+
+      for (var i = 0; i < lighting.spotLightCount; i++) {
+        if (i < lighting.spotLightCount) {
+          PBRInfo_setSpotLight(&pbrInfo, lighting_getSpotLight(i));
+          let attenuation = getSpotLightAttenuation(
+            lighting_getSpotLight(i),
+            fragmentInputs.pbr_vPosition
+          );
+          color += calculateFinalColor(pbrInfo, lighting_getSpotLight(i).color / attenuation);
+        }
+      }
+      #endif
+
+      #ifdef USE_IBL
+      if (pbrMaterial.IBLenabled != 0) {
+        color += getIBLContribution(pbrInfo, n, reflection);
+      }
+      #endif
+
+      #ifdef HAS_OCCLUSIONMAP
+      if (pbrMaterial.occlusionMapEnabled != 0) {
+        let ao =
+          textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, fragmentInputs.pbr_vUV).r;
+        color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+      }
+      #endif
+
+      var emissive = pbrMaterial.emissiveFactor;
+      #ifdef HAS_EMISSIVEMAP
+      if (pbrMaterial.emissiveMapEnabled != 0u) {
+        emissive *= SRGBtoLINEAR(
+          textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
+        ).rgb;
+      }
+      #endif
+      color += emissive * pbrMaterial.emissiveStrength;
+
+      #ifdef PBR_DEBUG
+      color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+      color = mix(color, vec3<f32>(metallic), pbrMaterial.scaleDiffBaseMR.z);
+      color = mix(color, vec3<f32>(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+      #endif
+
+      return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), baseColor.a);
+    }
+
+    var specularIntensity = pbrMaterial.specularIntensityFactor;
+    #ifdef HAS_SPECULARINTENSITYMAP
+    if (pbrMaterial.specularIntensityMapEnabled != 0) {
+      specularIntensity *= textureSample(
+        pbr_specularIntensitySampler,
+        pbr_specularIntensitySamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).a;
+    }
+    #endif
+
+    var specularFactor = pbrMaterial.specularColorFactor;
+    #ifdef HAS_SPECULARCOLORMAP
+    if (pbrMaterial.specularColorMapEnabled != 0) {
+      specularFactor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_specularColorSampler,
+          pbr_specularColorSamplerSampler,
+          fragmentInputs.pbr_vUV
+        )
+      ).rgb;
+    }
+    #endif
+
+    transmission = pbrMaterial.transmissionFactor;
+    #ifdef HAS_TRANSMISSIONMAP
+    if (pbrMaterial.transmissionMapEnabled != 0) {
+      transmission *= textureSample(
+        pbr_transmissionSampler,
+        pbr_transmissionSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).r;
+    }
+    #endif
+    transmission = clamp(transmission * (1.0 - metallic), 0.0, 1.0);
+    var thickness = max(pbrMaterial.thicknessFactor, 0.0);
+    #ifdef HAS_THICKNESSMAP
+    thickness *= textureSample(
+      pbr_thicknessSampler,
+      pbr_thicknessSamplerSampler,
+      fragmentInputs.pbr_vUV
+    ).g;
+    #endif
+
+    var clearcoatFactor = pbrMaterial.clearcoatFactor;
+    var clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
+    #ifdef HAS_CLEARCOATMAP
+    if (pbrMaterial.clearcoatMapEnabled != 0) {
+      clearcoatFactor *= textureSample(
+        pbr_clearcoatSampler,
+        pbr_clearcoatSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).r;
+    }
+    #endif
+    #ifdef HAS_CLEARCOATROUGHNESSMAP
+    if (pbrMaterial.clearcoatRoughnessMapEnabled != 0) {
+      clearcoatRoughness *= textureSample(
+        pbr_clearcoatRoughnessSampler,
+        pbr_clearcoatRoughnessSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).g;
+    }
+    #endif
+    clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
+    clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+    let clearcoatNormal = getClearcoatNormal(tbn, n);
+
+    var sheenColor = pbrMaterial.sheenColorFactor;
+    var sheenRoughness = pbrMaterial.sheenRoughnessFactor;
+    #ifdef HAS_SHEENCOLORMAP
+    if (pbrMaterial.sheenColorMapEnabled != 0) {
+      sheenColor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_sheenColorSampler,
+          pbr_sheenColorSamplerSampler,
+          fragmentInputs.pbr_vUV
+        )
+      ).rgb;
+    }
+    #endif
+    #ifdef HAS_SHEENROUGHNESSMAP
+    if (pbrMaterial.sheenRoughnessMapEnabled != 0) {
+      sheenRoughness *= textureSample(
+        pbr_sheenRoughnessSampler,
+        pbr_sheenRoughnessSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).a;
+    }
+    #endif
+    sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
+
+    var iridescence = pbrMaterial.iridescenceFactor;
+    #ifdef HAS_IRIDESCENCEMAP
+    if (pbrMaterial.iridescenceMapEnabled != 0) {
+      iridescence *= textureSample(
+        pbr_iridescenceSampler,
+        pbr_iridescenceSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).r;
+    }
+    #endif
+    iridescence = clamp(iridescence, 0.0, 1.0);
+    var iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      0.5
+    );
+    #ifdef HAS_IRIDESCENCETHICKNESSMAP
+    iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      textureSample(
+        pbr_iridescenceThicknessSampler,
+        pbr_iridescenceThicknessSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).g
+    );
+    #endif
+
+    var anisotropyStrength = clamp(pbrMaterial.anisotropyStrength, 0.0, 1.0);
+    var anisotropyDirection = normalizeDirection(pbrMaterial.anisotropyDirection);
+    #ifdef HAS_ANISOTROPYMAP
+    if (pbrMaterial.anisotropyMapEnabled != 0) {
+      let anisotropySample = textureSample(
+        pbr_anisotropySampler,
+        pbr_anisotropySamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).rgb;
+      anisotropyStrength *= anisotropySample.b;
+      let mappedDirection = anisotropySample.rg * 2.0 - 1.0;
+      if (length(mappedDirection) > 0.0001) {
+        anisotropyDirection = normalize(mappedDirection);
+      }
+    }
+    #endif
+    anisotropyDirection = rotateDirection(anisotropyDirection, pbrMaterial.anisotropyRotation);
+    var anisotropyTangent =
+      normalize(tbn[0] * anisotropyDirection.x + tbn[1] * anisotropyDirection.y);
+    if (length(anisotropyTangent) < 0.0001) {
+      anisotropyTangent = normalize(tbn[0]);
+    }
+    let anisotropyViewAlignment = abs(dot(v, anisotropyTangent));
+    perceptualRoughness = mix(
+      perceptualRoughness,
+      clamp(perceptualRoughness * (1.0 - 0.6 * anisotropyViewAlignment), c_MinRoughness, 1.0),
+      anisotropyStrength
+    );
+
     // Roughness is authored as perceptual roughness; as is convention,
     // convert to material roughness by squaring the perceptual roughness [2].
     let alphaRoughness = perceptualRoughness * perceptualRoughness;
 
-    let f0 = vec3<f32>(0.04);
-    var diffuseColor = baseColor.rgb * (vec3<f32>(1.0) - f0);
-    diffuseColor *= 1.0 - metallic;
-    let specularColor = mix(f0, baseColor.rgb, metallic);
+    let dielectricF0 = getDielectricF0(pbrMaterial.ior);
+    var dielectricSpecularF0 = min(
+      vec3f(dielectricF0) * specularFactor * specularIntensity,
+      vec3f(1.0)
+    );
+    let iridescenceTint = getIridescenceTint(iridescence, iridescenceThickness, NdotV);
+    dielectricSpecularF0 = mix(
+      dielectricSpecularF0,
+      dielectricSpecularF0 * iridescenceTint,
+      iridescence
+    );
+    var diffuseColor = baseColor.rgb * (vec3f(1.0) - dielectricSpecularF0);
+    diffuseColor *= (1.0 - metallic) * (1.0 - transmission);
+    var specularColor = mix(dielectricSpecularF0, baseColor.rgb, metallic);
+
+    let baseLayerEnergy = 1.0 - clearcoatFactor * 0.25;
+    diffuseColor *= baseLayerEnergy;
+    specularColor *= baseLayerEnergy;
 
     // Compute reflectance.
     let reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
@@ -4142,11 +6145,6 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     let reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
     let specularEnvironmentR0 = specularColor;
     let specularEnvironmentR90 = vec3<f32>(1.0, 1.0, 1.0) * reflectance90;
-
-    let n = getNormal();                          // 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);
     let reflection = -normalize(reflect(v, n));
 
     var pbrInfo = PBRInfo(
@@ -4169,13 +6167,33 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #ifdef USE_LIGHTS
     // Apply ambient light
     PBRInfo_setAmbientLight(&pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+    color += calculateMaterialLightColor(
+      pbrInfo,
+      lighting.ambientColor,
+      clearcoatNormal,
+      clearcoatFactor,
+      clearcoatRoughness,
+      sheenColor,
+      sheenRoughness,
+      anisotropyTangent,
+      anisotropyStrength
+    );
 
     // Apply directional light
     for (var i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
         PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
-        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getDirectionalLight(i).color,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
 
@@ -4187,7 +6205,35 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
           lighting_getPointLight(i),
           distance(lighting_getPointLight(i).position, fragmentInputs.pbr_vPosition)
         );
-        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getPointLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
+      }
+    }
+
+    for (var i = 0; i < lighting.spotLightCount; i++) {
+      if (i < lighting.spotLightCount) {
+        PBRInfo_setSpotLight(&pbrInfo, lighting_getSpotLight(i));
+        let attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), fragmentInputs.pbr_vPosition);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getSpotLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
     #endif
@@ -4195,7 +6241,16 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     // Calculate lighting contribution from image based lighting source (IBL)
     #ifdef USE_IBL
     if (pbrMaterial.IBLenabled != 0) {
-      color += getIBLContribution(pbrInfo, n, reflection);
+      color += getIBLContribution(pbrInfo, n, reflection) *
+        calculateAnisotropyBoost(pbrInfo, anisotropyTangent, anisotropyStrength);
+      color += calculateClearcoatIBLContribution(
+        pbrInfo,
+        clearcoatNormal,
+        -normalize(reflect(v, clearcoatNormal)),
+        clearcoatFactor,
+        clearcoatRoughness
+      );
+      color += sheenColor * pbrMaterial.scaleIBLAmbient.x * (1.0 - sheenRoughness) * 0.25;
     }
     #endif
 
@@ -4208,14 +6263,19 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     }
     #endif
 
+    var emissive = pbrMaterial.emissiveFactor;
     #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled != 0u) {
-      let emissive = SRGBtoLINEAR(
+      emissive *= SRGBtoLINEAR(
         textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
-      ).rgb * pbrMaterial.emissiveFactor;
-      color += emissive;
+      ).rgb;
     }
     #endif
+    color += emissive * pbrMaterial.emissiveStrength;
+
+    if (transmission > 0.0) {
+      color = mix(color, color * getVolumeAttenuation(thickness), transmission);
+    }
 
     // This section uses mix to override final color for reference app visualization
     // of various parameters in the lighting equation.
@@ -4234,7 +6294,8 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #endif
   }
 
-  return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), baseColor.a);
+  let alpha = clamp(baseColor.a * (1.0 - transmission), 0.0, 1.0);
+  return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), alpha);
 }
 `
 );
@@ -4259,11 +6320,12 @@ var wgslUniformBlock = (
   camera: vec3<f32>
 };
 
-@binding(0) @group(0) var<uniform> pbrProjection: pbrProjectionUniforms;
+@group(0) @binding(auto) var<uniform> pbrProjection: pbrProjectionUniforms;
 `
 );
 var pbrProjection = {
   name: "pbrProjection",
+  bindingLayout: [{ name: "pbrProjection", group: 0 }],
   source: wgslUniformBlock,
   vs: uniformBlock,
   fs: uniformBlock,
@@ -4281,8 +6343,75 @@ var pbrProjection = {
 var pbrMaterial = {
   props: {},
   uniforms: {},
+  defaultUniforms: {
+    unlit: false,
+    baseColorMapEnabled: false,
+    baseColorFactor: [1, 1, 1, 1],
+    normalMapEnabled: false,
+    normalScale: 1,
+    emissiveMapEnabled: false,
+    emissiveFactor: [0, 0, 0],
+    metallicRoughnessValues: [1, 1],
+    metallicRoughnessMapEnabled: false,
+    occlusionMapEnabled: false,
+    occlusionStrength: 1,
+    alphaCutoffEnabled: false,
+    alphaCutoff: 0.5,
+    IBLenabled: false,
+    scaleIBLAmbient: [1, 1],
+    scaleDiffBaseMR: [0, 0, 0, 0],
+    scaleFGDSpec: [0, 0, 0, 0],
+    specularColorFactor: [1, 1, 1],
+    specularIntensityFactor: 1,
+    specularColorMapEnabled: false,
+    specularIntensityMapEnabled: false,
+    ior: 1.5,
+    transmissionFactor: 0,
+    transmissionMapEnabled: false,
+    thicknessFactor: 0,
+    attenuationDistance: 1e9,
+    attenuationColor: [1, 1, 1],
+    clearcoatFactor: 0,
+    clearcoatRoughnessFactor: 0,
+    clearcoatMapEnabled: false,
+    clearcoatRoughnessMapEnabled: false,
+    sheenColorFactor: [0, 0, 0],
+    sheenRoughnessFactor: 0,
+    sheenColorMapEnabled: false,
+    sheenRoughnessMapEnabled: false,
+    iridescenceFactor: 0,
+    iridescenceIor: 1.3,
+    iridescenceThicknessRange: [100, 400],
+    iridescenceMapEnabled: false,
+    anisotropyStrength: 0,
+    anisotropyRotation: 0,
+    anisotropyDirection: [1, 0],
+    anisotropyMapEnabled: false,
+    emissiveStrength: 1
+  },
   name: "pbrMaterial",
-  dependencies: [lighting, pbrProjection],
+  firstBindingSlot: 0,
+  bindingLayout: [
+    { name: "pbrMaterial", group: 3 },
+    { name: "pbr_baseColorSampler", group: 3 },
+    { name: "pbr_normalSampler", group: 3 },
+    { name: "pbr_emissiveSampler", group: 3 },
+    { name: "pbr_metallicRoughnessSampler", group: 3 },
+    { name: "pbr_occlusionSampler", group: 3 },
+    { name: "pbr_specularColorSampler", group: 3 },
+    { name: "pbr_specularIntensitySampler", group: 3 },
+    { name: "pbr_transmissionSampler", group: 3 },
+    { name: "pbr_thicknessSampler", group: 3 },
+    { name: "pbr_clearcoatSampler", group: 3 },
+    { name: "pbr_clearcoatRoughnessSampler", group: 3 },
+    { name: "pbr_clearcoatNormalSampler", group: 3 },
+    { name: "pbr_sheenColorSampler", group: 3 },
+    { name: "pbr_sheenRoughnessSampler", group: 3 },
+    { name: "pbr_iridescenceSampler", group: 3 },
+    { name: "pbr_iridescenceThicknessSampler", group: 3 },
+    { name: "pbr_anisotropySampler", group: 3 }
+  ],
+  dependencies: [lighting, ibl, pbrProjection],
   source: source3,
   vs: vs3,
   fs: fs4,
@@ -4296,10 +6425,16 @@ var pbrMaterial = {
     HAS_SPECULARCOLORMAP: false,
     HAS_SPECULARINTENSITYMAP: false,
     HAS_TRANSMISSIONMAP: false,
+    HAS_THICKNESSMAP: false,
     HAS_CLEARCOATMAP: false,
+    HAS_CLEARCOATROUGHNESSMAP: false,
+    HAS_CLEARCOATNORMALMAP: false,
     HAS_SHEENCOLORMAP: false,
+    HAS_SHEENROUGHNESSMAP: false,
     HAS_IRIDESCENCEMAP: false,
+    HAS_IRIDESCENCETHICKNESSMAP: false,
     HAS_ANISOTROPYMAP: false,
+    USE_MATERIAL_EXTENSIONS: false,
     ALPHA_CUTOFF: false,
     USE_IBL: false,
     PBR_DEBUG: false
@@ -4325,14 +6460,6 @@ var pbrMaterial = {
     alphaCutoffEnabled: "i32",
     alphaCutoff: "f32",
     // #ifdef ALPHA_CUTOFF
-    // IBL
-    IBLenabled: "i32",
-    scaleIBLAmbient: "vec2<f32>",
-    // #ifdef USE_IBL
-    // debugging flags used for shader output of intermediate PBR variables
-    // #ifdef PBR_DEBUG
-    scaleDiffBaseMR: "vec4<f32>",
-    scaleFGDSpec: "vec4<f32>",
     specularColorFactor: "vec3<f32>",
     specularIntensityFactor: "f32",
     specularColorMapEnabled: "i32",
@@ -4346,9 +6473,11 @@ var pbrMaterial = {
     clearcoatFactor: "f32",
     clearcoatRoughnessFactor: "f32",
     clearcoatMapEnabled: "i32",
+    clearcoatRoughnessMapEnabled: "i32",
     sheenColorFactor: "vec3<f32>",
     sheenRoughnessFactor: "f32",
     sheenColorMapEnabled: "i32",
+    sheenRoughnessMapEnabled: "i32",
     iridescenceFactor: "f32",
     iridescenceIor: "f32",
     iridescenceThicknessRange: "vec2<f32>",
@@ -4357,7 +6486,15 @@ var pbrMaterial = {
     anisotropyRotation: "f32",
     anisotropyDirection: "vec2<f32>",
     anisotropyMapEnabled: "i32",
-    emissiveStrength: "f32"
+    emissiveStrength: "f32",
+    // IBL
+    IBLenabled: "i32",
+    scaleIBLAmbient: "vec2<f32>",
+    // #ifdef USE_IBL
+    // debugging flags used for shader output of intermediate PBR variables
+    // #ifdef PBR_DEBUG
+    scaleDiffBaseMR: "vec4<f32>",
+    scaleFGDSpec: "vec4<f32>"
   }
 };
 //# sourceMappingURL=index.cjs.map