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

package/dist/dist.dev.js

@@ -75,10 +75,15 @@ var __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,
@@ -88,7 +93,8 @@ var __exports__ = (() => {
     skin: () => skin,
     toHalfFloat: () => toHalfFloat,
     typeToChannelCount: () => typeToChannelCount,
-    typeToChannelSuffix: () => typeToChannelSuffix
+    typeToChannelSuffix: () => typeToChannelSuffix,
+    validateShaderModuleUniformLayout: () => validateShaderModuleUniformLayout
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
@@ -409,6 +415,123 @@ ${inject[key]}` : inject[key];
     return getShaderDependencies(modules);
   }
 
+  // src/lib/shader-module/shader-module-uniform-layout.ts
+  function getShaderModuleUniformBlockName(module) {
+    return `${module.name}Uniforms`;
+  }
+  function getShaderModuleUniformBlockFields(module, stage) {
+    const shaderSource = stage === "wgsl" ? module.source : stage === "vertex" ? module.vs : module.fs;
+    if (!shaderSource) {
+      return null;
+    }
+    const uniformBlockName = getShaderModuleUniformBlockName(module);
+    return extractShaderUniformBlockFieldNames(
+      shaderSource,
+      stage === "wgsl" ? "wgsl" : "glsl",
+      uniformBlockName
+    );
+  }
+  function getShaderModuleUniformLayoutValidationResult(module, stage) {
+    const expectedUniformNames = Object.keys(module.uniformTypes || {});
+    if (!expectedUniformNames.length) {
+      return null;
+    }
+    const actualUniformNames = getShaderModuleUniformBlockFields(module, stage);
+    if (!actualUniformNames) {
+      return null;
+    }
+    return {
+      moduleName: module.name,
+      uniformBlockName: getShaderModuleUniformBlockName(module),
+      stage,
+      expectedUniformNames,
+      actualUniformNames,
+      matches: areStringArraysEqual(expectedUniformNames, actualUniformNames)
+    };
+  }
+  function validateShaderModuleUniformLayout(module, stage, options = {}) {
+    const validationResult = getShaderModuleUniformLayoutValidationResult(module, stage);
+    if (!validationResult || validationResult.matches) {
+      return validationResult;
+    }
+    const message = formatShaderModuleUniformLayoutError(validationResult);
+    options.log?.error?.(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?.[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(", ")}`;
+  }
+
   // src/lib/shader-assembly/platform-defines.ts
   function getPlatformShaderDefines(platformInfo) {
     switch (platformInfo?.gpu.toLowerCase()) {
@@ -593,11 +716,166 @@ ${inject[key]}` : inject[key];
     return version;
   }
 
+  // src/lib/shader-assembly/wgsl-binding-debug.ts
+  var WGSL_BINDING_DEBUG_REGEXES = [
+    /@binding\(\s*(\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*var(?:<([^>]+)>)?\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^;]+);/g,
+    /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(\d+)\s*\)\s*var(?:<([^>]+)>)?\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^;]+);/g
+  ];
+  function getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments = []) {
+    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 = match[3]?.trim();
+        const name = match[4];
+        const resourceType = match[5].trim();
+        const moduleName = assignmentMap.get(getBindingAssignmentKey(name, group, binding));
+        rows.push(
+          normalizeShaderBindingDebugRow({
+            name,
+            group,
+            binding,
+            owner: moduleName ? "module" : "application",
+            moduleName,
+            accessDeclaration,
+            resourceType
+          })
+        );
+      }
+    }
+    return rows.sort((left, right) => {
+      if (left.group !== right.group) {
+        return left.group - right.group;
+      }
+      if (left.binding !== right.binding) {
+        return left.binding - right.binding;
+      }
+      return left.name.localeCompare(right.name);
+    });
+  }
+  function normalizeShaderBindingDebugRow(row) {
+    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?.[1];
+  }
+
   // src/lib/shader-assembly/assemble-shaders.ts
   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;
@@ -605,14 +883,17 @@ ${DECLARATION_INJECT_MARKER}
   );
   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) {
@@ -673,11 +954,28 @@ ${DECLARATION_INJECT_MARKER}
       }
     }
     const modulesToInject = modules;
+    const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(coreSource);
+    const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(
+      modulesToInject,
+      options._bindingRegistry,
+      usedBindingsByGroup
+    );
+    const bindingAssignments = [];
     for (const module of modulesToInject) {
       if (log2) {
         checkShaderModuleDeprecations(module, coreSource, log2);
       }
-      const moduleSource = getShaderModuleSource(module, "wgsl");
+      const relocation = relocateWGSLModuleBindings(
+        getShaderModuleSource(module, "wgsl", log2),
+        module,
+        {
+          usedBindingsByGroup,
+          bindingRegistry: options._bindingRegistry,
+          reservedBindingKeysByGroup
+        }
+      );
+      bindingAssignments.push(...relocation.bindingAssignments);
+      const moduleSource = relocation.source;
       assembledSource += moduleSource;
       const injections = module.injections?.[stage] || {};
       for (const key in injections) {
@@ -696,9 +994,11 @@ ${DECLARATION_INJECT_MARKER}
     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) {
     const {
@@ -771,7 +1071,7 @@ ${getApplicationDefines(allDefines)}
       if (log2) {
         checkShaderModuleDeprecations(module, coreSource, log2);
       }
-      const moduleSource = getShaderModuleSource(module, stage);
+      const moduleSource = getShaderModuleSource(module, stage, log2);
       assembledSource += moduleSource;
       const injections = module.instance?.normalizedInjections[stage] || {};
       for (const key in injections) {
@@ -819,7 +1119,7 @@ ${getApplicationDefines(allDefines)}
     }
     return sourceText;
   }
-  function getShaderModuleSource(module, stage) {
+  function getShaderModuleSource(module, stage, log2) {
     let moduleSource;
     switch (stage) {
       case "vertex":
@@ -837,6 +1137,7 @@ ${getApplicationDefines(allDefines)}
     if (!module.name) {
       throw new Error("Shader module must have a name");
     }
+    validateShaderModuleUniformLayout(module, stage, { log: log2 });
     const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
     let source4 = `// ----- MODULE ${module.name} ---------------
 
@@ -849,13 +1150,225 @@ ${getApplicationDefines(allDefines)}
 `;
     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, module, context) {
+    const bindingAssignments = [];
+    const relocationState = {
+      sawSupportedBindingDeclaration: false,
+      nextHintedBindingLocation: typeof module.firstBindingSlot === "number" ? module.firstBindingSlot : null
+    };
+    let relocatedSource = relocateWGSLModuleBindingsWithRegex(
+      moduleSource,
+      MODULE_WGSL_BINDING_DECLARATION_REGEXES[0],
+      { isBindingFirst: true, module, context, bindingAssignments, relocationState }
+    );
+    relocatedSource = relocateWGSLModuleBindingsWithRegex(
+      relocatedSource,
+      MODULE_WGSL_BINDING_DECLARATION_REGEXES[1],
+      { isBindingFirst: false, module, context, bindingAssignments, relocationState }
+    );
+    if (moduleSource.includes("@binding(auto)") && !relocationState.sawSupportedBindingDeclaration) {
+      throw new Error(
+        `Unsupported @binding(auto) declaration form in module "${module.name}". Use "@group(N) @binding(auto) var ..." or "@binding(auto) @group(N) var ..." on a single line.`
+      );
+    }
+    return { source: relocatedSource, bindingAssignments };
+  }
+  function relocateWGSLModuleBindingsWithRegex(source4, regex, params) {
+    return source4.replace(
+      regex,
+      (...replaceArguments) => relocateWGSLModuleBindingMatch(replaceArguments, params)
+    );
+  }
+  function relocateWGSLModuleBindingMatch(replaceArguments, params) {
+    const { isBindingFirst, module, context, bindingAssignments, relocationState } = params;
+    relocationState.sawSupportedBindingDeclaration = true;
+    const match = replaceArguments[0];
+    const bindingToken = replaceArguments[isBindingFirst ? 1 : 2];
+    const groupToken = replaceArguments[isBindingFirst ? 2 : 1];
+    const name = replaceArguments[4];
+    const group = Number(groupToken);
+    if (bindingToken === "auto") {
+      const registryKey = getBindingRegistryKey(group, module.name, name);
+      const registryLocation = context.bindingRegistry?.get(registryKey);
+      const location2 = registryLocation !== void 0 ? registryLocation : relocationState.nextHintedBindingLocation === null ? allocateAutoBindingLocation(group, context.usedBindingsByGroup) : allocateAutoBindingLocation(
+        group,
+        context.usedBindingsByGroup,
+        relocationState.nextHintedBindingLocation
+      );
+      validateModuleWGSLBinding(module.name, group, location2, name);
+      if (registryLocation !== void 0 && claimReservedBindingLocation(context.reservedBindingKeysByGroup, group, location2, registryKey)) {
+        bindingAssignments.push({ moduleName: module.name, name, group, location: location2 });
+        return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location2})`);
+      }
+      registerUsedBindingLocation(
+        context.usedBindingsByGroup,
+        group,
+        location2,
+        `module "${module.name}" binding "${name}"`
+      );
+      context.bindingRegistry?.set(registryKey, location2);
+      bindingAssignments.push({ moduleName: module.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(module.name, group, location, name);
+    registerUsedBindingLocation(
+      context.usedBindingsByGroup,
+      group,
+      location,
+      `module "${module.name}" binding "${name}"`
+    );
+    bindingAssignments.push({ moduleName: module.name, name, group, location });
+    return match;
+  }
+  function reserveRegisteredModuleBindings(modules, bindingRegistry, usedBindingsByGroup) {
+    const reservedBindingKeysByGroup = /* @__PURE__ */ new Map();
+    if (!bindingRegistry) {
+      return reservedBindingKeysByGroup;
+    }
+    for (const module of modules) {
+      for (const binding of getModuleWGSLBindingDeclarations(module)) {
+        const registryKey = getBindingRegistryKey(binding.group, module.name, binding.name);
+        const location = bindingRegistry.get(registryKey);
+        if (location !== 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(module) {
+    const declarations = [];
+    const moduleSource = module.source || "";
+    for (const regex of MODULE_WGSL_BINDING_DECLARATION_REGEXES) {
+      regex.lastIndex = 0;
+      let match;
+      while (match = regex.exec(moduleSource)) {
+        const isBindingFirst = regex === MODULE_WGSL_BINDING_DECLARATION_REGEXES[0];
+        declarations.push({
+          name: match[4],
+          group: Number(match[isBindingFirst ? 2 : 1])
+        });
+      }
+    }
+    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}`;
+  }
 
   // src/lib/preprocessor/preprocessor.ts
-  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) {
     const lines = source4.split("\n");
@@ -901,6 +1414,8 @@ ${getApplicationDefines(allDefines)}
     _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
@@ -946,10 +1461,11 @@ ${getApplicationDefines(allDefines)}
     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
       });
@@ -961,7 +1477,13 @@ ${getApplicationDefines(allDefines)}
         ...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
@@ -1126,6 +1648,11 @@ void main() {
       case "uniforms":
     }
     for (const [uniformName, uniformFormat] of Object.entries(module.uniformTypes || {})) {
+      if (typeof uniformFormat !== "string") {
+        throw new Error(
+          `Composite uniform types are not supported by GLSL shader generation: ${module.name}.${uniformName}`
+        );
+      }
       const glslUniformType = getGLSLUniformType(uniformFormat);
       switch (options.uniforms) {
         case "scoped-interface-blocks":
@@ -1186,6 +1713,11 @@ void main() {
     const wgsl = [];
     wgsl.push(`struct ${capitalize(module.name)} {`);
     for (const [uniformName, uniformFormat] of Object.entries(module?.uniformTypes || {})) {
+      if (typeof uniformFormat !== "string") {
+        throw new Error(
+          `Composite uniform types are not supported by WGSL shader generation: ${module.name}.${uniformName}`
+        );
+      }
       const wgslUniformType = uniformFormat;
       wgsl.push(`  ${uniformName} : ${wgslUniformType};`);
     }
@@ -3190,6 +3722,7 @@ float tan_fp32(float a) {
     `
 uniform fp64arithmeticUniforms {
   uniform float ONE;
+  uniform float SPLIT;
 } fp64;
 
 /*
@@ -3199,6 +3732,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
@@ -3207,17 +3746,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);
 }
 
@@ -3281,8 +3826,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);
 }
 
@@ -3358,6 +3921,218 @@ vec2 sqrt_fp64(vec2 a) {
 `
   );
 
+  // src/modules/math/fp64/fp64-arithmetic-wgsl.ts
+  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
+}
+`
+  );
+
   // src/modules/math/fp64/fp64-functions-glsl.ts
   var fp64functionShader = (
     /* glsl */
@@ -4036,13 +4811,18 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
   // src/modules/math/fp64/fp64.ts
   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,
@@ -4255,7 +5035,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])
@@ -4289,6 +5069,7 @@ mat4 getSkinMatrix(vec4 weights, uvec4 joints) {
     props: {},
     uniforms: {},
     name: "skin",
+    bindingLayout: [{ name: "skin", group: 0 }],
     dependencies: [],
     source: source2,
     vs: vs2,
@@ -4331,10 +5112,7 @@ mat4 getSkinMatrix(vec4 weights, uvec4 joints) {
       };
     },
     uniformTypes: {
-      jointMatrix: "mat4x4<f32>"
-    },
-    uniformSizes: {
-      jointMatrix: SKIN_MAX_JOINTS
+      jointMatrix: ["mat4x4<f32>", SKIN_MAX_JOINTS]
     }
   };
 
@@ -4357,77 +5135,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
@@ -4435,6 +5187,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
 `
   );
@@ -4455,100 +5221,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);
+}
 `
   );
 
   // src/modules/lighting/lights/lighting.ts
   var MAX_LIGHTS = 5;
   var COLOR_FACTOR = 255;
+  var LIGHT_UNIFORM_TYPE = {
+    color: "vec3<f32>",
+    position: "vec3<f32>",
+    direction: "vec3<f32>",
+    attenuation: "vec3<f32>",
+    coneCos: "vec2<f32>"
+  };
   var lighting = {
     props: {},
     uniforms: {},
@@ -4558,83 +5309,39 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
     },
     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: 0 /* 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;
@@ -4644,45 +5351,67 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
   function getLightSourceUniforms({
     ambientLight,
     pointLights = [],
+    spotLights = [],
     directionalLights = []
   }) {
-    const lightSourceUniforms = {};
-    lightSourceUniforms.ambientColor = convertColor(ambientLight);
+    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 = 0 /* 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 = 1 /* 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) {
-    const lightSources = { pointLights: [], directionalLights: [] };
+    const lightSources = { pointLights: [], spotLights: [], directionalLights: [] };
     for (const light of lights || []) {
       switch (light.type) {
         case "ambient":
@@ -4694,6 +5423,9 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
         case "point":
           lightSources.pointLights?.push(light);
           break;
+        case "spot":
+          lightSources.spotLights?.push(light);
+          break;
         default:
       }
     }
@@ -4703,6 +5435,68 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
     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)];
+  }
+
+  // src/modules/lighting/ibl/ibl.ts
+  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
+  };
 
   // src/modules/lighting/no-material/dirlight.ts
   var SOURCE_WGSL = (
@@ -4718,7 +5512,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 {
@@ -4763,6 +5557,8 @@ vec4 dirlight_filterColor(vec4 color) {
     props: {},
     uniforms: {},
     name: "dirlight",
+    bindingLayout: [{ name: "dirlight", group: 2 }],
+    firstBindingSlot: 16,
     dependencies: [],
     source: SOURCE_WGSL,
     vs: VS_GLSL,
@@ -4789,10 +5585,173 @@ vec4 dirlight_filterColor(vec4 color) {
     return uniforms;
   }
 
+  // src/modules/lighting/lambert-material/lambert-shaders-wgsl.ts
+  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;
+}
+`
+  );
+
+  // src/modules/lighting/lambert-material/lambert-shaders-glsl.ts
+  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;
+}
+`
+  );
+
+  // src/modules/lighting/lambert-material/lambert-material.ts
+  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 };
+    }
+  };
+
   // src/modules/lighting/phong-material/phong-shaders-glsl.ts
   var PHONG_VS = (
     /* glsl */
     `uniform phongMaterialUniforms {
+  uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -4802,9 +5761,8 @@ vec4 dirlight_filterColor(vec4 color) {
   );
   var PHONG_FS = (
     /* glsl */
-    `#define MAX_LIGHTS 3
-
-uniform phongMaterialUniforms {
+    `uniform phongMaterialUniforms {
+  uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -4826,6 +5784,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;
   }
@@ -4841,8 +5803,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);
   }
@@ -4856,13 +5825,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);
@@ -4879,6 +5849,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;
   }
@@ -4903,8 +5877,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);
   }  
@@ -4936,8 +5923,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);
     }
@@ -4951,6 +5951,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"),
@@ -4960,12 +5961,14 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
     },
     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,
@@ -4983,6 +5986,8 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
   // src/modules/lighting/phong-material/phong-material.ts
   var phongMaterial = {
     name: "phongMaterial",
+    firstBindingSlot: 0,
+    bindingLayout: [{ name: "phongMaterial", group: 3 }],
     dependencies: [lighting],
     // Note these are switched between phong and gouraud
     source: PHONG_WGSL,
@@ -4992,12 +5997,14 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       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,
@@ -5094,10 +6101,12 @@ uniform pbrMaterialUniforms {
   float clearcoatFactor;
   float clearcoatRoughnessFactor;
   bool clearcoatMapEnabled;
+  bool clearcoatRoughnessMapEnabled;
 
   vec3 sheenColorFactor;
   float sheenRoughnessFactor;
   bool sheenColorMapEnabled;
+  bool sheenRoughnessMapEnabled;
 
   float iridescenceFactor;
   float iridescenceIor;
@@ -5147,26 +6156,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;
@@ -5203,6 +6219,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
@@ -5218,11 +6236,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);
@@ -5243,9 +6259,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);
@@ -5254,6 +6282,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.
@@ -5329,7 +6366,170 @@ float microfacetDistribution(PBRInfo pbrInfo)
   return roughnessSq / (M_PI * f * f);
 }
 
-void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
+float maxComponent(vec3 value)
+{
+  return max(max(value.r, value.g), value.b);
+}
+
+float getDielectricF0(float ior)
+{
+  float clampedIor = max(ior, 1.0);
+  float ratio = (clampedIor - 1.0) / (clampedIor + 1.0);
+  return ratio * ratio;
+}
+
+vec2 normalizeDirection(vec2 direction)
+{
+  float directionLength = length(direction);
+  return directionLength > 0.0001 ? direction / directionLength : vec2(1.0, 0.0);
+}
+
+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 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;
@@ -5353,6 +6553,11 @@ void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
   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);
@@ -5383,6 +6588,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
   vec3 color = vec3(0, 0, 0);
 
+  float transmission = 0.0;
+
   if(pbrMaterial.unlit){
     color.rgb = baseColor.rgb;
   }
@@ -5401,14 +6608,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);
@@ -5420,11 +6865,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(
@@ -5448,13 +6888,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
+        );
       }
     }
 
@@ -5463,7 +6923,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
@@ -5471,7 +6959,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
 
@@ -5483,12 +6980,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.
@@ -5508,7 +7010,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);
 }
 `
   );
@@ -5574,6 +7077,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,
@@ -5586,38 +7125,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.
@@ -5658,11 +7236,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));
@@ -5680,16 +7256,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.
@@ -5700,17 +7312,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(
@@ -5771,6 +7391,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;
@@ -5795,6 +7581,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);
@@ -5824,6 +7615,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;
@@ -5846,14 +7638,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);
@@ -5865,11 +7951,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(
@@ -5892,13 +7973,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
+        );
       }
     }
 
@@ -5910,7 +8011,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
@@ -5918,7 +8047,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
 
@@ -5931,14 +8069,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.
@@ -5957,7 +8100,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);
 }
 `
   );
@@ -5982,11 +8126,12 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   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,
@@ -6004,8 +8149,75 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   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,
@@ -6019,10 +8231,16 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       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
@@ -6048,14 +8266,6 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       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",
@@ -6069,9 +8279,11 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       clearcoatFactor: "f32",
       clearcoatRoughnessFactor: "f32",
       clearcoatMapEnabled: "i32",
+      clearcoatRoughnessMapEnabled: "i32",
       sheenColorFactor: "vec3<f32>",
       sheenRoughnessFactor: "f32",
       sheenColorMapEnabled: "i32",
+      sheenRoughnessMapEnabled: "i32",
       iridescenceFactor: "f32",
       iridescenceIor: "f32",
       iridescenceThicknessRange: "vec2<f32>",
@@ -6080,7 +8292,15 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       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>"
     }
   };
   return __toCommonJS(bundle_exports);