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

package/dist/index.cjs

@@ -57,6 +57,7 @@ __export(dist_exports, {
   picking: () => picking,
   preprocess: () => preprocess,
   random: () => random,
+  skin: () => skin,
   toHalfFloat: () => toHalfFloat,
   typeToChannelCount: () => typeToChannelCount,
   typeToChannelSuffix: () => typeToChannelSuffix
@@ -204,7 +205,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 +219,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 = {};
@@ -434,19 +435,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 +471,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 +537,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 +549,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)) {
@@ -586,19 +587,19 @@ function assembleWGSLShader(options) {
   };
 }
 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 +610,7 @@ function assembleShaderWGSL(platformInfo, options) {
   var _a;
   const {
     // id,
-    source: source3,
+    source: source4,
     stage,
     modules,
     // defines = {},
@@ -617,8 +618,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 = {};
@@ -673,12 +674,12 @@ function assembleShaderWGSL(platformInfo, options) {
 }
 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) => {
@@ -801,39 +802,61 @@ function getShaderModuleSource(module2, stage) {
     throw new Error("Shader module must have a name");
   }
   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 source3;
+  return source4;
 }
 
 // dist/lib/preprocessor/preprocessor.js
 var IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
+var IFNDEF_REGEXP = /^\s*\#\s*ifndef\s*([a-zA-Z_]+)\s*(?:\/\/.*)?$/;
+var 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 = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\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");
 }
 
@@ -886,14 +909,21 @@ 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 } = assembleWGSLShader({
       ...props,
       // @ts-expect-error
       source: props.source,
       modules,
       hookFunctions
     });
