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

package/dist/index.cjs

@@ -47,19 +47,26 @@ __export(dist_exports, {
   getShaderInfo: () => getShaderInfo,
   getShaderModuleDependencies: () => getShaderModuleDependencies,
   getShaderModuleSource: () => getShaderModuleSource,
+  getShaderModuleUniformBlockFields: () => getShaderModuleUniformBlockFields,
+  getShaderModuleUniformBlockName: () => getShaderModuleUniformBlockName,
+  getShaderModuleUniformLayoutValidationResult: () => getShaderModuleUniformLayoutValidationResult,
   getShaderModuleUniforms: () => getShaderModuleUniforms,
   gouraudMaterial: () => gouraudMaterial,
+  ibl: () => ibl,
   initializeShaderModule: () => initializeShaderModule,
   initializeShaderModules: () => initializeShaderModules,
+  lambertMaterial: () => lambertMaterial,
   lighting: () => lighting,
   pbrMaterial: () => pbrMaterial,
   phongMaterial: () => phongMaterial,
   picking: () => picking,
   preprocess: () => preprocess,
   random: () => random,
+  skin: () => skin,
   toHalfFloat: () => toHalfFloat,
   typeToChannelCount: () => typeToChannelCount,
-  typeToChannelSuffix: () => typeToChannelSuffix
+  typeToChannelSuffix: () => typeToChannelSuffix,
+  validateShaderModuleUniformLayout: () => validateShaderModuleUniformLayout
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -204,7 +211,7 @@ function getHookStage(hook) {
       throw new Error(type);
   }
 }
-function injectShader(source3, stage, inject, injectStandardStubs = false) {
+function injectShader(source4, stage, inject, injectStandardStubs = false) {
   const isVertex = stage === "vertex";
   for (const key in inject) {
     const fragmentData = inject[key];
@@ -218,43 +225,43 @@ function injectShader(source3, stage, inject, injectStandardStubs = false) {
     switch (key) {
       case "vs:#decl":
         if (isVertex) {
-          source3 = source3.replace(DECLARATION_INJECT_MARKER, fragmentString);
+          source4 = source4.replace(DECLARATION_INJECT_MARKER, fragmentString);
         }
         break;
       case "vs:#main-start":
         if (isVertex) {
-          source3 = source3.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+          source4 = source4.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
         }
         break;
       case "vs:#main-end":
         if (isVertex) {
-          source3 = source3.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+          source4 = source4.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
         }
         break;
       case "fs:#decl":
         if (!isVertex) {
-          source3 = source3.replace(DECLARATION_INJECT_MARKER, fragmentString);
+          source4 = source4.replace(DECLARATION_INJECT_MARKER, fragmentString);
         }
         break;
       case "fs:#main-start":
         if (!isVertex) {
-          source3 = source3.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
+          source4 = source4.replace(REGEX_START_OF_MAIN, (match) => match + fragmentString);
         }
         break;
       case "fs:#main-end":
         if (!isVertex) {
-          source3 = source3.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
+          source4 = source4.replace(REGEX_END_OF_MAIN, (match) => fragmentString + match);
         }
         break;
       default:
-        source3 = source3.replace(key, (match) => match + fragmentString);
+        source4 = source4.replace(key, (match) => match + fragmentString);
     }
   }
-  source3 = source3.replace(DECLARATION_INJECT_MARKER, "");
+  source4 = source4.replace(DECLARATION_INJECT_MARKER, "");
   if (injectStandardStubs) {
-    source3 = source3.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[stage]);
+    source4 = source4.replace(/\}\s*$/, (match) => match + MODULE_INJECTORS[stage]);
   }
-  return source3;
+  return source4;
 }
 function combineInjects(injects) {
   const result = {};
@@ -378,6 +385,114 @@ function resolveModules(modules) {
   return getShaderDependencies(modules);
 }
 
+// dist/lib/shader-module/shader-module-uniform-layout.js
+function getShaderModuleUniformBlockName(module2) {
+  return `${module2.name}Uniforms`;
+}
+function getShaderModuleUniformBlockFields(module2, stage) {
+  const shaderSource = stage === "wgsl" ? module2.source : stage === "vertex" ? module2.vs : module2.fs;
+  if (!shaderSource) {
+    return null;
+  }
+  const uniformBlockName = getShaderModuleUniformBlockName(module2);
+  return extractShaderUniformBlockFieldNames(shaderSource, stage === "wgsl" ? "wgsl" : "glsl", uniformBlockName);
+}
+function getShaderModuleUniformLayoutValidationResult(module2, stage) {
+  const expectedUniformNames = Object.keys(module2.uniformTypes || {});
+  if (!expectedUniformNames.length) {
+    return null;
+  }
+  const actualUniformNames = getShaderModuleUniformBlockFields(module2, stage);
+  if (!actualUniformNames) {
+    return null;
+  }
+  return {
+    moduleName: module2.name,
+    uniformBlockName: getShaderModuleUniformBlockName(module2),
+    stage,
+    expectedUniformNames,
+    actualUniformNames,
+    matches: areStringArraysEqual(expectedUniformNames, actualUniformNames)
+  };
+}
+function validateShaderModuleUniformLayout(module2, stage, options = {}) {
+  var _a, _b;
+  const validationResult = getShaderModuleUniformLayoutValidationResult(module2, stage);
+  if (!validationResult || validationResult.matches) {
+    return validationResult;
+  }
+  const message = formatShaderModuleUniformLayoutError(validationResult);
+  (_b = (_a = options.log) == null ? void 0 : _a.error) == null ? void 0 : _b.call(_a, message, validationResult)();
+  if (options.throwOnError !== false) {
+    assert(false, message);
+  }
+  return validationResult;
+}
+function extractShaderUniformBlockFieldNames(shaderSource, language, uniformBlockName) {
+  const sourceBody = language === "wgsl" ? extractWGSLStructBody(shaderSource, uniformBlockName) : extractGLSLUniformBlockBody(shaderSource, uniformBlockName);
+  if (!sourceBody) {
+    return null;
+  }
+  const fieldNames = [];
+  for (const sourceLine of sourceBody.split("\n")) {
+    const line = sourceLine.replace(/\/\/.*$/, "").trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const fieldMatch = language === "wgsl" ? line.match(/^([A-Za-z0-9_]+)\s*:/) : line.match(/^(?:uniform\s+)?[A-Za-z0-9_]+(?:<[^>]+>)?\s+([A-Za-z0-9_]+)(?:\s*\[[^\]]+\])?\s*;/);
+    if (fieldMatch) {
+      fieldNames.push(fieldMatch[1]);
+    }
+  }
+  return fieldNames;
+}
+function extractWGSLStructBody(shaderSource, uniformBlockName) {
+  const structMatch = new RegExp(`\\bstruct\\s+${uniformBlockName}\\b`, "m").exec(shaderSource);
+  if (!structMatch) {
+    return null;
+  }
+  const openBraceIndex = shaderSource.indexOf("{", structMatch.index);
+  if (openBraceIndex < 0) {
+    return null;
+  }
+  let braceDepth = 0;
+  for (let index = openBraceIndex; index < shaderSource.length; index++) {
+    const character = shaderSource[index];
+    if (character === "{") {
+      braceDepth++;
+      continue;
+    }
+    if (character !== "}") {
+      continue;
+    }
+    braceDepth--;
+    if (braceDepth === 0) {
+      return shaderSource.slice(openBraceIndex + 1, index);
+    }
+  }
+  return null;
+}
+function extractGLSLUniformBlockBody(shaderSource, uniformBlockName) {
+  const sourceMatch = shaderSource.match(new RegExp(`uniform\\s+${uniformBlockName}\\s*\\{([\\s\\S]*?)\\}\\s*[A-Za-z0-9_]+\\s*;`, "m"));
+  return (sourceMatch == null ? void 0 : sourceMatch[1]) || null;
+}
+function areStringArraysEqual(leftValues, rightValues) {
+  if (leftValues.length !== rightValues.length) {
+    return false;
+  }
+  for (let valueIndex = 0; valueIndex < leftValues.length; valueIndex++) {
+    if (leftValues[valueIndex] !== rightValues[valueIndex]) {
+      return false;
+    }
+  }
+  return true;
+}
+function formatShaderModuleUniformLayoutError(validationResult) {
+  return `${validationResult.moduleName}: ${validationResult.stage} shader uniform block ${validationResult.uniformBlockName} does not match module.uniformTypes.
+Expected: ${validationResult.expectedUniformNames.join(", ")}
+Actual: ${validationResult.actualUniformNames.join(", ")}`;
+}
+
 // dist/lib/shader-assembly/platform-defines.js
 function getPlatformShaderDefines(platformInfo) {
   switch (platformInfo == null ? void 0 : platformInfo.gpu.toLowerCase()) {
@@ -434,19 +549,19 @@ function getPlatformShaderDefines(platformInfo) {
 }
 
 // dist/lib/shader-transpiler/transpile-glsl-shader.js
-function transpileGLSLShader(source3, stage) {
+function transpileGLSLShader(source4, stage) {
   var _a;
-  const sourceGLSLVersion = Number(((_a = source3.match(/^#version[ \t]+(\d+)/m)) == null ? void 0 : _a[1]) || 100);
+  const sourceGLSLVersion = Number(((_a = source4.match(/^#version[ \t]+(\d+)/m)) == null ? void 0 : _a[1]) || 100);
   if (sourceGLSLVersion !== 300) {
     throw new Error("luma.gl v9 only supports GLSL 3.00 shader sources");
   }
   switch (stage) {
     case "vertex":
-      source3 = convertShader(source3, ES300_VERTEX_REPLACEMENTS);
-      return source3;
+      source4 = convertShader(source4, ES300_VERTEX_REPLACEMENTS);
+      return source4;
     case "fragment":
-      source3 = convertShader(source3, ES300_FRAGMENT_REPLACEMENTS);
-      return source3;
+      source4 = convertShader(source4, ES300_FRAGMENT_REPLACEMENTS);
+      return source4;
     default:
       throw new Error(stage);
   }
@@ -470,11 +585,11 @@ var ES300_FRAGMENT_REPLACEMENTS = [
   // `varying` keyword replaced with `in`
   [makeVariableTextRegExp("varying"), "in $1"]
 ];
-function convertShader(source3, replacements) {
+function convertShader(source4, replacements) {
   for (const [pattern, replacement] of replacements) {
-    source3 = source3.replace(pattern, replacement);
+    source4 = source4.replace(pattern, replacement);
   }
-  return source3;
+  return source4;
 }
 function makeVariableTextRegExp(qualifier) {
   return new RegExp(`\\b${qualifier}[ \\t]+(\\w+[ \\t]+\\w+(\\[\\w+\\])?;)`, "g");
@@ -536,11 +651,11 @@ function normalizeShaderHooks(hookFunctions) {
 }
 
 // dist/lib/glsl-utils/get-shader-info.js
-function getShaderInfo(source3, defaultName) {
+function getShaderInfo(source4, defaultName) {
   return {
-    name: getShaderName(source3, defaultName),
+    name: getShaderName(source4, defaultName),
     language: "glsl",
-    version: getShaderVersion(source3)
+    version: getShaderVersion(source4)
   };
 }
 function getShaderName(shader, defaultName = "unnamed") {
@@ -548,9 +663,9 @@ function getShaderName(shader, defaultName = "unnamed") {
   const match = SHADER_NAME_REGEXP.exec(shader);
   return match ? match[1] : defaultName;
 }
-function getShaderVersion(source3) {
+function getShaderVersion(source4) {
   let version = 100;
-  const words = source3.match(/[^\s]+/g);
+  const words = source4.match(/[^\s]+/g);
   if (words && words.length >= 2 && words[0] === "#version") {
     const parsedVersion = parseInt(words[1], 10);
     if (Number.isFinite(parsedVersion)) {
@@ -563,11 +678,158 @@ function getShaderVersion(source3) {
   return version;
 }
 
+// dist/lib/shader-assembly/wgsl-binding-debug.js
+var WGSL_BINDING_DEBUG_REGEXES = [
+  /@binding\(\s*(\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*var(?:<([^>]+)>)?\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^;]+);/g,
+  /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(\d+)\s*\)\s*var(?:<([^>]+)>)?\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^;]+);/g
+];
+function getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments = []) {
+  var _a;
+  const assignmentMap = /* @__PURE__ */ new Map();
+  for (const bindingAssignment of bindingAssignments) {
+    assignmentMap.set(getBindingAssignmentKey(bindingAssignment.name, bindingAssignment.group, bindingAssignment.location), bindingAssignment.moduleName);
+  }
+  const rows = [];
+  for (const regex of WGSL_BINDING_DEBUG_REGEXES) {
+    regex.lastIndex = 0;
+    let match;
+    while (match = regex.exec(source4)) {
+      const isBindingFirst = regex === WGSL_BINDING_DEBUG_REGEXES[0];
+      const binding = Number(match[isBindingFirst ? 1 : 2]);
+      const group = Number(match[isBindingFirst ? 2 : 1]);
+      const accessDeclaration = (_a = match[3]) == null ? void 0 : _a.trim();
+      const name = match[4];
+      const resourceType = match[5].trim();
+      const moduleName = assignmentMap.get(getBindingAssignmentKey(name, group, binding));
+      rows.push(normalizeShaderBindingDebugRow({
+        name,
+        group,
+        binding,
+        owner: moduleName ? "module" : "application",
+        moduleName,
+        accessDeclaration,
+        resourceType
+      }));
+    }
+  }
+  return rows.sort((left, right) => {
+    if (left.group !== right.group) {
+      return left.group - right.group;
+    }
+    if (left.binding !== right.binding) {
+      return left.binding - right.binding;
+    }
+    return left.name.localeCompare(right.name);
+  });
+}
+function normalizeShaderBindingDebugRow(row) {
+  const baseRow = {
+    name: row.name,
+    group: row.group,
+    binding: row.binding,
+    owner: row.owner,
+    kind: "unknown",
+    moduleName: row.moduleName,
+    resourceType: row.resourceType
+  };
+  if (row.accessDeclaration) {
+    const access = row.accessDeclaration.split(",").map((value) => value.trim());
+    if (access[0] === "uniform") {
+      return { ...baseRow, kind: "uniform", access: "uniform" };
+    }
+    if (access[0] === "storage") {
+      const storageAccess = access[1] || "read_write";
+      return {
+        ...baseRow,
+        kind: storageAccess === "read" ? "read-only-storage" : "storage",
+        access: storageAccess
+      };
+    }
+  }
+  if (row.resourceType === "sampler" || row.resourceType === "sampler_comparison") {
+    return {
+      ...baseRow,
+      kind: "sampler",
+      samplerKind: row.resourceType === "sampler_comparison" ? "comparison" : "filtering"
+    };
+  }
+  if (row.resourceType.startsWith("texture_storage_")) {
+    return {
+      ...baseRow,
+      kind: "storage-texture",
+      access: getStorageTextureAccess(row.resourceType),
+      viewDimension: getTextureViewDimension(row.resourceType)
+    };
+  }
+  if (row.resourceType.startsWith("texture_")) {
+    return {
+      ...baseRow,
+      kind: "texture",
+      viewDimension: getTextureViewDimension(row.resourceType),
+      sampleType: getTextureSampleType(row.resourceType),
+      multisampled: row.resourceType.startsWith("texture_multisampled_")
+    };
+  }
+  return baseRow;
+}
+function getBindingAssignmentKey(name, group, binding) {
+  return `${group}:${binding}:${name}`;
+}
+function getTextureViewDimension(resourceType) {
+  if (resourceType.includes("cube_array")) {
+    return "cube-array";
+  }
+  if (resourceType.includes("2d_array")) {
+    return "2d-array";
+  }
+  if (resourceType.includes("cube")) {
+    return "cube";
+  }
+  if (resourceType.includes("3d")) {
+    return "3d";
+  }
+  if (resourceType.includes("2d")) {
+    return "2d";
+  }
+  if (resourceType.includes("1d")) {
+    return "1d";
+  }
+  return void 0;
+}
+function getTextureSampleType(resourceType) {
+  if (resourceType.startsWith("texture_depth_")) {
+    return "depth";
+  }
+  if (resourceType.includes("<i32>")) {
+    return "sint";
+  }
+  if (resourceType.includes("<u32>")) {
+    return "uint";
+  }
+  if (resourceType.includes("<f32>")) {
+    return "float";
+  }
+  return void 0;
+}
+function getStorageTextureAccess(resourceType) {
+  const match = /,\s*([A-Za-z_][A-Za-z0-9_]*)\s*>$/.exec(resourceType);
+  return match == null ? void 0 : match[1];
+}
+
 // dist/lib/shader-assembly/assemble-shaders.js
 var INJECT_SHADER_DECLARATIONS = `
 
 ${DECLARATION_INJECT_MARKER}
 `;
+var MODULE_WGSL_BINDING_DECLARATION_REGEXES = [
+  /@binding\(\s*(auto|\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g,
+  /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(auto|\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g
+];
+var WGSL_BINDING_DECLARATION_REGEXES = [
+  /@binding\(\s*(\d+)\s*\)\s*@group\(\s*(\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g,
+  /@group\(\s*(\d+)\s*\)\s*@binding\(\s*(\d+)\s*\)\s*(var(?:<[^>]+>)?\s+([A-Za-z_][A-Za-z0-9_]*))/g
+];
+var RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT = 100;
 var FRAGMENT_SHADER_PROLOGUE = (
   /* glsl */
   `precision highp float;
@@ -575,30 +837,33 @@ var FRAGMENT_SHADER_PROLOGUE = (
 );
 function assembleWGSLShader(options) {
   const modules = getShaderModuleDependencies(options.modules || []);
+  const { source: source4, bindingAssignments } = assembleShaderWGSL(options.platformInfo, {
+    ...options,
+    source: options.source,
+    stage: "vertex",
+    modules
+  });
   return {
-    source: assembleShaderWGSL(options.platformInfo, {
-      ...options,
-      source: options.source,
-      stage: "vertex",
-      modules
-    }),
-    getUniforms: assembleGetUniforms(modules)
+    source: source4,
+    getUniforms: assembleGetUniforms(modules),
+    bindingAssignments,
+    bindingTable: getShaderBindingDebugRowsFromWGSL(source4, bindingAssignments)
   };
 }
 function assembleGLSLShaderPair(options) {
-  const { vs: vs3, fs: fs4 } = options;
+  const { vs: vs4, fs: fs5 } = options;
   const modules = getShaderModuleDependencies(options.modules || []);
   return {
     vs: assembleShaderGLSL(options.platformInfo, {
       ...options,
-      source: vs3,
+      source: vs4,
       stage: "vertex",
       modules
     }),
     fs: assembleShaderGLSL(options.platformInfo, {
       ...options,
       // @ts-expect-error
-      source: fs4,
+      source: fs5,
       stage: "fragment",
       modules
     }),
@@ -609,7 +874,7 @@ function assembleShaderWGSL(platformInfo, options) {
   var _a;
   const {
     // id,
-    source: source3,
+    source: source4,
     stage,
     modules,
     // defines = {},
@@ -617,8 +882,8 @@ function assembleShaderWGSL(platformInfo, options) {
     inject = {},
     log: log2
   } = options;
-  assert(typeof source3 === "string", "shader source must be a string");
-  const coreSource = source3;
+  assert(typeof source4 === "string", "shader source must be a string");
+  const coreSource = source4;
   let assembledSource = "";
   const hookFunctionMap = normalizeShaderHooks(hookFunctions);
   const hookInjections = {};
@@ -644,11 +909,20 @@ function assembleShaderWGSL(platformInfo, options) {
     }
   }
   const modulesToInject = modules;
+  const usedBindingsByGroup = getUsedBindingsByGroupFromApplicationWGSL(coreSource);
+  const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(modulesToInject, options._bindingRegistry, usedBindingsByGroup);
+  const bindingAssignments = [];
   for (const module2 of modulesToInject) {
     if (log2) {
       checkShaderModuleDeprecations(module2, coreSource, log2);
     }
-    const moduleSource = getShaderModuleSource(module2, "wgsl");
+    const relocation = relocateWGSLModuleBindings(getShaderModuleSource(module2, "wgsl", log2), module2, {
+      usedBindingsByGroup,
+      bindingRegistry: options._bindingRegistry,
+      reservedBindingKeysByGroup
+    });
+    bindingAssignments.push(...relocation.bindingAssignments);
+    const moduleSource = relocation.source;
     assembledSource += moduleSource;
     const injections = ((_a = module2.injections) == null ? void 0 : _a[stage]) || {};
     for (const key in injections) {
@@ -667,18 +941,20 @@ function assembleShaderWGSL(platformInfo, options) {
   assembledSource += INJECT_SHADER_DECLARATIONS;
   assembledSource = injectShader(assembledSource, stage, declInjections);
   assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
+  assembledSource += formatWGSLBindingAssignmentComments(bindingAssignments);
   assembledSource += coreSource;
   assembledSource = injectShader(assembledSource, stage, mainInjections);
-  return assembledSource;
+  assertNoUnresolvedAutoBindings(assembledSource);
+  return { source: assembledSource, bindingAssignments };
 }
 function assembleShaderGLSL(platformInfo, options) {
   var _a;
-  const { source: source3, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log2 } = options;
-  assert(typeof source3 === "string", "shader source must be a string");
-  const sourceVersion = language === "glsl" ? getShaderInfo(source3).version : -1;
+  const { source: source4, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log2 } = options;
+  assert(typeof source4 === "string", "shader source must be a string");
+  const sourceVersion = language === "glsl" ? getShaderInfo(source4).version : -1;
   const targetVersion = platformInfo.shaderLanguageVersion;
   const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es";
-  const sourceLines = source3.split("\n");
+  const sourceLines = source4.split("\n");
   const coreSource = sourceLines.slice(1).join("\n");
   const allDefines = {};
   modules.forEach((module2) => {
@@ -733,7 +1009,7 @@ ${getApplicationDefines(allDefines)}
     if (log2) {
       checkShaderModuleDeprecations(module2, coreSource, log2);
     }
-    const moduleSource = getShaderModuleSource(module2, stage);
+    const moduleSource = getShaderModuleSource(module2, stage, log2);
     assembledSource += moduleSource;
     const injections = ((_a = module2.instance) == null ? void 0 : _a.normalizedInjections[stage]) || {};
     for (const key in injections) {
@@ -782,7 +1058,7 @@ function getApplicationDefines(defines = {}) {
   }
   return sourceText;
 }
-function getShaderModuleSource(module2, stage) {
+function getShaderModuleSource(module2, stage, log2) {
   let moduleSource;
   switch (stage) {
     case "vertex":
@@ -800,40 +1076,227 @@ function getShaderModuleSource(module2, stage) {
   if (!module2.name) {
     throw new Error("Shader module must have a name");
   }
+  validateShaderModuleUniformLayout(module2, stage, { log: log2 });
   const moduleName = module2.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
-  let source3 = `// ----- MODULE ${module2.name} ---------------
+  let source4 = `// ----- MODULE ${module2.name} ---------------
 
 `;
   if (stage !== "wgsl") {
-    source3 += `#define MODULE_${moduleName}
+    source4 += `#define MODULE_${moduleName}
 `;
   }
-  source3 += `${moduleSource}
+  source4 += `${moduleSource}
+`;
+  return source4;
+}
+function getUsedBindingsByGroupFromApplicationWGSL(source4) {
+  const usedBindingsByGroup = /* @__PURE__ */ new Map();
+  for (const regex of WGSL_BINDING_DECLARATION_REGEXES) {
+    regex.lastIndex = 0;
+    let match;
+    while (match = regex.exec(source4)) {
+      const isBindingFirst = regex === WGSL_BINDING_DECLARATION_REGEXES[0];
+      const location = Number(match[isBindingFirst ? 1 : 2]);
+      const group = Number(match[isBindingFirst ? 2 : 1]);
+      const name = match[4];
+      validateApplicationWGSLBinding(group, location, name);
+      registerUsedBindingLocation(usedBindingsByGroup, group, location, `application binding "${name}"`);
+    }
+  }
+  return usedBindingsByGroup;
+}
+function relocateWGSLModuleBindings(moduleSource, module2, context) {
+  const bindingAssignments = [];
+  const relocationState = {
+    sawSupportedBindingDeclaration: false,
+    nextHintedBindingLocation: typeof module2.firstBindingSlot === "number" ? module2.firstBindingSlot : null
+  };
+  let relocatedSource = relocateWGSLModuleBindingsWithRegex(moduleSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES[0], { isBindingFirst: true, module: module2, context, bindingAssignments, relocationState });
+  relocatedSource = relocateWGSLModuleBindingsWithRegex(relocatedSource, MODULE_WGSL_BINDING_DECLARATION_REGEXES[1], { isBindingFirst: false, module: module2, context, bindingAssignments, relocationState });
+  if (moduleSource.includes("@binding(auto)") && !relocationState.sawSupportedBindingDeclaration) {
+    throw new Error(`Unsupported @binding(auto) declaration form in module "${module2.name}". Use "@group(N) @binding(auto) var ..." or "@binding(auto) @group(N) var ..." on a single line.`);
+  }
+  return { source: relocatedSource, bindingAssignments };
+}
+function relocateWGSLModuleBindingsWithRegex(source4, regex, params) {
+  return source4.replace(regex, (...replaceArguments) => relocateWGSLModuleBindingMatch(replaceArguments, params));
+}
+function relocateWGSLModuleBindingMatch(replaceArguments, params) {
+  var _a, _b;
+  const { isBindingFirst, module: module2, context, bindingAssignments, relocationState } = params;
+  relocationState.sawSupportedBindingDeclaration = true;
+  const match = replaceArguments[0];
+  const bindingToken = replaceArguments[isBindingFirst ? 1 : 2];
+  const groupToken = replaceArguments[isBindingFirst ? 2 : 1];
+  const name = replaceArguments[4];
+  const group = Number(groupToken);
+  if (bindingToken === "auto") {
+    const registryKey = getBindingRegistryKey(group, module2.name, name);
+    const registryLocation = (_a = context.bindingRegistry) == null ? void 0 : _a.get(registryKey);
+    const location2 = registryLocation !== void 0 ? registryLocation : relocationState.nextHintedBindingLocation === null ? allocateAutoBindingLocation(group, context.usedBindingsByGroup) : allocateAutoBindingLocation(group, context.usedBindingsByGroup, relocationState.nextHintedBindingLocation);
+    validateModuleWGSLBinding(module2.name, group, location2, name);
+    if (registryLocation !== void 0 && claimReservedBindingLocation(context.reservedBindingKeysByGroup, group, location2, registryKey)) {
+      bindingAssignments.push({ moduleName: module2.name, name, group, location: location2 });
+      return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location2})`);
+    }
+    registerUsedBindingLocation(context.usedBindingsByGroup, group, location2, `module "${module2.name}" binding "${name}"`);
+    (_b = context.bindingRegistry) == null ? void 0 : _b.set(registryKey, location2);
+    bindingAssignments.push({ moduleName: module2.name, name, group, location: location2 });
+    if (relocationState.nextHintedBindingLocation !== null && registryLocation === void 0) {
+      relocationState.nextHintedBindingLocation = location2 + 1;
+    }
+    return match.replace(/@binding\(\s*auto\s*\)/, `@binding(${location2})`);
+  }
+  const location = Number(bindingToken);
+  validateModuleWGSLBinding(module2.name, group, location, name);
+  registerUsedBindingLocation(context.usedBindingsByGroup, group, location, `module "${module2.name}" binding "${name}"`);
+  bindingAssignments.push({ moduleName: module2.name, name, group, location });
+  return match;
+}
+function reserveRegisteredModuleBindings(modules, bindingRegistry, usedBindingsByGroup) {
+  const reservedBindingKeysByGroup = /* @__PURE__ */ new Map();
+  if (!bindingRegistry) {
+    return reservedBindingKeysByGroup;
+  }
+  for (const module2 of modules) {
+    for (const binding of getModuleWGSLBindingDeclarations(module2)) {
+      const registryKey = getBindingRegistryKey(binding.group, module2.name, binding.name);
+      const location = bindingRegistry.get(registryKey);
+      if (location !== void 0) {
+        const reservedBindingKeys = reservedBindingKeysByGroup.get(binding.group) || /* @__PURE__ */ new Map();
+        const existingReservation = reservedBindingKeys.get(location);
+        if (existingReservation && existingReservation !== registryKey) {
+          throw new Error(`Duplicate WGSL binding reservation for modules "${existingReservation}" and "${registryKey}": group ${binding.group}, binding ${location}.`);
+        }
+        registerUsedBindingLocation(usedBindingsByGroup, binding.group, location, `registered module binding "${registryKey}"`);
+        reservedBindingKeys.set(location, registryKey);
+        reservedBindingKeysByGroup.set(binding.group, reservedBindingKeys);
+      }
+    }
+  }
+  return reservedBindingKeysByGroup;
+}
+function claimReservedBindingLocation(reservedBindingKeysByGroup, group, location, registryKey) {
+  const reservedBindingKeys = reservedBindingKeysByGroup.get(group);
+  if (!reservedBindingKeys) {
+    return false;
+  }
+  const reservedKey = reservedBindingKeys.get(location);
+  if (!reservedKey) {
+    return false;
+  }
+  if (reservedKey !== registryKey) {
+    throw new Error(`Registered module binding "${registryKey}" collided with "${reservedKey}": group ${group}, binding ${location}.`);
+  }
+  return true;
+}
+function getModuleWGSLBindingDeclarations(module2) {
+  const declarations = [];
+  const moduleSource = module2.source || "";
+  for (const regex of MODULE_WGSL_BINDING_DECLARATION_REGEXES) {
+    regex.lastIndex = 0;
+    let match;
+    while (match = regex.exec(moduleSource)) {
+      const isBindingFirst = regex === MODULE_WGSL_BINDING_DECLARATION_REGEXES[0];
+      declarations.push({
+        name: match[4],
+        group: Number(match[isBindingFirst ? 2 : 1])
+      });
+    }
+  }
+  return declarations;
+}
+function validateApplicationWGSLBinding(group, location, name) {
+  if (group === 0 && location >= RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT) {
+    throw new Error(`Application binding "${name}" in group 0 uses reserved binding ${location}. Application-owned explicit group-0 bindings must stay below ${RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT}.`);
+  }
+}
+function validateModuleWGSLBinding(moduleName, group, location, name) {
+  if (group === 0 && location < RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT) {
+    throw new Error(`Module "${moduleName}" binding "${name}" in group 0 uses reserved application binding ${location}. Module-owned explicit group-0 bindings must be ${RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT} or higher.`);
+  }
+}
+function registerUsedBindingLocation(usedBindingsByGroup, group, location, label) {
+  const usedBindings = usedBindingsByGroup.get(group) || /* @__PURE__ */ new Set();
+  if (usedBindings.has(location)) {
+    throw new Error(`Duplicate WGSL binding assignment for ${label}: group ${group}, binding ${location}.`);
+  }
+  usedBindings.add(location);
+  usedBindingsByGroup.set(group, usedBindings);
+}
+function allocateAutoBindingLocation(group, usedBindingsByGroup, preferredBindingLocation) {
+  const usedBindings = usedBindingsByGroup.get(group) || /* @__PURE__ */ new Set();
+  let nextBinding = preferredBindingLocation ?? (group === 0 ? RESERVED_APPLICATION_GROUP_0_BINDING_LIMIT : usedBindings.size > 0 ? Math.max(...usedBindings) + 1 : 0);
+  while (usedBindings.has(nextBinding)) {
+    nextBinding++;
+  }
+  return nextBinding;
+}
+function assertNoUnresolvedAutoBindings(source4) {
+  if (/@binding\(\s*auto\s*\)/.test(source4)) {
+    throw new Error("Unresolved @binding(auto) remained in assembled WGSL source.");
+  }
+}
+function formatWGSLBindingAssignmentComments(bindingAssignments) {
+  if (bindingAssignments.length === 0) {
+    return "";
+  }
+  let source4 = "// ----- MODULE WGSL BINDING ASSIGNMENTS ---------------\n";
+  for (const bindingAssignment of bindingAssignments) {
+    source4 += `// ${bindingAssignment.moduleName}.${bindingAssignment.name} -> @group(${bindingAssignment.group}) @binding(${bindingAssignment.location})
 `;
-  return source3;
+  }
+  source4 += "\n";
+  return source4;
+}
+function getBindingRegistryKey(group, moduleName, bindingName) {
+  return `${group}:${moduleName}:${bindingName}`;
 }
 
 // dist/lib/preprocessor/preprocessor.js
-var IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
+var 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*$/;
-function preprocess(source3, options) {
-  var _a;
-  const lines = source3.split("\n");
+var IFDEF_WITH_COMMENT_REGEXP = new RegExp(`^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`);
+var ENDIF_WITH_COMMENT_REGEXP = /^\s*\#\s*endif\s*(?:\/\/.*)?$/;
+function preprocess(source4, options) {
+  var _a, _b;
+  const lines = source4.split("\n");
   const output = [];
+  const conditionalStack = [];
   let conditional = true;
-  let currentDefine = null;
   for (const line of lines) {
-    const matchIf = line.match(IFDEF_REGEXP);
-    const matchEnd = line.match(ENDIF_REGEXP);
-    if (matchIf) {
-      currentDefine = matchIf[1];
-      conditional = Boolean((_a = options == null ? void 0 : options.defines) == null ? void 0 : _a[currentDefine]);
+    const matchIf = line.match(IFDEF_WITH_COMMENT_REGEXP) || line.match(IFDEF_REGEXP);
+    const matchIfNot = line.match(IFNDEF_REGEXP);
+    const matchElse = line.match(ELSE_REGEXP);
+    const matchEnd = line.match(ENDIF_WITH_COMMENT_REGEXP) || line.match(ENDIF_REGEXP);
+    if (matchIf || matchIfNot) {
+      const defineName = (_a = matchIf || matchIfNot) == null ? void 0 : _a[1];
+      const defineValue = Boolean((_b = options == null ? void 0 : options.defines) == null ? void 0 : _b[defineName]);
+      const branchTaken = matchIf ? defineValue : !defineValue;
+      const active = conditional && branchTaken;
+      conditionalStack.push({ parentActive: conditional, branchTaken, active });
+      conditional = active;
+    } else if (matchElse) {
+      const currentConditional = conditionalStack[conditionalStack.length - 1];
+      if (!currentConditional) {
+        throw new Error("Encountered #else without matching #ifdef or #ifndef");
+      }
+      currentConditional.active = currentConditional.parentActive && !currentConditional.branchTaken;
+      currentConditional.branchTaken = true;
+      conditional = currentConditional.active;
     } else if (matchEnd) {
-      conditional = true;
+      conditionalStack.pop();
+      conditional = conditionalStack.length ? conditionalStack[conditionalStack.length - 1].active : true;
     } else if (conditional) {
       output.push(line);
     }
   }
+  if (conditionalStack.length > 0) {
+    throw new Error("Unterminated conditional block in shader source");
+  }
   return output.join("\n");
 }
 
@@ -843,6 +1306,8 @@ var _ShaderAssembler = class {
   _hookFunctions = [];
   /** Shader modules */
   _defaultModules = [];
+  /** Stable per-run WGSL auto-binding assignments keyed by group/module/binding. */
+  _wgslBindingRegistry = /* @__PURE__ */ new Map();
   /**
    * A default shader assembler instance - the natural place to register default modules and hooks
    * @returns
@@ -886,15 +1351,29 @@ var _ShaderAssembler = class {
   assembleWGSLShader(props) {
     const modules = this._getModuleList(props.modules);
     const hookFunctions = this._hookFunctions;
-    const { source: source3, getUniforms: getUniforms4 } = assembleWGSLShader({
+    const { source: source4, getUniforms: getUniforms4, bindingAssignments } = assembleWGSLShader({
       ...props,
       // @ts-expect-error
       source: props.source,
+      _bindingRegistry: this._wgslBindingRegistry,
       modules,
       hookFunctions
     });
-    const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source3) : source3;
-    return { source: preprocessedSource, getUniforms: getUniforms4, modules };
+    const defines = {
+      ...modules.reduce((accumulator, module2) => {
+        Object.assign(accumulator, module2.defines);
+        return accumulator;
+      }, {}),
+      ...props.defines
+    };
+    const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source4, { defines }) : source4;
+    return {
+      source: preprocessedSource,
+      getUniforms: getUniforms4,
+      modules,
+      bindingAssignments,
+      bindingTable: getShaderBindingDebugRowsFromWGSL(preprocessedSource, bindingAssignments)
+    };
   }
   /**
    * Assemble a pair of shaders into a single shader program
@@ -1059,6 +1538,9 @@ function generateGLSLUniformDeclarations(module2, options) {
     case "uniforms":
   }
   for (const [uniformName, uniformFormat] of Object.entries(module2.uniformTypes || {})) {
+    if (typeof uniformFormat !== "string") {
+      throw new Error(`Composite uniform types are not supported by GLSL shader generation: ${module2.name}.${uniformName}`);
+    }
     const glslUniformType = getGLSLUniformType(uniformFormat);
     switch (options.uniforms) {
       case "scoped-interface-blocks":
@@ -1119,6 +1601,9 @@ function generateWGSLUniformDeclarations(module2, options) {
   const wgsl = [];
   wgsl.push(`struct ${capitalize(module2.name)} {`);
   for (const [uniformName, uniformFormat] of Object.entries((module2 == null ? void 0 : module2.uniformTypes) || {})) {
+    if (typeof uniformFormat !== "string") {
+      throw new Error(`Composite uniform types are not supported by WGSL shader generation: ${module2.name}.${uniformName}`);
+    }
     const wgslUniformType = uniformFormat;
     wgsl.push(`  ${uniformName} : ${wgslUniformType};`);
   }
@@ -1248,9 +1733,8 @@ function fp64ifyMatrix4(matrix) {
 // dist/modules/math/random/random.js
 var source = (
   /* wgsl */
-  `fn random(scale: vec3f, seed: float) -> f32 {
-  /* use the fragment position for a different seed per-pixel */
-  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+  `fn random(scale: vec3f, seed: f32) -> f32 {
+  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);
 }
 `
 );
@@ -1434,6 +1918,7 @@ var fp64arithmeticShader = (
   `
 uniform fp64arithmeticUniforms {
   uniform float ONE;
+  uniform float SPLIT;
 } fp64;
 
 /*
@@ -1443,6 +1928,12 @@ The purpose of this workaround is to prevent shader compilers from
 optimizing away necessary arithmetic operations by swapping their sequences
 or transform the equation to some 'equivalent' form.
 
+These helpers implement Dekker/Veltkamp-style error tracking. If the compiler
+folds constants or reassociates the arithmetic, the high/low split can stop
+tracking the rounding error correctly. That failure mode tends to look fine in
+simple coordinate setup, but then breaks down inside iterative arithmetic such
+as fp64 Mandelbrot loops.
+
 The method is to multiply an artifical variable, ONE, which will be known to
 the compiler to be 1 only at runtime. The whole expression is then represented
 as a polynomial with respective to ONE. In the coefficients of all terms, only one a
@@ -1451,17 +1942,23 @@ and one b should appear
 err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
 */
 
-// Divide float number to high and low floats to extend fraction bits
-vec2 split(float a) {
-  const float SPLIT = 4097.0;
-  float t = a * SPLIT;
+float prevent_fp64_optimization(float value) {
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float a_hi = t * fp64.ONE - (t - a);
-  float a_lo = a * fp64.ONE - a_hi;
+  return value + fp64.ONE * 0.0;
 #else
-  float a_hi = t - (t - a);
-  float a_lo = a - a_hi;
+  return value;
 #endif
+}
+
+// Divide float number to high and low floats to extend fraction bits
+vec2 split(float a) {
+  // Keep SPLIT as a runtime uniform so the compiler cannot fold the Dekker
+  // split into a constant expression and reassociate the recovery steps.
+  float split = prevent_fp64_optimization(fp64.SPLIT);
+  float t = prevent_fp64_optimization(a * split);
+  float temp = t - a;
+  float a_hi = t - temp;
+  float a_lo = a - a_hi;
   return vec2(a_hi, a_lo);
 }
 
@@ -1525,8 +2022,26 @@ vec2 twoProd(float a, float b) {
   float prod = a * b;
   vec2 a_fp64 = split(a);
   vec2 b_fp64 = split(b);
-  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
-    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
+  // twoProd is especially sensitive because mul_fp64 and div_fp64 both depend
+  // on the split terms and cross terms staying in the original evaluation
+  // order. If the compiler folds or reassociates them, the low part tends to
+  // collapse to zero or NaN on some drivers.
+  float highProduct = prevent_fp64_optimization(a_fp64.x * b_fp64.x);
+  float crossProduct1 = prevent_fp64_optimization(a_fp64.x * b_fp64.y);
+  float crossProduct2 = prevent_fp64_optimization(a_fp64.y * b_fp64.x);
+  float lowProduct = prevent_fp64_optimization(a_fp64.y * b_fp64.y);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err1 = (highProduct - prod) * fp64.ONE;
+  float err2 = crossProduct1 * fp64.ONE * fp64.ONE;
+  float err3 = crossProduct2 * fp64.ONE * fp64.ONE * fp64.ONE;
+  float err4 = lowProduct * fp64.ONE * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err1 = highProduct - prod;
+  float err2 = crossProduct1;
+  float err3 = crossProduct2;
+  float err4 = lowProduct;
+#endif
+  float err = ((err1 + err2) + err3) + err4;
   return vec2(prod, err);
 }
 
@@ -1602,6 +2117,218 @@ vec2 sqrt_fp64(vec2 a) {
 `
 );
 
+// dist/modules/math/fp64/fp64-arithmetic-wgsl.js
+var fp64arithmeticWGSL = (
+  /* wgsl */
+  `struct Fp64ArithmeticUniforms {
+  ONE: f32,
+  SPLIT: f32,
+};
+
+@group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;
+
+fn fp64_nan(seed: f32) -> f32 {
+  let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);
+  return bitcast<f32>(nanBits);
+}
+
+fn fp64_runtime_zero() -> f32 {
+  return fp64arithmetic.ONE * 0.0;
+}
+
+fn prevent_fp64_optimization(value: f32) -> f32 {
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  return value + fp64_runtime_zero();
+#else
+  return value;
+#endif
+}
+
+fn split(a: f32) -> vec2f {
+  let splitValue = prevent_fp64_optimization(fp64arithmetic.SPLIT + fp64_runtime_zero());
+  let t = prevent_fp64_optimization(a * splitValue);
+  let temp = prevent_fp64_optimization(t - a);
+  let aHi = prevent_fp64_optimization(t - temp);
+  let aLo = prevent_fp64_optimization(a - aHi);
+  return vec2f(aHi, aLo);
+}
+
+fn split2(a: vec2f) -> vec2f {
+  var b = split(a.x);
+  b.y = b.y + a.y;
+  return b;
+}
+
+fn quickTwoSum(a: f32, b: f32) -> vec2f {
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let sum = prevent_fp64_optimization((a + b) * fp64arithmetic.ONE);
+  let err = prevent_fp64_optimization(b - (sum - a) * fp64arithmetic.ONE);
+#else
+  let sum = prevent_fp64_optimization(a + b);
+  let err = prevent_fp64_optimization(b - (sum - a));
+#endif
+  return vec2f(sum, err);
+}
+
+fn twoSum(a: f32, b: f32) -> vec2f {
+  let s = prevent_fp64_optimization(a + b);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);
+  let err =
+    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE) +
+    prevent_fp64_optimization(b - v);
+#else
+  let v = prevent_fp64_optimization(s - a);
+  let err = prevent_fp64_optimization(a - (s - v)) + prevent_fp64_optimization(b - v);
+#endif
+  return vec2f(s, err);
+}
+
+fn twoSub(a: f32, b: f32) -> vec2f {
+  let s = prevent_fp64_optimization(a - b);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);
+  let err =
+    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE) -
+    prevent_fp64_optimization(b + v);
+#else
+  let v = prevent_fp64_optimization(s - a);
+  let err = prevent_fp64_optimization(a - (s - v)) - prevent_fp64_optimization(b + v);
+#endif
+  return vec2f(s, err);
+}
+
+fn twoSqr(a: f32) -> vec2f {
+  let prod = prevent_fp64_optimization(a * a);
+  let aFp64 = split(a);
+  let highProduct = prevent_fp64_optimization(aFp64.x * aFp64.x);
+  let crossProduct = prevent_fp64_optimization(2.0 * aFp64.x * aFp64.y);
+  let lowProduct = prevent_fp64_optimization(aFp64.y * aFp64.y);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let err =
+    (prevent_fp64_optimization(highProduct - prod) * fp64arithmetic.ONE +
+      crossProduct * fp64arithmetic.ONE * fp64arithmetic.ONE) +
+    lowProduct * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;
+#else
+  let err = ((prevent_fp64_optimization(highProduct - prod) + crossProduct) + lowProduct);
+#endif
+  return vec2f(prod, err);
+}
+
+fn twoProd(a: f32, b: f32) -> vec2f {
+  let prod = prevent_fp64_optimization(a * b);
+  let aFp64 = split(a);
+  let bFp64 = split(b);
+  let highProduct = prevent_fp64_optimization(aFp64.x * bFp64.x);
+  let crossProduct1 = prevent_fp64_optimization(aFp64.x * bFp64.y);
+  let crossProduct2 = prevent_fp64_optimization(aFp64.y * bFp64.x);
+  let lowProduct = prevent_fp64_optimization(aFp64.y * bFp64.y);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let err1 = (highProduct - prod) * fp64arithmetic.ONE;
+  let err2 = crossProduct1 * fp64arithmetic.ONE * fp64arithmetic.ONE;
+  let err3 = crossProduct2 * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;
+  let err4 =
+    lowProduct *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE;
+#else
+  let err1 = highProduct - prod;
+  let err2 = crossProduct1;
+  let err3 = crossProduct2;
+  let err4 = lowProduct;
+#endif
+  let err12InputA = prevent_fp64_optimization(err1);
+  let err12InputB = prevent_fp64_optimization(err2);
+  let err12 = prevent_fp64_optimization(err12InputA + err12InputB);
+  let err123InputA = prevent_fp64_optimization(err12);
+  let err123InputB = prevent_fp64_optimization(err3);
+  let err123 = prevent_fp64_optimization(err123InputA + err123InputB);
+  let err1234InputA = prevent_fp64_optimization(err123);
+  let err1234InputB = prevent_fp64_optimization(err4);
+  let err = prevent_fp64_optimization(err1234InputA + err1234InputB);
+  return vec2f(prod, err);
+}
+
+fn sum_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var s = twoSum(a.x, b.x);
+  let t = twoSum(a.y, b.y);
+  s.y = prevent_fp64_optimization(s.y + t.x);
+  s = quickTwoSum(s.x, s.y);
+  s.y = prevent_fp64_optimization(s.y + t.y);
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+fn sub_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var s = twoSub(a.x, b.x);
+  let t = twoSub(a.y, b.y);
+  s.y = prevent_fp64_optimization(s.y + t.x);
+  s = quickTwoSum(s.x, s.y);
+  s.y = prevent_fp64_optimization(s.y + t.y);
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+fn mul_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var prod = twoProd(a.x, b.x);
+  let crossProduct1 = prevent_fp64_optimization(a.x * b.y);
+  prod.y = prevent_fp64_optimization(prod.y + crossProduct1);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  let crossProduct2 = prevent_fp64_optimization(a.y * b.x);
+  prod.y = prevent_fp64_optimization(prod.y + crossProduct2);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
+}
+
+fn div_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let xn = prevent_fp64_optimization(1.0 / b.x);
+  let yn = mul_fp64(a, vec2f(xn, fp64_runtime_zero()));
+  let diff = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, yn)).x);
+  let prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+fn sqrt_fp64(a: vec2f) -> vec2f {
+  if (a.x == 0.0 && a.y == 0.0) {
+    return vec2f(0.0, 0.0);
+  }
+  if (a.x < 0.0) {
+    let nanValue = fp64_nan(a.x);
+    return vec2f(nanValue, nanValue);
+  }
+
+  let x = prevent_fp64_optimization(1.0 / sqrt(a.x));
+  let yn = prevent_fp64_optimization(a.x * x);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let ynSqr = twoSqr(yn) * fp64arithmetic.ONE;
+#else
+  let ynSqr = twoSqr(yn);
+#endif
+  let diff = prevent_fp64_optimization(sub_fp64(a, ynSqr).x);
+  let prod = twoProd(prevent_fp64_optimization(x * 0.5), diff);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2f(yn, 0.0), prod);
+#endif
+}
+`
+);
+
 // dist/modules/math/fp64/fp64-functions-glsl.js
 var fp64functionShader = (
   /* glsl */
@@ -2280,13 +3007,18 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
 // dist/modules/math/fp64/fp64.js
 var defaultUniforms = {
   // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
-  ONE: 1
+  ONE: 1,
+  // Runtime split factor for Dekker splitting. Keeping this as a uniform helps
+  // prevent aggressive constant folding in shader compilers.
+  SPLIT: 4097
 };
 var fp64arithmetic = {
   name: "fp64arithmetic",
+  source: fp64arithmeticWGSL,
+  fs: fp64arithmeticShader,
   vs: fp64arithmeticShader,
   defaultUniforms,
-  uniformTypes: { ONE: "f32" },
+  uniformTypes: { ONE: "f32", SPLIT: "f32" },
   // Additional Functions
   fp64ify,
   fp64LowPart,
@@ -2490,8 +3222,100 @@ function getUniforms(opts = {}, prevUniforms) {
   return uniforms;
 }
 
+// dist/modules/engine/skin/skin.js
+var import_core2 = require("@math.gl/core");
+var SKIN_MAX_JOINTS = 20;
+var source2 = (
+  /* wgsl */
+  `
+struct skinUniforms {
+  jointMatrix: array<mat4x4<f32>, ${SKIN_MAX_JOINTS}>,
+};
+
+@group(0) @binding(auto) var<uniform> skin: skinUniforms;
+
+fn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {
+  return (weights.x * skin.jointMatrix[joints.x])
+       + (weights.y * skin.jointMatrix[joints.y])
+       + (weights.z * skin.jointMatrix[joints.z])
+       + (weights.w * skin.jointMatrix[joints.w]);
+}
+`
+);
+var vs2 = (
+  /* glsl */
+  `
+uniform skinUniforms {
+  mat4 jointMatrix[SKIN_MAX_JOINTS];
+} skin;
+
+mat4 getSkinMatrix(vec4 weights, uvec4 joints) {
+  return (weights.x * skin.jointMatrix[joints.x])
+       + (weights.y * skin.jointMatrix[joints.y])
+       + (weights.z * skin.jointMatrix[joints.z])
+       + (weights.w * skin.jointMatrix[joints.w]);
+}
+
+`
+);
+var fs3 = (
+  /* glsl */
+  ``
+);
+var skin = {
+  props: {},
+  uniforms: {},
+  name: "skin",
+  bindingLayout: [{ name: "skin", group: 0 }],
+  dependencies: [],
+  source: source2,
+  vs: vs2,
+  fs: fs3,
+  defines: {
+    SKIN_MAX_JOINTS
+  },
+  getUniforms: (props = {}, prevUniforms) => {
+    var _a, _b;
+    const { scenegraphsFromGLTF } = props;
+    if (!((_b = (_a = scenegraphsFromGLTF == null ? void 0 : scenegraphsFromGLTF.gltf) == null ? void 0 : _a.skins) == null ? void 0 : _b[0])) {
+      return { jointMatrix: [] };
+    }
+    const { inverseBindMatrices, joints, skeleton } = scenegraphsFromGLTF.gltf.skins[0];
+    const matsib = [];
+    const countib = inverseBindMatrices.value.length / 16;
+    for (let i = 0; i < countib; i++) {
+      const slice = inverseBindMatrices.value.subarray(i * 16, i * 16 + 16);
+      matsib.push(new import_core2.Matrix4(Array.from(slice)));
+    }
+    const top = scenegraphsFromGLTF.gltfNodeIndexToNodeMap.get(skeleton);
+    const matrices = {};
+    top.preorderTraversal((node, { worldMatrix }) => {
+      matrices[node.id] = worldMatrix;
+    });
+    const mats = new Float32Array(SKIN_MAX_JOINTS * 16);
+    for (let i = 0; i < SKIN_MAX_JOINTS; ++i) {
+      const nodeIndex = joints[i];
+      if (nodeIndex === void 0)
+        break;
+      const worldMat = matrices[scenegraphsFromGLTF.gltfNodeIndexToNodeMap.get(nodeIndex).id];
+      const invBindMat = matsib[i];
+      const Z = new import_core2.Matrix4().copy(worldMat).multiplyRight(invBindMat);
+      const off = i * 16;
+      for (let j = 0; j < 16; j++) {
+        mats[off + j] = Z[j];
+      }
+    }
+    return {
+      jointMatrix: mats
+    };
+  },
+  uniformTypes: {
+    jointMatrix: ["mat4x4<f32>", SKIN_MAX_JOINTS]
+  }
+};
+
 // dist/modules/lighting/lights/lighting.js
-var import_core2 = require("@luma.gl/core");
+var import_core3 = require("@luma.gl/core");
 
 // dist/modules/lighting/lights/lighting-glsl.js
 var lightingUniformsGLSL = (
@@ -2509,59 +3333,51 @@ struct PointLight {
   vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 struct DirectionalLight {
   vec3 color;
   vec3 direction;
 };
 
+struct UniformLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 uniform lightingUniforms {
   int enabled;
-  int lightType;
-
   int directionalLightCount;
   int pointLightCount;
-
+  int spotLightCount;
   vec3 ambientColor;
-
-  vec3 lightColor0;
-  vec3 lightPosition0;
-  vec3 lightDirection0;
-  vec3 lightAttenuation0;
-
-  vec3 lightColor1;
-  vec3 lightPosition1;
-  vec3 lightDirection1;
-  vec3 lightAttenuation1;
-
-  vec3 lightColor2;
-  vec3 lightPosition2;
-  vec3 lightDirection2;
-  vec3 lightAttenuation2;
+  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:
-    default:  
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
-  }
+  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:
-    default:   
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-  }
-} 
+  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
@@ -2569,6 +3385,20 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
        + pointLight.attenuation.z * distance * distance;
 }
 
+float getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {
+  vec3 light_direction = normalize(positionWorldspace - spotLight.position);
+  float coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), light_direction)
+  );
+  float distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
+
 // #endif
 `
 );
@@ -2577,6 +3407,8 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 var lightingUniformsWGSL = (
   /* wgsl */
   `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+const MAX_LIGHTS: i32 = 5;
+
 struct AmbientLight {
   color: vec3<f32>,
 };
@@ -2587,57 +3419,85 @@ struct PointLight {
   attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct DirectionalLight {
   color: vec3<f32>,
   direction: vec3<f32>,
 };
 
+struct UniformLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct lightingUniforms {
   enabled: i32,
-  pointLightCount: i32,
   directionalLightCount: i32,
-
+  pointLightCount: i32,
+  spotLightCount: i32,
   ambientColor: vec3<f32>,
-
-  // TODO - support multiple lights by uncommenting arrays below
-  lightType: i32,
-  lightColor: vec3<f32>,
-  lightDirection: vec3<f32>,
-  lightPosition: vec3<f32>,
-  lightAttenuation: vec3<f32>,
-
-  // AmbientLight ambientLight;
-  // PointLight pointLight[MAX_LIGHTS];
-  // DirectionalLight directionalLight[MAX_LIGHTS];
+  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 {
-  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+  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 {
-  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
-} 
+  let light = lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
   return pointLight.attenuation.x
        + pointLight.attenuation.y * distance
        + pointLight.attenuation.z * distance * distance;
 }
+
+fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>) -> f32 {
+  let lightDirection = normalize(positionWorldspace - spotLight.position);
+  let coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), lightDirection)
+  );
+  let distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
 `
 );
 
 // dist/modules/lighting/lights/lighting.js
 var MAX_LIGHTS = 5;
 var COLOR_FACTOR = 255;
-var LIGHT_TYPE;
-(function(LIGHT_TYPE2) {
-  LIGHT_TYPE2[LIGHT_TYPE2["POINT"] = 0] = "POINT";
-  LIGHT_TYPE2[LIGHT_TYPE2["DIRECTIONAL"] = 1] = "DIRECTIONAL";
-})(LIGHT_TYPE || (LIGHT_TYPE = {}));
+var LIGHT_UNIFORM_TYPE = {
+  color: "vec3<f32>",
+  position: "vec3<f32>",
+  direction: "vec3<f32>",
+  attenuation: "vec3<f32>",
+  coneCos: "vec2<f32>"
+};
 var lighting = {
   props: {},
   uniforms: {},
@@ -2647,102 +3507,105 @@ var lighting = {
   },
   uniformTypes: {
     enabled: "i32",
-    lightType: "i32",
     directionalLightCount: "i32",
     pointLightCount: "i32",
+    spotLightCount: "i32",
     ambientColor: "vec3<f32>",
-    // TODO define as arrays once we have appropriate uniformTypes
-    lightColor0: "vec3<f32>",
-    lightPosition0: "vec3<f32>",
-    // TODO - could combine direction and attenuation
-    lightDirection0: "vec3<f32>",
-    lightAttenuation0: "vec3<f32>",
-    lightColor1: "vec3<f32>",
-    lightPosition1: "vec3<f32>",
-    lightDirection1: "vec3<f32>",
-    lightAttenuation1: "vec3<f32>",
-    lightColor2: "vec3<f32>",
-    lightPosition2: "vec3<f32>",
-    lightDirection2: "vec3<f32>",
-    lightAttenuation2: "vec3<f32>"
-  },
-  defaultUniforms: {
-    enabled: 1,
-    lightType: LIGHT_TYPE.POINT,
-    directionalLightCount: 0,
-    pointLightCount: 0,
-    ambientColor: [0.1, 0.1, 0.1],
-    lightColor0: [1, 1, 1],
-    lightPosition0: [1, 1, 2],
-    // TODO - could combine direction and attenuation
-    lightDirection0: [1, 1, 1],
-    lightAttenuation0: [1, 0, 0],
-    lightColor1: [1, 1, 1],
-    lightPosition1: [1, 1, 2],
-    lightDirection1: [1, 1, 1],
-    lightAttenuation1: [1, 0, 0],
-    lightColor2: [1, 1, 1],
-    lightPosition2: [1, 1, 2],
-    lightDirection2: [1, 1, 1],
-    lightAttenuation2: [1, 0, 0]
+    lights: [LIGHT_UNIFORM_TYPE, MAX_LIGHTS]
   },
+  defaultUniforms: createDefaultLightingUniforms(),
+  bindingLayout: [{ name: "lighting", group: 2 }],
+  firstBindingSlot: 0,
   source: lightingUniformsWGSL,
   vs: lightingUniformsGLSL,
   fs: lightingUniformsGLSL,
   getUniforms: getUniforms2
 };
-function getUniforms2(props, prevUniforms = {}) {
+function getUniforms2(props, _prevUniforms = {}) {
   props = props ? { ...props } : props;
   if (!props) {
-    return { ...lighting.defaultUniforms };
+    return createDefaultLightingUniforms();
   }
   if (props.lights) {
     props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
   }
-  const { ambientLight, pointLights, directionalLights } = props || {};
-  const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
+  const { ambientLight, pointLights, spotLights, directionalLights } = props || {};
+  const hasLights = ambientLight || pointLights && pointLights.length > 0 || spotLights && spotLights.length > 0 || directionalLights && directionalLights.length > 0;
   if (!hasLights) {
-    return { ...lighting.defaultUniforms, enabled: 0 };
+    return {
+      ...createDefaultLightingUniforms(),
+      enabled: 0
+    };
   }
   const uniforms = {
-    ...lighting.defaultUniforms,
-    ...prevUniforms,
-    ...getLightSourceUniforms({ ambientLight, pointLights, directionalLights })
+    ...createDefaultLightingUniforms(),
+    ...getLightSourceUniforms({ ambientLight, pointLights, spotLights, directionalLights })
   };
   if (props.enabled !== void 0) {
     uniforms.enabled = props.enabled ? 1 : 0;
   }
   return uniforms;
 }
-function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {
-  const lightSourceUniforms = {};
-  lightSourceUniforms.ambientColor = convertColor(ambientLight);
+function getLightSourceUniforms({ ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
+  const lights = createDefaultLightUniforms();
   let currentLight = 0;
+  let pointLightCount = 0;
+  let spotLightCount = 0;
+  let directionalLightCount = 0;
   for (const pointLight of pointLights) {
-    lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
-    const i = currentLight;
-    lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
-    lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
-    lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
+    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) {
-    lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;
-    const i = currentLight;
-    lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
-    lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
+    lights[currentLight] = {
+      ...lights[currentLight],
+      color: convertColor(directionalLight),
+      direction: directionalLight.direction
+    };
     currentLight++;
+    directionalLightCount++;
   }
-  if (currentLight > MAX_LIGHTS) {
-    import_core2.log.warn("MAX_LIGHTS exceeded")();
+  if (pointLights.length + spotLights.length + directionalLights.length > MAX_LIGHTS) {
+    import_core3.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
   }
-  lightSourceUniforms.directionalLightCount = directionalLights.length;
-  lightSourceUniforms.pointLightCount = pointLights.length;
-  return lightSourceUniforms;
+  return {
+    ambientColor: convertColor(ambientLight),
+    directionalLightCount,
+    pointLightCount,
+    spotLightCount,
+    lights
+  };
 }
 function extractLightTypes(lights) {
-  var _a, _b;
-  const lightSources = { pointLights: [], directionalLights: [] };
+  var _a, _b, _c;
+  const lightSources = { pointLights: [], spotLights: [], directionalLights: [] };
   for (const light of lights || []) {
     switch (light.type) {
       case "ambient":
@@ -2754,6 +3617,9 @@ function extractLightTypes(lights) {
       case "point":
         (_b = lightSources.pointLights) == null ? void 0 : _b.push(light);
         break;
+      case "spot":
+        (_c = lightSources.spotLights) == null ? void 0 : _c.push(light);
+        break;
       default:
     }
   }
@@ -2763,6 +3629,68 @@ function convertColor(colorDef = {}) {
   const { color = [0, 0, 0], intensity = 1 } = colorDef;
   return color.map((component) => component * intensity / COLOR_FACTOR);
 }
+function createDefaultLightingUniforms() {
+  return {
+    enabled: 1,
+    directionalLightCount: 0,
+    pointLightCount: 0,
+    spotLightCount: 0,
+    ambientColor: [0.1, 0.1, 0.1],
+    lights: createDefaultLightUniforms()
+  };
+}
+function createDefaultLightUniforms() {
+  return Array.from({ length: MAX_LIGHTS }, () => createDefaultLightUniform());
+}
+function createDefaultLightUniform() {
+  return {
+    color: [1, 1, 1],
+    position: [1, 1, 2],
+    direction: [1, 1, 1],
+    attenuation: [1, 0, 0],
+    coneCos: [1, 0]
+  };
+}
+function getSpotConeCos(spotLight) {
+  const innerConeAngle = spotLight.innerConeAngle ?? 0;
+  const outerConeAngle = spotLight.outerConeAngle ?? Math.PI / 4;
+  return [Math.cos(innerConeAngle), Math.cos(outerConeAngle)];
+}
+
+// dist/modules/lighting/ibl/ibl.js
+var iblWGSL = (
+  /* wgsl */
+  `#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`
+);
+var iblGLSL = (
+  /* glsl */
+  `#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`
+);
+var ibl = {
+  name: "ibl",
+  firstBindingSlot: 32,
+  bindingLayout: [
+    { name: "pbr_diffuseEnvSampler", group: 2 },
+    { name: "pbr_specularEnvSampler", group: 2 },
+    { name: "pbr_brdfLUT", group: 2 }
+  ],
+  source: iblWGSL,
+  vs: iblGLSL,
+  fs: iblGLSL
+};
 
 // dist/modules/lighting/no-material/dirlight.js
 var SOURCE_WGSL = (
@@ -2778,7 +3706,7 @@ struct DirlightInputs {
   normal: DirlightNormal,
 };
 
-@binding(1) @group(0) var<uniform> dirlight : dirlightUniforms;
+@group(2) @binding(auto) var<uniform> dirlight : dirlightUniforms;
 
 // For vertex
 fn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {
@@ -2823,6 +3751,8 @@ var dirlight = {
   props: {},
   uniforms: {},
   name: "dirlight",
+  bindingLayout: [{ name: "dirlight", group: 2 }],
+  firstBindingSlot: 16,
   dependencies: [],
   source: SOURCE_WGSL,
   vs: VS_GLSL,
@@ -2849,10 +3779,173 @@ function getUniforms3(opts = dirlight.defaultUniforms) {
   return uniforms;
 }
 
+// dist/modules/lighting/lambert-material/lambert-shaders-wgsl.js
+var LAMBERT_WGSL = (
+  /* wgsl */
+  `struct lambertMaterialUniforms {
+  unlit: u32,
+  ambient: f32,
+  diffuse: f32,
+};
+
+@group(3) @binding(auto) var<uniform> lambertMaterial : lambertMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let lambertian: f32 = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * lambertMaterial.diffuse * surfaceColor * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lambertMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = lambertMaterial.ambient * surfaceColor * lighting.ambientColor;
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight: PointLight = lighting_getPointLight(i);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(light_position_worldspace, position_worldspace)
+    );
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      pointLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight: SpotLight = lighting_getSpotLight(i);
+    let light_position_worldspace: vec3<f32> = spotLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      spotLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      -directionalLight.direction,
+      normal_worldspace,
+      directionalLight.color
+    );
+  }
+
+  return lightColor;
+}
+`
+);
+
+// dist/modules/lighting/lambert-material/lambert-shaders-glsl.js
+var LAMBERT_VS = (
+  /* glsl */
+  `uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+`
+);
+var LAMBERT_FS = (
+  /* glsl */
+  `uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 normal_worldspace, vec3 color) {
+  float lambertian = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * material.diffuse * surfaceColor * color;
+}
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+  vec3 lightColor = surfaceColor;
+
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, normal_worldspace, directionalLight.color);
+  }
+
+  return lightColor;
+}
+`
+);
+
+// dist/modules/lighting/lambert-material/lambert-material.js
+var lambertMaterial = {
+  name: "lambertMaterial",
+  firstBindingSlot: 0,
+  bindingLayout: [{ name: "lambertMaterial", group: 3 }],
+  dependencies: [lighting],
+  source: LAMBERT_WGSL,
+  vs: LAMBERT_VS,
+  fs: LAMBERT_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    unlit: "i32",
+    ambient: "f32",
+    diffuse: "f32"
+  },
+  defaultUniforms: {
+    unlit: false,
+    ambient: 0.35,
+    diffuse: 0.6
+  },
+  getUniforms(props) {
+    return { ...lambertMaterial.defaultUniforms, ...props };
+  }
+};
+
 // dist/modules/lighting/phong-material/phong-shaders-glsl.js
 var PHONG_VS = (
   /* glsl */
   `uniform phongMaterialUniforms {
+  uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -2862,9 +3955,8 @@ var PHONG_VS = (
 );
 var PHONG_FS = (
   /* glsl */
-  `#define MAX_LIGHTS 3
-
-uniform phongMaterialUniforms {
+  `uniform phongMaterialUniforms {
+  uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -2886,6 +3978,10 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
   vec3 lightColor = surfaceColor;
 
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
   if (lighting.enabled == 0) {
     return lightColor;
   }
@@ -2901,8 +3997,15 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
     lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
   }
 
-  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
-  for (int i = lighting.pointLightCount; i < totalLights; i++) {
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
     DirectionalLight directionalLight = lighting_getDirectionalLight(i);
     lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }
@@ -2916,13 +4019,14 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
 var PHONG_WGSL = (
   /* wgsl */
   `struct phongMaterialUniforms {
+  unlit: u32,
   ambient: f32,
   diffuse: f32,
   shininess: f32,
   specularColor: vec3<f32>,
 };
 
-@binding(2) @group(0) var<uniform> phongMaterial : phongMaterialUniforms;
+@group(3) @binding(auto) var<uniform> phongMaterial : phongMaterialUniforms;
 
 fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
   let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
@@ -2939,6 +4043,10 @@ fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, v
 fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
   var lightColor: vec3<f32> = surfaceColor;
 
+  if (phongMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
   if (lighting.enabled == 0) {
     return lightColor;
   }
@@ -2946,56 +4054,86 @@ fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, p
   let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
   lightColor = phongMaterial.ambient * surfaceColor * lighting.ambientColor;
 
-  if (lighting.lightType == 0) {
-    let pointLight: PointLight  = lighting_getPointLight(0);
+  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);
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-  } else if (lighting.lightType == 1) {
-    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
-    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    let light_attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(light_position_worldspace, position_worldspace)
+    );
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      view_direction,
+      normal_worldspace,
+      pointLight.color / light_attenuation
+    );
   }
-  
-  return lightColor;
-  /*
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.pointLightCount) {
-      break;
-    }
-    PointLight pointLight = lighting.pointLight[i];
-    vec3 light_position_worldspace = pointLight.position;
-    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+
+  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 (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.directionalLightCount) {
-      break;
-    }
-    DirectionalLight directionalLight = lighting.directionalLight[i];
+  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);
-  }
-  */
+  }  
+  
+  return lightColor;
 }
 
 fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{
   var lightColor = vec3<f32>(0, 0, 0);
   let surfaceColor = vec3<f32>(0, 0, 0);
 
-  if (lighting.enabled == 0) {
+  if (lighting.enabled != 0) {
     let view_direction = normalize(cameraPosition - position_worldspace);
 
-    switch (lighting.lightType) {
-      case 0, default: {
-        let pointLight: PointLight = lighting_getPointLight(0);
-        let light_position_worldspace: vec3<f32> = pointLight.position;
-        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
-        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-      }
-      case 1: {
-        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+    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,
+        view_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,
+        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);
-      }
     }
   }
   return lightColor;
@@ -3007,6 +4145,7 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
 var gouraudMaterial = {
   props: {},
   name: "gouraudMaterial",
+  bindingLayout: [{ name: "gouraudMaterial", group: 3 }],
   // Note these are switched between phong and gouraud
   vs: PHONG_FS.replace("phongMaterial", "gouraudMaterial"),
   fs: PHONG_VS.replace("phongMaterial", "gouraudMaterial"),
@@ -3016,12 +4155,14 @@ var gouraudMaterial = {
   },
   dependencies: [lighting],
   uniformTypes: {
+    unlit: "i32",
     ambient: "f32",
     diffuse: "f32",
     shininess: "f32",
     specularColor: "vec3<f32>"
   },
   defaultUniforms: {
+    unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,
@@ -3039,6 +4180,8 @@ var gouraudMaterial = {
 // dist/modules/lighting/phong-material/phong-material.js
 var phongMaterial = {
   name: "phongMaterial",
+  firstBindingSlot: 0,
+  bindingLayout: [{ name: "phongMaterial", group: 3 }],
   dependencies: [lighting],
   // Note these are switched between phong and gouraud
   source: PHONG_WGSL,
@@ -3048,12 +4191,14 @@ var phongMaterial = {
     LIGHTING_FRAGMENT: true
   },
   uniformTypes: {
+    unlit: "i32",
     ambient: "f32",
     diffuse: "f32",
     shininess: "f32",
     specularColor: "vec3<f32>"
   },
   defaultUniforms: {
+    unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,
@@ -3069,7 +4214,7 @@ var phongMaterial = {
 };
 
 // dist/modules/lighting/pbr-material/pbr-material-glsl.js
-var vs2 = (
+var vs3 = (
   /* glsl */
   `out vec3 pbr_vPosition;
 out vec2 pbr_vUV;
@@ -3106,7 +4251,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 }
 `
 );
-var fs3 = (
+var fs4 = (
   /* glsl */
   `precision highp float;
 
@@ -3150,10 +4295,12 @@ uniform pbrMaterialUniforms {
   float clearcoatFactor;
   float clearcoatRoughnessFactor;
   bool clearcoatMapEnabled;
+  bool clearcoatRoughnessMapEnabled;
 
   vec3 sheenColorFactor;
   float sheenRoughnessFactor;
   bool sheenColorMapEnabled;
+  bool sheenRoughnessMapEnabled;
 
   float iridescenceFactor;
   float iridescenceIor;
@@ -3203,26 +4350,33 @@ uniform sampler2D pbr_specularIntensitySampler;
 #ifdef HAS_TRANSMISSIONMAP
 uniform sampler2D pbr_transmissionSampler;
 #endif
+#ifdef HAS_THICKNESSMAP
+uniform sampler2D pbr_thicknessSampler;
+#endif
 #ifdef HAS_CLEARCOATMAP
 uniform sampler2D pbr_clearcoatSampler;
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
 uniform sampler2D pbr_clearcoatRoughnessSampler;
 #endif
+#ifdef HAS_CLEARCOATNORMALMAP
+uniform sampler2D pbr_clearcoatNormalSampler;
+#endif
 #ifdef HAS_SHEENCOLORMAP
 uniform sampler2D pbr_sheenColorSampler;
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
 uniform sampler2D pbr_sheenRoughnessSampler;
 #endif
 #ifdef HAS_IRIDESCENCEMAP
 uniform sampler2D pbr_iridescenceSampler;
 #endif
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+uniform sampler2D pbr_iridescenceThicknessSampler;
+#endif
 #ifdef HAS_ANISOTROPYMAP
 uniform sampler2D pbr_anisotropySampler;
 #endif
-#ifdef USE_IBL
-uniform samplerCube pbr_diffuseEnvSampler;
-uniform samplerCube pbr_specularEnvSampler;
-uniform sampler2D pbr_brdfLUT;
-#endif
-
 // Inputs from vertex shader
 
 in vec3 pbr_vPosition;
@@ -3259,6 +4413,8 @@ struct PBRInfo {
 const float M_PI = 3.141592653589793;
 const float c_MinRoughness = 0.04;
 
+vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor);
+
 vec4 SRGBtoLINEAR(vec4 srgbIn)
 {
 #ifdef MANUAL_SRGB
@@ -3274,11 +4430,9 @@ vec4 SRGBtoLINEAR(vec4 srgbIn)
 #endif //MANUAL_SRGB
 }
 
-// Find the normal for this fragment, pulling either from a predefined normal map
-// or from the interpolated mesh normal and tangent attributes.
-vec3 getNormal()
+// Build the tangent basis from interpolated attributes or screen-space derivatives.
+mat3 getTBN()
 {
-  // Retrieve the tangent space matrix
 #ifndef HAS_TANGENTS
   vec3 pos_dx = dFdx(pbr_vPosition);
   vec3 pos_dy = dFdy(pbr_vPosition);
@@ -3299,9 +4453,21 @@ vec3 getNormal()
   mat3 tbn = pbr_vTBN;
 #endif
 
+  return tbn;
+}
+
+// Find the normal for this fragment, pulling either from a predefined normal map
+// or from the interpolated mesh normal and tangent attributes.
+vec3 getMappedNormal(sampler2D normalSampler, mat3 tbn, float normalScale)
+{
+  vec3 n = texture(normalSampler, pbr_vUV).rgb;
+  return normalize(tbn * ((2.0 * n - 1.0) * vec3(normalScale, normalScale, 1.0)));
+}
+
+vec3 getNormal(mat3 tbn)
+{
 #ifdef HAS_NORMALMAP
-  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
+  vec3 n = getMappedNormal(pbr_normalSampler, tbn, pbrMaterial.normalScale);
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   vec3 n = normalize(tbn[2].xyz);
@@ -3310,6 +4476,15 @@ vec3 getNormal()
   return n;
 }
 
+vec3 getClearcoatNormal(mat3 tbn, vec3 baseNormal)
+{
+#ifdef HAS_CLEARCOATNORMALMAP
+  return getMappedNormal(pbr_clearcoatNormalSampler, tbn, 1.0);
+#else
+  return baseNormal;
+#endif
+}
+
 // Calculation of the lighting contribution from an optional Image Based Light source.
 // Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
 // See our README.md on Environment Maps [3] for additional discussion.
@@ -3385,30 +4560,198 @@ float microfacetDistribution(PBRInfo pbrInfo)
   return roughnessSq / (M_PI * f * f);
 }
 
-void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
-  pbrInfo.NdotL = 1.0;
-  pbrInfo.NdotH = 0.0;
-  pbrInfo.LdotH = 0.0;
-  pbrInfo.VdotH = 1.0;
+float maxComponent(vec3 value)
+{
+  return max(max(value.r, value.g), value.b);
 }
 
-void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
-  vec3 n = pbrInfo.n;
-  vec3 v = pbrInfo.v;
-  vec3 l = normalize(lightDirection);             // Vector from surface point to light
-  vec3 h = normalize(l+v);                        // Half vector between both l and v
+float getDielectricF0(float ior)
+{
+  float clampedIor = max(ior, 1.0);
+  float ratio = (clampedIor - 1.0) / (clampedIor + 1.0);
+  return ratio * ratio;
+}
 
-  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
-  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
-  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
-  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
+vec2 normalizeDirection(vec2 direction)
+{
+  float directionLength = length(direction);
+  return directionLength > 0.0001 ? direction / directionLength : vec2(1.0, 0.0);
 }
 
-void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
+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;
+  pbrInfo.VdotH = 1.0;
+}
+
+void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
+  vec3 n = pbrInfo.n;
+  vec3 v = pbrInfo.v;
+  vec3 l = normalize(lightDirection);             // Vector from surface point to light
+  vec3 h = normalize(l+v);                        // Half vector between both l and v
+
+  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
+  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
+  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
+  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
+}
+
+void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
   vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
   PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
+void PBRInfo_setSpotLight(inout PBRInfo pbrInfo, SpotLight spotLight) {
+  vec3 light_direction = normalize(spotLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
 vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
   // Calculate the shading terms for the microfacet specular shading model
   vec3 F = specularReflection(pbrInfo);
@@ -3439,6 +4782,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
   vec3 color = vec3(0, 0, 0);
 
+  float transmission = 0.0;
+
   if(pbrMaterial.unlit){
     color.rgb = baseColor.rgb;
   }
@@ -3457,14 +4802,252 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #endif
     perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
     metallic = clamp(metallic, 0.0, 1.0);
+    mat3 tbn = getTBN();
+    vec3 n = getNormal(tbn);                          // normal at surface point
+    vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
+    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
+#ifdef USE_MATERIAL_EXTENSIONS
+    bool useExtendedPBR =
+      pbrMaterial.specularColorMapEnabled ||
+      pbrMaterial.specularIntensityMapEnabled ||
+      abs(pbrMaterial.specularIntensityFactor - 1.0) > 0.0001 ||
+      maxComponent(abs(pbrMaterial.specularColorFactor - vec3(1.0))) > 0.0001 ||
+      abs(pbrMaterial.ior - 1.5) > 0.0001 ||
+      pbrMaterial.transmissionMapEnabled ||
+      pbrMaterial.transmissionFactor > 0.0001 ||
+      pbrMaterial.clearcoatMapEnabled ||
+      pbrMaterial.clearcoatRoughnessMapEnabled ||
+      pbrMaterial.clearcoatFactor > 0.0001 ||
+      pbrMaterial.clearcoatRoughnessFactor > 0.0001 ||
+      pbrMaterial.sheenColorMapEnabled ||
+      pbrMaterial.sheenRoughnessMapEnabled ||
+      maxComponent(pbrMaterial.sheenColorFactor) > 0.0001 ||
+      pbrMaterial.sheenRoughnessFactor > 0.0001 ||
+      pbrMaterial.iridescenceMapEnabled ||
+      pbrMaterial.iridescenceFactor > 0.0001 ||
+      abs(pbrMaterial.iridescenceIor - 1.3) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.x - 100.0) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.y - 400.0) > 0.0001 ||
+      pbrMaterial.anisotropyMapEnabled ||
+      pbrMaterial.anisotropyStrength > 0.0001 ||
+      abs(pbrMaterial.anisotropyRotation) > 0.0001 ||
+      length(pbrMaterial.anisotropyDirection - vec2(1.0, 0.0)) > 0.0001;
+#else
+    bool useExtendedPBR = false;
+#endif
+
+    if (!useExtendedPBR) {
+      // Keep the baseline metallic-roughness implementation byte-for-byte equivalent in behavior.
+      float alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+      vec3 f0 = vec3(0.04);
+      vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
+      diffuseColor *= 1.0 - metallic;
+      vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+
+      float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+      float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+      vec3 specularEnvironmentR0 = specularColor.rgb;
+      vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
+      vec3 reflection = -normalize(reflect(v, n));
+
+      PBRInfo pbrInfo = PBRInfo(
+        0.0, // NdotL
+        NdotV,
+        0.0, // NdotH
+        0.0, // LdotH
+        0.0, // VdotH
+        perceptualRoughness,
+        metallic,
+        specularEnvironmentR0,
+        specularEnvironmentR90,
+        alphaRoughness,
+        diffuseColor,
+        specularColor,
+        n,
+        v
+      );
+
+#ifdef USE_LIGHTS
+      PBRInfo_setAmbientLight(pbrInfo);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+
+      for(int i = 0; i < lighting.directionalLightCount; i++) {
+        if (i < lighting.directionalLightCount) {
+          PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        }
+      }
+
+      for(int i = 0; i < lighting.pointLightCount; i++) {
+        if (i < lighting.pointLightCount) {
+          PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+          float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        }
+      }
+
+      for(int i = 0; i < lighting.spotLightCount; i++) {
+        if (i < lighting.spotLightCount) {
+          PBRInfo_setSpotLight(pbrInfo, lighting_getSpotLight(i));
+          float attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), pbr_vPosition);
+          color += calculateFinalColor(pbrInfo, lighting_getSpotLight(i).color / attenuation);
+        }
+      }
+#endif
+
+#ifdef USE_IBL
+      if (pbrMaterial.IBLenabled) {
+        color += getIBLContribution(pbrInfo, n, reflection);
+      }
+#endif
+
+#ifdef HAS_OCCLUSIONMAP
+      if (pbrMaterial.occlusionMapEnabled) {
+        float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+        color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+      }
+#endif
+
+      vec3 emissive = pbrMaterial.emissiveFactor;
+#ifdef HAS_EMISSIVEMAP
+      if (pbrMaterial.emissiveMapEnabled) {
+        emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb;
+      }
+#endif
+      color += emissive * pbrMaterial.emissiveStrength;
+
+#ifdef PBR_DEBUG
+      color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+      color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+      color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+#endif
+
+      return vec4(pow(color, vec3(1.0 / 2.2)), baseColor.a);
+    }
+
+    float specularIntensity = pbrMaterial.specularIntensityFactor;
+#ifdef HAS_SPECULARINTENSITYMAP
+    if (pbrMaterial.specularIntensityMapEnabled) {
+      specularIntensity *= texture(pbr_specularIntensitySampler, pbr_vUV).a;
+    }
+#endif
+
+    vec3 specularFactor = pbrMaterial.specularColorFactor;
+#ifdef HAS_SPECULARCOLORMAP
+    if (pbrMaterial.specularColorMapEnabled) {
+      specularFactor *= SRGBtoLINEAR(texture(pbr_specularColorSampler, pbr_vUV)).rgb;
+    }
+#endif
+
+    transmission = pbrMaterial.transmissionFactor;
+#ifdef HAS_TRANSMISSIONMAP
+    if (pbrMaterial.transmissionMapEnabled) {
+      transmission *= texture(pbr_transmissionSampler, pbr_vUV).r;
+    }
+#endif
+    transmission = clamp(transmission * (1.0 - metallic), 0.0, 1.0);
+    float thickness = max(pbrMaterial.thicknessFactor, 0.0);
+#ifdef HAS_THICKNESSMAP
+    thickness *= texture(pbr_thicknessSampler, pbr_vUV).g;
+#endif
+
+    float clearcoatFactor = pbrMaterial.clearcoatFactor;
+    float clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
+#ifdef HAS_CLEARCOATMAP
+    if (pbrMaterial.clearcoatMapEnabled) {
+      clearcoatFactor *= texture(pbr_clearcoatSampler, pbr_vUV).r;
+    }
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
+    if (pbrMaterial.clearcoatRoughnessMapEnabled) {
+      clearcoatRoughness *= texture(pbr_clearcoatRoughnessSampler, pbr_vUV).g;
+    }
+#endif
+    clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
+    clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+    vec3 clearcoatNormal = getClearcoatNormal(tbn, n);
+
+    vec3 sheenColor = pbrMaterial.sheenColorFactor;
+    float sheenRoughness = pbrMaterial.sheenRoughnessFactor;
+#ifdef HAS_SHEENCOLORMAP
+    if (pbrMaterial.sheenColorMapEnabled) {
+      sheenColor *= SRGBtoLINEAR(texture(pbr_sheenColorSampler, pbr_vUV)).rgb;
+    }
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
+    if (pbrMaterial.sheenRoughnessMapEnabled) {
+      sheenRoughness *= texture(pbr_sheenRoughnessSampler, pbr_vUV).a;
+    }
+#endif
+    sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
+
+    float iridescence = pbrMaterial.iridescenceFactor;
+#ifdef HAS_IRIDESCENCEMAP
+    if (pbrMaterial.iridescenceMapEnabled) {
+      iridescence *= texture(pbr_iridescenceSampler, pbr_vUV).r;
+    }
+#endif
+    iridescence = clamp(iridescence, 0.0, 1.0);
+    float iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      0.5
+    );
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+    iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      texture(pbr_iridescenceThicknessSampler, pbr_vUV).g
+    );
+#endif
+
+    float anisotropyStrength = clamp(pbrMaterial.anisotropyStrength, 0.0, 1.0);
+    vec2 anisotropyDirection = normalizeDirection(pbrMaterial.anisotropyDirection);
+#ifdef HAS_ANISOTROPYMAP
+    if (pbrMaterial.anisotropyMapEnabled) {
+      vec3 anisotropySample = texture(pbr_anisotropySampler, pbr_vUV).rgb;
+      anisotropyStrength *= anisotropySample.b;
+      vec2 mappedDirection = anisotropySample.rg * 2.0 - 1.0;
+      if (length(mappedDirection) > 0.0001) {
+        anisotropyDirection = normalize(mappedDirection);
+      }
+    }
+#endif
+    anisotropyDirection = rotateDirection(anisotropyDirection, pbrMaterial.anisotropyRotation);
+    vec3 anisotropyTangent = normalize(tbn[0] * anisotropyDirection.x + tbn[1] * anisotropyDirection.y);
+    if (length(anisotropyTangent) < 0.0001) {
+      anisotropyTangent = normalize(tbn[0]);
+    }
+    float anisotropyViewAlignment = abs(dot(v, anisotropyTangent));
+    perceptualRoughness = mix(
+      perceptualRoughness,
+      clamp(perceptualRoughness * (1.0 - 0.6 * anisotropyViewAlignment), c_MinRoughness, 1.0),
+      anisotropyStrength
+    );
+
     // Roughness is authored as perceptual roughness; as is convention,
     // convert to material roughness by squaring the perceptual roughness [2].
     float alphaRoughness = perceptualRoughness * perceptualRoughness;
 
-    vec3 f0 = vec3(0.04);
-    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
-    diffuseColor *= 1.0 - metallic;
-    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+    float dielectricF0 = getDielectricF0(pbrMaterial.ior);
+    vec3 dielectricSpecularF0 = min(
+      vec3(dielectricF0) * specularFactor * specularIntensity,
+      vec3(1.0)
+    );
+    vec3 iridescenceTint = getIridescenceTint(iridescence, iridescenceThickness, NdotV);
+    dielectricSpecularF0 = mix(
+      dielectricSpecularF0,
+      dielectricSpecularF0 * iridescenceTint,
+      iridescence
+    );
+    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - dielectricSpecularF0);
+    diffuseColor *= (1.0 - metallic) * (1.0 - transmission);
+    vec3 specularColor = mix(dielectricSpecularF0, baseColor.rgb, metallic);
+
+    float baseLayerEnergy = 1.0 - clearcoatFactor * 0.25;
+    diffuseColor *= baseLayerEnergy;
+    specularColor *= baseLayerEnergy;
 
     // Compute reflectance.
     float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
@@ -3476,11 +5059,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
     vec3 specularEnvironmentR0 = specularColor.rgb;
     vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
-
-    vec3 n = getNormal();                          // normal at surface point
-    vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
-
-    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
     vec3 reflection = -normalize(reflect(v, n));
 
     PBRInfo pbrInfo = PBRInfo(
@@ -3504,13 +5082,33 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef USE_LIGHTS
     // Apply ambient light
     PBRInfo_setAmbientLight(pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+    color += calculateMaterialLightColor(
+      pbrInfo,
+      lighting.ambientColor,
+      clearcoatNormal,
+      clearcoatFactor,
+      clearcoatRoughness,
+      sheenColor,
+      sheenRoughness,
+      anisotropyTangent,
+      anisotropyStrength
+    );
 
     // Apply directional light
     for(int i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
         PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
-        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getDirectionalLight(i).color,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
 
@@ -3519,7 +5117,35 @@ vec4 pbr_filterColor(vec4 colorUnused)
       if (i < lighting.pointLightCount) {
         PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
         float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
-        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getPointLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
+      }
+    }
+
+    for(int i = 0; i < lighting.spotLightCount; i++) {
+      if (i < lighting.spotLightCount) {
+        PBRInfo_setSpotLight(pbrInfo, lighting_getSpotLight(i));
+        float attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), pbr_vPosition);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getSpotLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
 #endif
@@ -3527,7 +5153,16 @@ vec4 pbr_filterColor(vec4 colorUnused)
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
     if (pbrMaterial.IBLenabled) {
-      color += getIBLContribution(pbrInfo, n, reflection);
+      color += getIBLContribution(pbrInfo, n, reflection) *
+        calculateAnisotropyBoost(pbrInfo, anisotropyTangent, anisotropyStrength);
+      color += calculateClearcoatIBLContribution(
+        pbrInfo,
+        clearcoatNormal,
+        -normalize(reflect(v, clearcoatNormal)),
+        clearcoatFactor,
+        clearcoatRoughness
+      );
+      color += sheenColor * pbrMaterial.scaleIBLAmbient.x * (1.0 - sheenRoughness) * 0.25;
     }
 #endif
 
@@ -3539,12 +5174,17 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
 #endif
 
+    vec3 emissive = pbrMaterial.emissiveFactor;
 #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled) {
-      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
-      color += emissive;
+      emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb;
     }
 #endif
+    color += emissive * pbrMaterial.emissiveStrength;
+
+    if (transmission > 0.0) {
+      color = mix(color, color * getVolumeAttenuation(thickness), transmission);
+    }
 
     // This section uses mix to override final color for reference app visualization
     // of various parameters in the lighting equation.
@@ -3564,68 +5204,109 @@ 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);
 }
 `
 );
 
 // dist/modules/lighting/pbr-material/pbr-material-wgsl.js
-var source2 = (
+var source3 = (
   /* wgsl */
   `struct PBRFragmentInputs {
   pbr_vPosition: vec3f,
   pbr_vUV: vec2f,
-  pbr_vTBN: mat3f,
+  pbr_vTBN: mat3x3f,
   pbr_vNormal: vec3f
 };
 
-var fragmentInputs: PBRFragmentInputs;
+var<private> fragmentInputs: PBRFragmentInputs;
 
 fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f, uv: vec2f)
 {
   var pos: vec4f = pbrProjection.modelMatrix * position;
-  fragmentInputs.pbr_vPosition = vec3(pos.xyz) / pos.w;
+  fragmentInputs.pbr_vPosition = pos.xyz / pos.w;
+  fragmentInputs.pbr_vNormal = vec3f(0.0, 0.0, 1.0);
+  fragmentInputs.pbr_vTBN = mat3x3f(
+    vec3f(1.0, 0.0, 0.0),
+    vec3f(0.0, 1.0, 0.0),
+    vec3f(0.0, 0.0, 1.0)
+  );
+  fragmentInputs.pbr_vUV = vec2f(0.0, 0.0);
 
 #ifdef HAS_NORMALS
+  let normalW: vec3f = normalize((pbrProjection.normalMatrix * vec4f(normal.xyz, 0.0)).xyz);
+  fragmentInputs.pbr_vNormal = normalW;
 #ifdef HAS_TANGENTS
-  let normalW: vec3f = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
-  let tangentW: vec3f = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  let tangentW: vec3f = normalize((pbrProjection.modelMatrix * vec4f(tangent.xyz, 0.0)).xyz);
   let bitangentW: vec3f = cross(normalW, tangentW) * tangent.w;
-  fragmentInputs.pbr_vTBN = mat3(tangentW, bitangentW, normalW);
-#else // HAS_TANGENTS != 1
-  fragmentInputs.pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+  fragmentInputs.pbr_vTBN = mat3x3f(tangentW, bitangentW, normalW);
 #endif
 #endif
 
 #ifdef HAS_UV
   fragmentInputs.pbr_vUV = uv;
-#else
-  fragmentInputs.pbr_vUV = vec2(0.,0.);
 #endif
 }
 
 struct pbrMaterialUniforms {
   // Material is unlit
-  unlit: uint32,
+  unlit: u32,
 
   // Base color map
-  baseColorMapEnabled: uint32,
+  baseColorMapEnabled: u32,
   baseColorFactor: vec4f,
 
-  normalMapEnabled : uint32,
+  normalMapEnabled : u32,
   normalScale: f32,  // #ifdef HAS_NORMALMAP
 
-  emissiveMapEnabled: uint32,
+  emissiveMapEnabled: u32,
   emissiveFactor: vec3f, // #ifdef HAS_EMISSIVEMAP
 
   metallicRoughnessValues: vec2f,
-  metallicRoughnessMapEnabled: uint32,
+  metallicRoughnessMapEnabled: u32,
 
   occlusionMapEnabled: i32,
   occlusionStrength: f32, // #ifdef HAS_OCCLUSIONMAP
   
   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,
@@ -3634,34 +5315,81 @@ struct pbrMaterialUniforms {
   // debugging flags used for shader output of intermediate PBR variables
   // #ifdef PBR_DEBUG
   scaleDiffBaseMR: vec4f,
-  scaleFGDSpec: vec4f
+  scaleFGDSpec: vec4f,
   // #endif
 }
 
-@binding(2) @group(0) var<uniform> pbrMaterial : pbrMaterialUniforms;
+@group(3) @binding(auto) var<uniform> pbrMaterial : pbrMaterialUniforms;
 
 // Samplers
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D pbr_baseColorSampler;
+@group(3) @binding(auto) var pbr_baseColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_baseColorSamplerSampler: sampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D pbr_normalSampler;
+@group(3) @binding(auto) var pbr_normalSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_normalSamplerSampler: sampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D pbr_emissiveSampler;
+@group(3) @binding(auto) var pbr_emissiveSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_emissiveSamplerSampler: sampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D pbr_metallicRoughnessSampler;
+@group(3) @binding(auto) var pbr_metallicRoughnessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_metallicRoughnessSamplerSampler: sampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-uniform sampler2D pbr_occlusionSampler;
+@group(3) @binding(auto) var pbr_occlusionSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_occlusionSamplerSampler: sampler;
 #endif
-#ifdef USE_IBL
-uniform samplerCube pbr_diffuseEnvSampler;
-uniform samplerCube pbr_specularEnvSampler;
-uniform sampler2D pbr_brdfLUT;
+#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.
@@ -3687,80 +5415,130 @@ const c_MinRoughness = 0.04;
 
 fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
 {
+  var linOut: vec3f = srgbIn.xyz;
 #ifdef MANUAL_SRGB
+  let bLess: vec3f = step(vec3f(0.04045), srgbIn.xyz);
+  linOut = mix(
+    srgbIn.xyz / vec3f(12.92),
+    pow((srgbIn.xyz + vec3f(0.055)) / vec3f(1.055), vec3f(2.4)),
+    bLess
+  );
 #ifdef SRGB_FAST_APPROXIMATION
-  var linOut: vec3f = pow(srgbIn.xyz,vec3(2.2));
-#else // SRGB_FAST_APPROXIMATION
-  var bLess: vec3f = step(vec3(0.04045),srgbIn.xyz);
-  var linOut: vec3f = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
-#endif //SRGB_FAST_APPROXIMATION
-  return vec4f(linOut,srgbIn.w);;
-#else //MANUAL_SRGB
-  return srgbIn;
-#endif //MANUAL_SRGB
+  linOut = pow(srgbIn.xyz, vec3f(2.2));
+#endif
+#endif
+  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
-#ifndef HAS_TANGENTS
-  var pos_dx: vec3f = dFdx(fragmentInputs.pbr_vPosition);
-  var pos_dy: vec3f = dFdy(fragmentInputs.pbr_vPosition);
-  var tex_dx: vec3f = dFdx(vec3(fragmentInputs.pbr_vUV, 0.0));
-  var tex_dy: vec3f = dFdy(vec3(fragmentInputs.pbr_vUV, 0.0));
-  var t: vec3f = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+  let pos_dx: vec3f = dpdx(fragmentInputs.pbr_vPosition);
+  let pos_dy: vec3f = dpdy(fragmentInputs.pbr_vPosition);
+  let tex_dx: vec3f = dpdx(vec3f(fragmentInputs.pbr_vUV, 0.0));
+  let tex_dy: vec3f = dpdy(vec3f(fragmentInputs.pbr_vUV, 0.0));
+  var t: vec3f = (tex_dy.y * pos_dx - tex_dx.y * pos_dy) / (tex_dx.x * tex_dy.y - tex_dy.x * tex_dx.y);
 
-#ifdef HAS_NORMALS
-  var ng: vec3f = normalize(fragmentInputs.pbr_vNormal);
-#else
   var ng: vec3f = cross(pos_dx, pos_dy);
+#ifdef HAS_NORMALS
+  ng = normalize(fragmentInputs.pbr_vNormal);
 #endif
-
   t = normalize(t - ng * dot(ng, t));
   var b: vec3f = normalize(cross(ng, t));
-  var tbn: mat3f = mat3f(t, b, ng);
-#else // HAS_TANGENTS
-  var tbn: mat3f = fragmentInputs.pbr_vTBN;
+  var tbn: mat3x3f = mat3x3f(t, b, ng);
+#ifdef HAS_TANGENTS
+  tbn = fragmentInputs.pbr_vTBN;
 #endif
 
-#ifdef HAS_NORMALMAP
-  vec3 n = texture(pbr_normalSampler, fragmentInputs.pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
-#else
+  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
-  vec3 n = normalize(tbn[2].xyz);
+  var n: vec3f = normalize(tbn[2].xyz);
+#ifdef HAS_NORMALMAP
+  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.
 #ifdef USE_IBL
-fn getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection) -> vec3f
+fn getIBLContribution(pbrInfo: PBRInfo, n: vec3f, reflection: vec3f) -> vec3f
 {
-  float mipCount = 9.0; // resolution of 512x512
-  float lod = (pbrInfo.perceptualRoughness * mipCount);
+  let mipCount: f32 = 9.0; // resolution of 512x512
+  let lod: f32 = pbrInfo.perceptualRoughness * mipCount;
   // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
-    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
-  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
-
+  let brdf = SRGBtoLINEAR(
+    textureSampleLevel(
+      pbr_brdfLUT,
+      pbr_brdfLUTSampler,
+      vec2f(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness),
+      0.0
+    )
+  ).rgb;
+  let diffuseLight =
+    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
-  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
-#else
-  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
+  specularLight = SRGBtoLINEAR(
+    textureSampleLevel(
+      pbr_specularEnvSampler,
+      pbr_specularEnvSamplerSampler,
+      reflection,
+      lod
+    )
+  ).rgb;
 #endif
 
-  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
-  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
-
-  // For presentation, this allows us to disable IBL terms
-  diffuse *= pbrMaterial.scaleIBLAmbient.x;
-  specular *= pbrMaterial.scaleIBLAmbient.y;
+  let diffuse = diffuseLight * pbrInfo.diffuseColor * pbrMaterial.scaleIBLAmbient.x;
+  let specular =
+    specularLight * (pbrInfo.specularColor * brdf.x + brdf.y) * pbrMaterial.scaleIBLAmbient.y;
 
   return diffuse + specular;
 }
@@ -3804,7 +5582,173 @@ fn geometricOcclusion(pbrInfo: PBRInfo) -> f32 {
 fn microfacetDistribution(pbrInfo: PBRInfo) -> f32 {
   let roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
   let f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
-  return roughnessSq / (PI * f * f);
+  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>) {
@@ -3831,6 +5775,11 @@ fn PBRInfo_setPointLight(pbrInfo: ptr<function, PBRInfo>, pointLight: PointLight
   PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
+fn PBRInfo_setSpotLight(pbrInfo: ptr<function, PBRInfo>, spotLight: SpotLight) {
+  let light_direction = normalize(spotLight.position - fragmentInputs.pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
 fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
   // Calculate the shading terms for the microfacet specular shading model
   let F = specularReflection(pbrInfo);
@@ -3846,11 +5795,11 @@ fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
 
 fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   // The albedo may be defined from a base texture or a flat color
-  var baseColor: vec4<f32>;
+  var baseColor: vec4<f32> = pbrMaterial.baseColorFactor;
   #ifdef HAS_BASECOLORMAP
-  baseColor = SRGBtoLINEAR(textureSample(pbr_baseColorSampler, pbr_baseColorSampler, fragmentInputs.pbr_vUV)) * pbrMaterial.baseColorFactor;
-  #else
-  baseColor = pbrMaterial.baseColorFactor;
+  baseColor = SRGBtoLINEAR(
+    textureSample(pbr_baseColorSampler, pbr_baseColorSamplerSampler, fragmentInputs.pbr_vUV)
+  ) * pbrMaterial.baseColorFactor;
   #endif
 
   #ifdef ALPHA_CUTOFF
@@ -3860,8 +5809,9 @@ 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) {
+  if (pbrMaterial.unlit != 0u) {
     color = baseColor.rgb;
   } else {
     // Metallic and Roughness material properties are packed together
@@ -3872,20 +5822,318 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    let mrSample = textureSample(pbr_metallicRoughnessSampler, pbr_metallicRoughnessSampler, fragmentInputs.pbr_vUV);
+    let mrSample = textureSample(
+      pbr_metallicRoughnessSampler,
+      pbr_metallicRoughnessSamplerSampler,
+      fragmentInputs.pbr_vUV
+    );
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
     #endif
     perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
     metallic = clamp(metallic, 0.0, 1.0);
+    let tbn = getTBN();
+    let n = getNormal(tbn);                          // normal at surface point
+    let 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);
@@ -3897,11 +6145,6 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     let reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
     let specularEnvironmentR0 = specularColor;
     let specularEnvironmentR90 = vec3<f32>(1.0, 1.0, 1.0) * reflectance90;
-
-    let n = getNormal();                          // normal at surface point
-    let v = normalize(pbrProjection.camera - fragmentInputs.pbr_vPosition);  // Vector from surface point to camera
-
-    let NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
     let reflection = -normalize(reflect(v, n));
 
     var pbrInfo = PBRInfo(
@@ -3924,13 +6167,33 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #ifdef USE_LIGHTS
     // Apply ambient light
     PBRInfo_setAmbientLight(&pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+    color += calculateMaterialLightColor(
+      pbrInfo,
+      lighting.ambientColor,
+      clearcoatNormal,
+      clearcoatFactor,
+      clearcoatRoughness,
+      sheenColor,
+      sheenRoughness,
+      anisotropyTangent,
+      anisotropyStrength
+    );
 
     // Apply directional light
     for (var i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
         PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
-        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getDirectionalLight(i).color,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
 
@@ -3942,32 +6205,77 @@ 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
 
     // Calculate lighting contribution from image based lighting source (IBL)
     #ifdef USE_IBL
-    if (pbrMaterial.IBLenabled) {
-      color += getIBLContribution(pbrInfo, n, reflection);
+    if (pbrMaterial.IBLenabled != 0) {
+      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
 
     // Apply optional PBR terms for additional (optional) shading
     #ifdef HAS_OCCLUSIONMAP
-    if (pbrMaterial.occlusionMapEnabled) {
-      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSampler, fragmentInputs.pbr_vUV).r;
+    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) {
-      let emissive = SRGBtoLINEAR(textureSample(pbr_emissiveSampler, pbr_emissiveSampler, fragmentInputs.pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
-      color += emissive;
+    if (pbrMaterial.emissiveMapEnabled != 0u) {
+      emissive *= SRGBtoLINEAR(
+        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.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.
@@ -3986,7 +6294,8 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #endif
   }
 
-  return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), baseColor.a);
+  let alpha = clamp(baseColor.a * (1.0 - transmission), 0.0, 1.0);
+  return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), alpha);
 }
 `
 );
@@ -4002,8 +6311,22 @@ var uniformBlock = (
 } pbrProjection;
 `
 );
+var wgslUniformBlock = (
+  /* wgsl */
+  `struct pbrProjectionUniforms {
+  modelViewProjectionMatrix: mat4x4<f32>,
+  modelMatrix: mat4x4<f32>,
+  normalMatrix: mat4x4<f32>,
+  camera: vec3<f32>
+};
+
+@group(0) @binding(auto) var<uniform> pbrProjection: pbrProjectionUniforms;
+`
+);
 var pbrProjection = {
   name: "pbrProjection",
+  bindingLayout: [{ name: "pbrProjection", group: 0 }],
+  source: wgslUniformBlock,
   vs: uniformBlock,
   fs: uniformBlock,
   // TODO why is this needed?
@@ -4012,7 +6335,7 @@ var pbrProjection = {
     modelViewProjectionMatrix: "mat4x4<f32>",
     modelMatrix: "mat4x4<f32>",
     normalMatrix: "mat4x4<f32>",
-    camera: "vec3<i32>"
+    camera: "vec3<f32>"
   }
 };
 
@@ -4020,11 +6343,78 @@ var pbrProjection = {
 var pbrMaterial = {
   props: {},
   uniforms: {},
+  defaultUniforms: {
+    unlit: false,
+    baseColorMapEnabled: false,
+    baseColorFactor: [1, 1, 1, 1],
+    normalMapEnabled: false,
+    normalScale: 1,
+    emissiveMapEnabled: false,
+    emissiveFactor: [0, 0, 0],
+    metallicRoughnessValues: [1, 1],
+    metallicRoughnessMapEnabled: false,
+    occlusionMapEnabled: false,
+    occlusionStrength: 1,
+    alphaCutoffEnabled: false,
+    alphaCutoff: 0.5,
+    IBLenabled: false,
+    scaleIBLAmbient: [1, 1],
+    scaleDiffBaseMR: [0, 0, 0, 0],
+    scaleFGDSpec: [0, 0, 0, 0],
+    specularColorFactor: [1, 1, 1],
+    specularIntensityFactor: 1,
+    specularColorMapEnabled: false,
+    specularIntensityMapEnabled: false,
+    ior: 1.5,
+    transmissionFactor: 0,
+    transmissionMapEnabled: false,
+    thicknessFactor: 0,
+    attenuationDistance: 1e9,
+    attenuationColor: [1, 1, 1],
+    clearcoatFactor: 0,
+    clearcoatRoughnessFactor: 0,
+    clearcoatMapEnabled: false,
+    clearcoatRoughnessMapEnabled: false,
+    sheenColorFactor: [0, 0, 0],
+    sheenRoughnessFactor: 0,
+    sheenColorMapEnabled: false,
+    sheenRoughnessMapEnabled: false,
+    iridescenceFactor: 0,
+    iridescenceIor: 1.3,
+    iridescenceThicknessRange: [100, 400],
+    iridescenceMapEnabled: false,
+    anisotropyStrength: 0,
+    anisotropyRotation: 0,
+    anisotropyDirection: [1, 0],
+    anisotropyMapEnabled: false,
+    emissiveStrength: 1
+  },
   name: "pbrMaterial",
-  dependencies: [lighting, pbrProjection],
-  source: source2,
-  vs: vs2,
-  fs: fs3,
+  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,
   defines: {
     LIGHTING_FRAGMENT: true,
     HAS_NORMALMAP: false,
@@ -4035,10 +6425,16 @@ var pbrMaterial = {
     HAS_SPECULARCOLORMAP: false,
     HAS_SPECULARINTENSITYMAP: false,
     HAS_TRANSMISSIONMAP: false,
+    HAS_THICKNESSMAP: false,
     HAS_CLEARCOATMAP: false,
+    HAS_CLEARCOATROUGHNESSMAP: false,
+    HAS_CLEARCOATNORMALMAP: false,
     HAS_SHEENCOLORMAP: false,
+    HAS_SHEENROUGHNESSMAP: false,
     HAS_IRIDESCENCEMAP: false,
+    HAS_IRIDESCENCETHICKNESSMAP: false,
     HAS_ANISOTROPYMAP: false,
+    USE_MATERIAL_EXTENSIONS: false,
     ALPHA_CUTOFF: false,
     USE_IBL: false,
     PBR_DEBUG: false
@@ -4064,14 +6460,6 @@ var pbrMaterial = {
     alphaCutoffEnabled: "i32",
     alphaCutoff: "f32",
     // #ifdef ALPHA_CUTOFF
-    // IBL
-    IBLenabled: "i32",
-    scaleIBLAmbient: "vec2<f32>",
-    // #ifdef USE_IBL
-    // debugging flags used for shader output of intermediate PBR variables
-    // #ifdef PBR_DEBUG
-    scaleDiffBaseMR: "vec4<f32>",
-    scaleFGDSpec: "vec4<f32>",
     specularColorFactor: "vec3<f32>",
     specularIntensityFactor: "f32",
     specularColorMapEnabled: "i32",
@@ -4085,9 +6473,11 @@ var pbrMaterial = {
     clearcoatFactor: "f32",
     clearcoatRoughnessFactor: "f32",
     clearcoatMapEnabled: "i32",
+    clearcoatRoughnessMapEnabled: "i32",
     sheenColorFactor: "vec3<f32>",
     sheenRoughnessFactor: "f32",
     sheenColorMapEnabled: "i32",
+    sheenRoughnessMapEnabled: "i32",
     iridescenceFactor: "f32",
     iridescenceIor: "f32",
     iridescenceThicknessRange: "vec2<f32>",
@@ -4096,7 +6486,15 @@ var pbrMaterial = {
     anisotropyRotation: "f32",
     anisotropyDirection: "vec2<f32>",
     anisotropyMapEnabled: "i32",
-    emissiveStrength: "f32"
+    emissiveStrength: "f32",
+    // IBL
+    IBLenabled: "i32",
+    scaleIBLAmbient: "vec2<f32>",
+    // #ifdef USE_IBL
+    // debugging flags used for shader output of intermediate PBR variables
+    // #ifdef PBR_DEBUG
+    scaleDiffBaseMR: "vec4<f32>",
+    scaleFGDSpec: "vec4<f32>"
   }
 };
 //# sourceMappingURL=index.cjs.map