-    const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source3) : source3;
+    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 };
   }
   /**
@@ -1248,9 +1278,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);
 }
 `
 );
@@ -2490,8 +2519,102 @@ 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}>,
+};
+
+@binding(19) @group(0) 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",
+  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>"
+  },
+  uniformSizes: {
+    jointMatrix: 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 = (
@@ -2537,6 +2660,16 @@ uniform lightingUniforms {
   vec3 lightPosition2;
   vec3 lightDirection2;
   vec3 lightAttenuation2;
+
+  vec3 lightColor3;
+  vec3 lightPosition3;
+  vec3 lightDirection3;
+  vec3 lightAttenuation3;
+
+  vec3 lightColor4;
+  vec3 lightPosition4;
+  vec3 lightDirection4;
+  vec3 lightAttenuation4;
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
@@ -2546,8 +2679,12 @@ PointLight lighting_getPointLight(int index) {
     case 1:
       return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
     case 2:
-    default:  
       return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+    case 3:
+      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
+    case 4:
+    default:  
+      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
   }
 }
 
@@ -2558,8 +2695,12 @@ DirectionalLight lighting_getDirectionalLight(int index) {
     case 1:
       return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
     case 2:
-    default:   
       return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+    case 3:
+      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
+    case 4:
+    default:   
+      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
   }
 } 
 
@@ -2577,6 +2718,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>,
 };
@@ -2594,32 +2737,80 @@ struct DirectionalLight {
 
 struct lightingUniforms {
   enabled: i32,
-  pointLightCount: i32,
+  lightType: i32,
+
   directionalLightCount: i32,
+  pointLightCount: 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];
+  lightColor0: vec3<f32>,
+  lightPosition0: vec3<f32>,
+  lightDirection0: vec3<f32>,
+  lightAttenuation0: vec3<f32>,
+
+  lightColor1: vec3<f32>,
+  lightPosition1: vec3<f32>,
+  lightDirection1: vec3<f32>,
+  lightAttenuation1: vec3<f32>,
+
+  lightColor2: vec3<f32>,
+  lightPosition2: vec3<f32>,
+  lightDirection2: vec3<f32>,
+  lightAttenuation2: vec3<f32>,
+
+  lightColor3: vec3<f32>,
+  lightPosition3: vec3<f32>,
+  lightDirection3: vec3<f32>,
+  lightAttenuation3: vec3<f32>,
+
+  lightColor4: vec3<f32>,
+  lightPosition4: vec3<f32>,
+  lightDirection4: vec3<f32>,
+  lightAttenuation4: vec3<f32>,
 };
 
 // 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;
 
 fn lighting_getPointLight(index: i32) -> PointLight {
-  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+  switch (index) {
+    case 0: {
+      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
+    }
+    case 1: {
+      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
+    }
+    case 2: {
+      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+    }
+    case 3: {
+      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
+    }
+    case 4, default: {
+      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
+    }
+  }
 }
 
 fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
-  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+  switch (index) {
+    case 0: {
+      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
+    }
+    case 1: {
+      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
+    }
+    case 2: {
+      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+    }
+    case 3: {
+      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
+    }
+    case 4, default: {
+      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
+    }
+  }
 } 
 
 fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
@@ -2664,7 +2855,15 @@ var lighting = {
     lightColor2: "vec3<f32>",
     lightPosition2: "vec3<f32>",
     lightDirection2: "vec3<f32>",
-    lightAttenuation2: "vec3<f32>"
+    lightAttenuation2: "vec3<f32>",
+    lightColor3: "vec3<f32>",
+    lightPosition3: "vec3<f32>",
+    lightDirection3: "vec3<f32>",
+    lightAttenuation3: "vec3<f32>",
+    lightColor4: "vec3<f32>",
+    lightPosition4: "vec3<f32>",
+    lightDirection4: "vec3<f32>",
+    lightAttenuation4: "vec3<f32>"
   },
   defaultUniforms: {
     enabled: 1,
@@ -2684,7 +2883,15 @@ var lighting = {
     lightColor2: [1, 1, 1],
     lightPosition2: [1, 1, 2],
     lightDirection2: [1, 1, 1],
-    lightAttenuation2: [1, 0, 0]
+    lightAttenuation2: [1, 0, 0],
+    lightColor3: [1, 1, 1],
+    lightPosition3: [1, 1, 2],
+    lightDirection3: [1, 1, 1],
+    lightAttenuation3: [1, 0, 0],
+    lightColor4: [1, 1, 1],
+    lightPosition4: [1, 1, 2],
+    lightDirection4: [1, 1, 1],
+    lightAttenuation4: [1, 0, 0]
   },
   source: lightingUniformsWGSL,
   vs: lightingUniformsGLSL,
@@ -2718,26 +2925,36 @@ function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLig
   const lightSourceUniforms = {};
   lightSourceUniforms.ambientColor = convertColor(ambientLight);
   let currentLight = 0;
+  let pointLightCount = 0;
+  let directionalLightCount = 0;
   for (const pointLight of pointLights) {
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
     lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
     const i = currentLight;
     lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
     lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
     lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
     currentLight++;
+    pointLightCount++;
   }
   for (const directionalLight of directionalLights) {
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
     lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;
     const i = currentLight;
     lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
     lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
     currentLight++;
+    directionalLightCount++;
   }
-  if (currentLight > MAX_LIGHTS) {
-    import_core2.log.warn("MAX_LIGHTS exceeded")();
+  if (pointLights.length + directionalLights.length > MAX_LIGHTS) {
+    import_core3.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
   }
-  lightSourceUniforms.directionalLightCount = directionalLights.length;
-  lightSourceUniforms.pointLightCount = pointLights.length;
+  lightSourceUniforms.directionalLightCount = directionalLightCount;
+  lightSourceUniforms.pointLightCount = pointLightCount;
   return lightSourceUniforms;
 }
 function extractLightTypes(lights) {
@@ -2946,56 +3163,60 @@ 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);
-  }
-  
-  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);
+    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 (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.directionalLightCount) {
-      break;
-    }
-    DirectionalLight directionalLight = lighting.directionalLight[i];
+  let totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
+  for (var i: i32 = lighting.pointLightCount; i < totalLights; 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
+      );
+    }
+
+    let totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
+    for (var i: i32 = lighting.pointLightCount; i < totalLights; i++) {
+        let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
         lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-      }
     }
   }
   return lightColor;
@@ -3069,7 +3290,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 +3327,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 }
 `
 );
-var fs3 = (
+var fs4 = (
   /* glsl */
   `precision highp float;
 
@@ -3570,56 +3791,60 @@ vec4 pbr_filterColor(vec4 colorUnused)
 );
 
 // 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
@@ -3634,7 +3859,7 @@ struct pbrMaterialUniforms {
   // debugging flags used for shader output of intermediate PBR variables
   // #ifdef PBR_DEBUG
   scaleDiffBaseMR: vec4f,
-  scaleFGDSpec: vec4f
+  scaleFGDSpec: vec4f,
   // #endif
 }
 
@@ -3642,24 +3867,32 @@ struct pbrMaterialUniforms {
 
 // Samplers
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D pbr_baseColorSampler;
+@binding(3) @group(0) var pbr_baseColorSampler: texture_2d<f32>;
+@binding(4) @group(0) var pbr_baseColorSamplerSampler: sampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D pbr_normalSampler;
+@binding(5) @group(0) var pbr_normalSampler: texture_2d<f32>;
+@binding(6) @group(0) var pbr_normalSamplerSampler: sampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D pbr_emissiveSampler;
+@binding(7) @group(0) var pbr_emissiveSampler: texture_2d<f32>;
+@binding(8) @group(0) var pbr_emissiveSamplerSampler: sampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D pbr_metallicRoughnessSampler;
+@binding(9) @group(0) var pbr_metallicRoughnessSampler: texture_2d<f32>;
+@binding(10) @group(0) var pbr_metallicRoughnessSamplerSampler: sampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-uniform sampler2D pbr_occlusionSampler;
+@binding(11) @group(0) var pbr_occlusionSampler: texture_2d<f32>;
+@binding(12) @group(0) var pbr_occlusionSamplerSampler: sampler;
 #endif
 #ifdef USE_IBL
-uniform samplerCube pbr_diffuseEnvSampler;
-uniform samplerCube pbr_specularEnvSampler;
-uniform sampler2D pbr_brdfLUT;
+@binding(13) @group(0) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@binding(14) @group(0) var pbr_diffuseEnvSamplerSampler: sampler;
+@binding(15) @group(0) var pbr_specularEnvSampler: texture_cube<f32>;
+@binding(16) @group(0) var pbr_specularEnvSamplerSampler: sampler;
+@binding(17) @group(0) var pbr_BrdfLUT: texture_2d<f32>;
+@binding(18) @group(0) var pbr_BrdfLUTSampler: sampler;
 #endif
 
 // Encapsulate the various inputs used by the various functions in the shading equation
@@ -3687,17 +3920,19 @@ 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
@@ -3705,32 +3940,28 @@ fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
 fn getNormal() -> vec3f
 {
   // 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
   // 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 = textureSample(pbr_normalSampler, pbr_normalSamplerSampler, fragmentInputs.pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3f(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
 #endif
 
   return n;
@@ -3740,27 +3971,37 @@ fn getNormal() -> vec3f
 // 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(
+    textureSample(
+      pbr_BrdfLUT,
+      pbr_BrdfLUTSampler,
+      vec2f(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness)
+    )
+  ).rgb;
+  let diffuseLight =
+    SRGBtoLINEAR(textureSample(pbr_diffuseEnvSampler, pbr_diffuseEnvSamplerSampler, n)).rgb;
+  let specularLightDefault =
+    SRGBtoLINEAR(textureSample(pbr_specularEnvSampler, pbr_specularEnvSamplerSampler, reflection)).rgb;
+  var specularLight = specularLightDefault;
 #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 +4045,7 @@ 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 PBRInfo_setAmbientLight(pbrInfo: ptr<function, PBRInfo>) {
@@ -3846,11 +4087,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
@@ -3861,7 +4102,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
 
   var color = vec3<f32>(0.0, 0.0, 0.0);
 
-  if (pbrMaterial.unlit) {
+  if (pbrMaterial.unlit != 0u) {
     color = baseColor.rgb;
   } else {
     // Metallic and Roughness material properties are packed together
@@ -3872,7 +4113,11 @@ 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
@@ -3949,22 +4194,25 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
 
     // Calculate lighting contribution from image based lighting source (IBL)
     #ifdef USE_IBL
-    if (pbrMaterial.IBLenabled) {
+    if (pbrMaterial.IBLenabled != 0) {
       color += getIBLContribution(pbrInfo, n, reflection);
     }
     #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
 
     #ifdef HAS_EMISSIVEMAP
-    if (pbrMaterial.emissiveMapEnabled) {
-      let emissive = SRGBtoLINEAR(textureSample(pbr_emissiveSampler, pbr_emissiveSampler, fragmentInputs.pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+    if (pbrMaterial.emissiveMapEnabled != 0u) {
+      let emissive = SRGBtoLINEAR(
+        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
+      ).rgb * pbrMaterial.emissiveFactor;
       color += emissive;
     }
     #endif
@@ -4002,8 +4250,21 @@ var uniformBlock = (
 } pbrProjection;
 `
 );
+var wgslUniformBlock = (
+  /* wgsl */
+  `struct pbrProjectionUniforms {
+  modelViewProjectionMatrix: mat4x4<f32>,
+  modelMatrix: mat4x4<f32>,
+  normalMatrix: mat4x4<f32>,
+  camera: vec3<f32>
+};
+
+@binding(0) @group(0) var<uniform> pbrProjection: pbrProjectionUniforms;
+`
+);
 var pbrProjection = {
   name: "pbrProjection",
+  source: wgslUniformBlock,
   vs: uniformBlock,
   fs: uniformBlock,
   // TODO why is this needed?
@@ -4012,7 +4273,7 @@ var pbrProjection = {
     modelViewProjectionMatrix: "mat4x4<f32>",
     modelMatrix: "mat4x4<f32>",
     normalMatrix: "mat4x4<f32>",
-    camera: "vec3<i32>"
+    camera: "vec3<f32>"
   }
 };
 
@@ -4022,9 +4283,9 @@ var pbrMaterial = {
   uniforms: {},
   name: "pbrMaterial",
   dependencies: [lighting, pbrProjection],
-  source: source2,
-  vs: vs2,
-  fs: fs3,
+  source: source3,
+  vs: vs3,
+  fs: fs4,
   defines: {
     LIGHTING_FRAGMENT: true,
     HAS_NORMALMAP: false,