@luma.gl/gltf 9.0.23 → 9.0.24

package/dist/dist.dev.js

@@ -73,9 +73,9 @@ var __exports__ = (() => {
       bindings: {},
       uniforms: {
         // TODO: find better values?
-        u_Camera: [0, 0, 0],
+        camera: [0, 0, 0],
         // Model should override
-        u_MetallicRoughnessValues: [1, 1]
+        metallicRoughnessValues: [1, 1]
         // Default is 1 and 1
       },
       parameters: {},
@@ -85,15 +85,15 @@ var __exports__ = (() => {
     parsedMaterial.defines.USE_TEX_LOD = 1;
     const { imageBasedLightingEnvironment } = options;
     if (imageBasedLightingEnvironment) {
-      parsedMaterial.bindings.u_DiffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler;
-      parsedMaterial.bindings.u_SpecularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler;
-      parsedMaterial.bindings.u_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture;
-      parsedMaterial.uniforms.u_ScaleIBLAmbient = [1, 1];
+      parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler;
+      parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler;
+      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture;
+      parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
     }
     if (options?.pbrDebug) {
       parsedMaterial.defines.PBR_DEBUG = 1;
-      parsedMaterial.uniforms.u_ScaleDiffBaseMR = [0, 0, 0, 0];
-      parsedMaterial.uniforms.u_ScaleFGDSpec = [0, 0, 0, 0];
+      parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
+      parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
     }
     if (attributes.NORMAL)
       parsedMaterial.defines.HAS_NORMALS = 1;
@@ -111,41 +111,47 @@ var __exports__ = (() => {
     return parsedMaterial;
   }
   function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.pbr_uUnlit = Boolean(material.unlit);
+    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
     if (material.pbrMetallicRoughness) {
       parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
     }
     if (material.normalTexture) {
-      addTexture(device, material.normalTexture, "u_NormalSampler", "HAS_NORMALMAP", parsedMaterial);
+      addTexture(
+        device,
+        material.normalTexture,
+        "pbr_normalSampler",
+        "HAS_NORMALMAP",
+        parsedMaterial
+      );
       const { scale: scale4 = 1 } = material.normalTexture;
-      parsedMaterial.uniforms.u_NormalScale = scale4;
+      parsedMaterial.uniforms.normalScale = scale4;
     }
     if (material.occlusionTexture) {
       addTexture(
         device,
         material.occlusionTexture,
-        "u_OcclusionSampler",
+        "pbr_occlusionSampler",
         "HAS_OCCLUSIONMAP",
         parsedMaterial
       );
       const { strength = 1 } = material.occlusionTexture;
-      parsedMaterial.uniforms.u_OcclusionStrength = strength;
+      parsedMaterial.uniforms.occlusionStrength = strength;
     }
     if (material.emissiveTexture) {
       addTexture(
         device,
         material.emissiveTexture,
-        "u_EmissiveSampler",
+        "pbr_emissiveSampler",
         "HAS_EMISSIVEMAP",
         parsedMaterial
       );
-      parsedMaterial.uniforms.u_EmissiveFactor = material.emissiveFactor || [0, 0, 0];
+      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
     }
     switch (material.alphaMode) {
       case "MASK":
         const { alphaCutoff = 0.5 } = material;
         parsedMaterial.defines.ALPHA_CUTOFF = 1;
-        parsedMaterial.uniforms.u_AlphaCutoff = alphaCutoff;
+        parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
         break;
       case "BLEND":
         import_core.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
@@ -171,23 +177,23 @@ var __exports__ = (() => {
       addTexture(
         device,
         pbrMetallicRoughness.baseColorTexture,
-        "u_BaseColorSampler",
+        "pbr_baseColorSampler",
         "HAS_BASECOLORMAP",
         parsedMaterial
       );
     }
-    parsedMaterial.uniforms.u_BaseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
+    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
     if (pbrMetallicRoughness.metallicRoughnessTexture) {
       addTexture(
         device,
         pbrMetallicRoughness.metallicRoughnessTexture,
-        "u_MetallicRoughnessSampler",
+        "pbr_metallicRoughnessSampler",
         "HAS_METALROUGHNESSMAP",
         parsedMaterial
       );
     }
     const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
-    parsedMaterial.uniforms.u_MetallicRoughnessValues = [metallicFactor, roughnessFactor];
+    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
   }
   function addTexture(device, gltfTexture, uniformName, define = null, parsedMaterial) {
     const parameters = gltfTexture?.texture?.sampler?.parameters || {};
@@ -3570,25 +3576,24 @@ var __exports__ = (() => {
   }
 
   // src/gltf/create-gltf-model.ts
-  var import_core4 = __toESM(require_core(), 1);
+  var import_core5 = __toESM(require_core(), 1);
 
   // ../shadertools/src/lib/glsl-utils/highlight.ts
   var glsl = (x) => `${x}`;
 
-  // ../shadertools/src/modules-webgl1/lighting/lights/lights-glsl.ts
-  var lightingShader = glsl`\
-#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+  // ../shadertools/src/modules/lighting/lights/lighting-uniforms-glsl.ts
+  var lightingUniforms = glsl`\
+precision highp int;
 
+// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
 struct AmbientLight {
- vec3 color;
+  vec3 color;
 };
 
 struct PointLight {
- vec3 color;
- vec3 position;
-
- // Constant-Linear-Exponential
- vec3 attenuation;
+  vec3 color;
+  vec3 position;
+  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
 struct DirectionalLight {
@@ -3596,13 +3601,54 @@ struct DirectionalLight {
   vec3 direction;
 };
 
-uniform AmbientLight lighting_uAmbientLight;
-uniform PointLight lighting_uPointLight[MAX_LIGHTS];
-uniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];
-uniform int lighting_uPointLightCount;
-uniform int lighting_uDirectionalLightCount;
+uniform lightingUniforms {
+  int enabled;
+  int lightType;
+
+  int directionalLightCount;
+  int pointLightCount;
+
+  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;
+} 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);
+  }
+}
 
-uniform bool lighting_uEnabled;
+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);
+  }
+} 
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {
   return pointLight.attenuation.x
@@ -3610,16 +3656,87 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
        + pointLight.attenuation.z * distance * distance;
 }
 
-#endif
+// #endif
 `;
 
-  // ../shadertools/src/modules-webgl1/lighting/lights/lights.ts
-  var INITIAL_MODULE_OPTIONS = {
-    lightSources: {}
+  // ../shadertools/src/modules/lighting/lights/lighting-uniforms.ts
+  var import_core4 = __toESM(require_core(), 1);
+  var MAX_LIGHTS = 3;
+  var COLOR_FACTOR = 255;
+  var lighting = {
+    name: "lighting",
+    vs: lightingUniforms,
+    fs: lightingUniforms,
+    getUniforms(props, prevUniforms) {
+      return getUniforms(props);
+    },
+    defines: {
+      MAX_LIGHTS
+    },
+    uniformTypes: {
+      enabled: "i32",
+      lightType: "i32",
+      directionalLightCount: "i32",
+      pointLightCount: "i32",
+      ambientLightColor: "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: 0 /* POINT */,
+      directionalLightCount: 0,
+      pointLightCount: 0,
+      ambientLightColor: [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]
+    }
   };
-  function convertColor(colorDef = {}) {
-    const { color = [0, 0, 0], intensity = 1 } = colorDef;
-    return color.map((component) => component * intensity / 255);
+  function getUniforms(props, prevUniforms = {}) {
+    props = props ? { ...props } : props;
+    if (!props) {
+      return { ...lighting.defaultUniforms };
+    }
+    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;
+    if (!hasLights) {
+      return { ...lighting.defaultUniforms, enabled: 0 };
+    }
+    const uniforms = {
+      ...lighting.defaultUniforms,
+      ...prevUniforms,
+      ...getLightSourceUniforms({ ambientLight, pointLights, directionalLights })
+    };
+    if (props.enabled !== void 0) {
+      uniforms.enabled = props.enabled ? 1 : 0;
+    }
+    return uniforms;
   }
   function getLightSourceUniforms({
     ambientLight,
@@ -3627,79 +3744,55 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     directionalLights = []
   }) {
     const lightSourceUniforms = {};
-    if (ambientLight) {
-      lightSourceUniforms["lighting_uAmbientLight.color"] = convertColor(ambientLight);
-    } else {
-      lightSourceUniforms["lighting_uAmbientLight.color"] = [0, 0, 0];
-    }
-    pointLights.forEach((pointLight, index) => {
-      lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor(pointLight);
-      lightSourceUniforms[`lighting_uPointLight[${index}].position`] = pointLight.position;
-      lightSourceUniforms[`lighting_uPointLight[${index}].attenuation`] = pointLight.attenuation || [
-        1,
-        0,
-        0
-      ];
-    });
-    lightSourceUniforms.lighting_uPointLightCount = pointLights.length;
-    directionalLights.forEach((directionalLight, index) => {
-      lightSourceUniforms[`lighting_uDirectionalLight[${index}].color`] = convertColor(directionalLight);
-      lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] = directionalLight.direction;
-    });
-    lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;
+    lightSourceUniforms.ambientLightColor = convertColor(ambientLight);
+    let currentLight = 0;
+    for (const pointLight of pointLights) {
+      lightSourceUniforms.lightType = 0 /* POINT */;
+      const i = currentLight;
+      lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
+      lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
+      lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
+      currentLight++;
+    }
+    for (const directionalLight of directionalLights) {
+      lightSourceUniforms.lightType = 1 /* DIRECTIONAL */;
+      const i = currentLight;
+      lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
+      lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
+      currentLight++;
+    }
+    if (currentLight > MAX_LIGHTS) {
+      import_core4.log.warn("MAX_LIGHTS exceeded")();
+    }
+    lightSourceUniforms.directionalLightCount = directionalLights.length;
+    lightSourceUniforms.pointLightCount = pointLights.length;
     return lightSourceUniforms;
   }
-  function getUniforms(opts = INITIAL_MODULE_OPTIONS) {
-    if ("lightSources" in opts) {
-      const { ambientLight, pointLights, directionalLights } = opts.lightSources || {};
-      const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
-      if (!hasLights) {
-        return { lighting_uEnabled: false };
-      }
-      return Object.assign(
-        {},
-        getLightSourceUniforms({ ambientLight, pointLights, directionalLights }),
-        {
-          lighting_uEnabled: true
-        }
-      );
-    }
-    if ("lights" in opts) {
-      const lightSources = { pointLights: [], directionalLights: [] };
-      for (const light of opts.lights || []) {
-        switch (light.type) {
-          case "ambient":
-            lightSources.ambientLight = light;
-            break;
-          case "directional":
-            lightSources.directionalLights?.push(light);
-            break;
-          case "point":
-            lightSources.pointLights?.push(light);
-            break;
-          default:
-        }
+  function extractLightTypes(lights) {
+    const lightSources = { pointLights: [], directionalLights: [] };
+    for (const light of lights || []) {
+      switch (light.type) {
+        case "ambient":
+          lightSources.ambientLight = light;
+          break;
+        case "directional":
+          lightSources.directionalLights?.push(light);
+          break;
+        case "point":
+          lightSources.pointLights?.push(light);
+          break;
+        default:
       }
-      return getUniforms({ lightSources });
     }
-    return {};
+    return lightSources;
+  }
+  function convertColor(colorDef = {}) {
+    const { color = [0, 0, 0], intensity = 1 } = colorDef;
+    return color.map((component) => component * intensity / COLOR_FACTOR);
   }
-  var lights = {
-    name: "lights",
-    vs: lightingShader,
-    fs: lightingShader,
-    getUniforms,
-    defines: {
-      MAX_LIGHTS: 3
-    }
-  };
 
-  // ../shadertools/src/modules-webgl1/lighting/pbr/pbr-vertex-glsl.ts
+  // ../shadertools/src/modules/lighting/pbr-material/pbr-vertex-glsl.ts
   var vs = glsl`\
-uniform mat4 u_MVPMatrix;
-uniform mat4 u_ModelMatrix;
-uniform mat4 u_NormalMatrix;
-
 out vec3 pbr_vPosition;
 out vec2 pbr_vUV;
 
@@ -3713,17 +3806,17 @@ out vec3 pbr_vNormal;
 
 void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
 {
-  vec4 pos = u_ModelMatrix * position;
+  vec4 pos = pbrProjection.modelMatrix * position;
   pbr_vPosition = vec3(pos.xyz) / pos.w;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));
-  vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));
+  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
   vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
   pbr_vTBN = mat3(tangentW, bitangentW, normalW);
 #else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));
+  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 
@@ -3735,55 +3828,69 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 }
 `;
 
-  // ../shadertools/src/modules-webgl1/lighting/pbr/pbr-fragment-glsl.ts
+  // ../shadertools/src/modules/lighting/pbr-material/pbr-fragment-glsl.ts
   var fs = glsl`\
 precision highp float;
 
-uniform bool pbr_uUnlit;
-
-#ifdef USE_IBL
-uniform samplerCube u_DiffuseEnvSampler;
-uniform samplerCube u_SpecularEnvSampler;
-uniform sampler2D u_brdfLUT;
-uniform vec2 u_ScaleIBLAmbient;
-#endif
-
+uniform pbrMaterialUniforms {
+  // Material is unlit
+  bool unlit;
+
+  // Base color map
+  bool baseColorMapEnabled;
+  vec4 baseColorFactor;
+
+  bool normalMapEnabled;  
+  float normalScale; // #ifdef HAS_NORMALMAP
+
+  bool emissiveMapEnabled;
+  vec3 emissiveFactor; // #ifdef HAS_EMISSIVEMAP
+
+  vec2 metallicRoughnessValues;
+  bool metallicRoughnessMapEnabled;
+
+  bool occlusionMapEnabled;
+  float occlusionStrength; // #ifdef HAS_OCCLUSIONMAP
+  
+  bool alphaCutoffEnabled;
+  float alphaCutoff; // #ifdef ALPHA_CUTOFF
+  
+  // IBL
+  bool IBLenabled;
+  vec2 scaleIBLAmbient; // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  vec4 scaleDiffBaseMR;
+  vec4 scaleFGDSpec;
+  // #endif
+} pbrMaterial;
+
+// Samplers
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D u_BaseColorSampler;
+uniform sampler2D pbr_baseColorSampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D u_NormalSampler;
-uniform float u_NormalScale;
+uniform sampler2D pbr_normalSampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D u_EmissiveSampler;
-uniform vec3 u_EmissiveFactor;
+uniform sampler2D pbr_emissiveSampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D u_MetallicRoughnessSampler;
+uniform sampler2D pbr_metallicRoughnessSampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-uniform sampler2D u_OcclusionSampler;
-uniform float u_OcclusionStrength;
+uniform sampler2D pbr_occlusionSampler;
 #endif
-
-#ifdef ALPHA_CUTOFF
-uniform float u_AlphaCutoff;
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
 #endif
 
-uniform vec2 u_MetallicRoughnessValues;
-uniform vec4 u_BaseColorFactor;
-
-uniform vec3 u_Camera;
-
-// debugging flags used for shader output of intermediate PBR variables
-#ifdef PBR_DEBUG
-uniform vec4 u_ScaleDiffBaseMR;
-uniform vec4 u_ScaleFGDSpec;
-#endif
+// Inputs from vertex shader
 
 in vec3 pbr_vPosition;
-
 in vec2 pbr_vUV;
 
 #ifdef HAS_NORMALS
@@ -3797,8 +3904,7 @@ in vec3 pbr_vNormal;
 // 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.
-struct PBRInfo
-{
+struct PBRInfo {
   float NdotL;                  // cos angle between normal and light direction
   float NdotV;                  // cos angle between normal and view direction
   float NdotH;                  // cos angle between normal and half vector
@@ -3823,7 +3929,7 @@ vec4 SRGBtoLINEAR(vec4 srgbIn)
 #ifdef MANUAL_SRGB
 #ifdef SRGB_FAST_APPROXIMATION
   vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
-#else //SRGB_FAST_APPROXIMATION
+#else // SRGB_FAST_APPROXIMATION
   vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
   vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
 #endif //SRGB_FAST_APPROXIMATION
@@ -3859,8 +3965,8 @@ vec3 getNormal()
 #endif
 
 #ifdef HAS_NORMALMAP
-  vec3 n = texture(u_NormalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_NormalScale, u_NormalScale, 1.0)));
+  vec3 n = texture(pbr_normalSampler, 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);
@@ -3873,27 +3979,27 @@ vec3 getNormal()
 // 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
-vec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)
+vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
 {
   float mipCount = 9.0; // resolution of 512x512
-  float lod = (pbrInputs.perceptualRoughness * mipCount);
+  float lod = (pbrInfo.perceptualRoughness * mipCount);
   // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture(u_brdfLUT,
-    vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;
-  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
+    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
 
 #ifdef USE_TEX_LOD
-  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
 #else
-  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
 #endif
 
-  vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;
-  vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);
+  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
+  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
 
   // For presentation, this allows us to disable IBL terms
-  diffuse *= u_ScaleIBLAmbient.x;
-  specular *= u_ScaleIBLAmbient.y;
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
 
   return diffuse + specular;
 }
@@ -3902,29 +4008,29 @@ vec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)
 // Basic Lambertian diffuse
 // Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
 // See also [1], Equation 1
-vec3 diffuse(PBRInfo pbrInputs)
+vec3 diffuse(PBRInfo pbrInfo)
 {
-  return pbrInputs.diffuseColor / M_PI;
+  return pbrInfo.diffuseColor / M_PI;
 }
 
 // The following equation models the Fresnel reflectance term of the spec equation (aka F())
 // Implementation of fresnel from [4], Equation 15
-vec3 specularReflection(PBRInfo pbrInputs)
+vec3 specularReflection(PBRInfo pbrInfo)
 {
-  return pbrInputs.reflectance0 +
-    (pbrInputs.reflectance90 - pbrInputs.reflectance0) *
-    pow(clamp(1.0 - pbrInputs.VdotH, 0.0, 1.0), 5.0);
+  return pbrInfo.reflectance0 +
+    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
+    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
 }
 
 // This calculates the specular geometric attenuation (aka G()),
 // where rougher material will reflect less light back to the viewer.
 // This implementation is based on [1] Equation 4, and we adopt their modifications to
 // alphaRoughness as input as originally proposed in [2].
-float geometricOcclusion(PBRInfo pbrInputs)
+float geometricOcclusion(PBRInfo pbrInfo)
 {
-  float NdotL = pbrInputs.NdotL;
-  float NdotV = pbrInputs.NdotV;
-  float r = pbrInputs.alphaRoughness;
+  float NdotL = pbrInfo.NdotL;
+  float NdotV = pbrInfo.NdotV;
+  float r = pbrInfo.alphaRoughness;
 
   float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
   float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
@@ -3937,80 +4043,80 @@ float geometricOcclusion(PBRInfo pbrInputs)
 // for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
 // Follows the distribution function recommended in the SIGGRAPH 2013 course notes
 // from EPIC Games [1], Equation 3.
-float microfacetDistribution(PBRInfo pbrInputs)
+float microfacetDistribution(PBRInfo pbrInfo)
 {
-  float roughnessSq = pbrInputs.alphaRoughness * pbrInputs.alphaRoughness;
-  float f = (pbrInputs.NdotH * roughnessSq - pbrInputs.NdotH) * pbrInputs.NdotH + 1.0;
+  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
   return roughnessSq / (M_PI * f * f);
 }
 
-void PBRInfo_setAmbientLight(inout PBRInfo pbrInputs) {
-  pbrInputs.NdotL = 1.0;
-  pbrInputs.NdotH = 0.0;
-  pbrInputs.LdotH = 0.0;
-  pbrInputs.VdotH = 1.0;
+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 pbrInputs, vec3 lightDirection) {
-  vec3 n = pbrInputs.n;
-  vec3 v = pbrInputs.v;
+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
 
-  pbrInputs.NdotL = clamp(dot(n, l), 0.001, 1.0);
-  pbrInputs.NdotH = clamp(dot(n, h), 0.0, 1.0);
-  pbrInputs.LdotH = clamp(dot(l, h), 0.0, 1.0);
-  pbrInputs.VdotH = clamp(dot(v, h), 0.0, 1.0);
+  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 pbrInputs, PointLight pointLight) {
+void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
   vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
-  PBRInfo_setDirectionalLight(pbrInputs, light_direction);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
-vec3 calculateFinalColor(PBRInfo pbrInputs, vec3 lightColor) {
+vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
   // Calculate the shading terms for the microfacet specular shading model
-  vec3 F = specularReflection(pbrInputs);
-  float G = geometricOcclusion(pbrInputs);
-  float D = microfacetDistribution(pbrInputs);
+  vec3 F = specularReflection(pbrInfo);
+  float G = geometricOcclusion(pbrInfo);
+  float D = microfacetDistribution(pbrInfo);
 
   // Calculation of analytical lighting contribution
-  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);
-  vec3 specContrib = F * G * D / (4.0 * pbrInputs.NdotL * pbrInputs.NdotV);
+  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
+  vec3 specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
   // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
-  return pbrInputs.NdotL * lightColor * (diffuseContrib + specContrib);
+  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
 }
 
 vec4 pbr_filterColor(vec4 colorUnused)
 {
   // The albedo may be defined from a base texture or a flat color
 #ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture(u_BaseColorSampler, pbr_vUV)) * u_BaseColorFactor;
+  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
 #else
-  vec4 baseColor = u_BaseColorFactor;
+  vec4 baseColor = pbrMaterial.baseColorFactor;
 #endif
 
 #ifdef ALPHA_CUTOFF
-  if (baseColor.a < u_AlphaCutoff) {
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
     discard;
   }
 #endif
 
   vec3 color = vec3(0, 0, 0);
 
-  if(pbr_uUnlit){
+  if(pbrMaterial.unlit){
     color.rgb = baseColor.rgb;
   }
   else{
     // Metallic and Roughness material properties are packed together
     // In glTF, these factors can be specified by fixed scalar values
     // or from a metallic-roughness map
-    float perceptualRoughness = u_MetallicRoughnessValues.y;
-    float metallic = u_MetallicRoughnessValues.x;
+    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    float metallic = pbrMaterial.metallicRoughnessValues.x;
 #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    vec4 mrSample = texture(u_MetallicRoughnessSampler, pbr_vUV);
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
 #endif
@@ -4037,12 +4143,12 @@ vec4 pbr_filterColor(vec4 colorUnused)
     vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
 
     vec3 n = getNormal();                          // normal at surface point
-    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera
+    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 pbrInputs = PBRInfo(
+    PBRInfo pbrInfo = PBRInfo(
       0.0, // NdotL
       NdotV,
       0.0, // NdotH
@@ -4059,43 +4165,50 @@ vec4 pbr_filterColor(vec4 colorUnused)
       v
     );
 
+
 #ifdef USE_LIGHTS
     // Apply ambient light
-    PBRInfo_setAmbientLight(pbrInputs);
-    color += calculateFinalColor(pbrInputs, lighting_uAmbientLight.color);
+    PBRInfo_setAmbientLight(pbrInfo);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
 
     // Apply directional light
-    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {
-      if (i < lighting_uDirectionalLightCount) {
-        PBRInfo_setDirectionalLight(pbrInputs, lighting_uDirectionalLight[i].direction);
-        color += calculateFinalColor(pbrInputs, lighting_uDirectionalLight[i].color);
+    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);
       }
     }
 
     // Apply point light
-    for(int i = 0; i < lighting_uPointLightCount; i++) {
-      if (i < lighting_uPointLightCount) {
-        PBRInfo_setPointLight(pbrInputs, lighting_uPointLight[i]);
-        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
-        color += calculateFinalColor(pbrInputs, lighting_uPointLight[i].color / attenuation);
+    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);
       }
     }
 #endif
 
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
-    color += getIBLContribution(pbrInputs, n, reflection);
+    if (pbrMaterial.IBLenabled) {
+      color += getIBLContribution(pbrInfo, n, reflection);
+    }
 #endif
 
-    // Apply optional PBR terms for additional (optional) shading
+ // Apply optional PBR terms for additional (optional) shading
 #ifdef HAS_OCCLUSIONMAP
-    float ao = texture(u_OcclusionSampler, pbr_vUV).r;
-    color = mix(color, color * ao, u_OcclusionStrength);
+    if (pbrMaterial.occlusionMapEnabled) {
+      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+    }
 #endif
 
 #ifdef HAS_EMISSIVEMAP
-    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;
-    color += emissive;
+    if (pbrMaterial.emissiveMapEnabled) {
+      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+      color += emissive;
+    }
 #endif
 
     // This section uses mix to override final color for reference app visualization
@@ -4103,15 +4216,15 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef PBR_DEBUG
     // TODO: Figure out how to debug multiple lights
 
-    // color = mix(color, F, u_ScaleFGDSpec.x);
-    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);
-    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);
-    // color = mix(color, specContrib, u_ScaleFGDSpec.w);
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
 
-    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);
-    color = mix(color, baseColor.rgb, u_ScaleDiffBaseMR.y);
-    color = mix(color, vec3(metallic), u_ScaleDiffBaseMR.z);
-    color = mix(color, vec3(perceptualRoughness), u_ScaleDiffBaseMR.w);
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    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
 
   }
@@ -4120,15 +4233,77 @@ vec4 pbr_filterColor(vec4 colorUnused)
 }
 `;
 
-  // ../shadertools/src/modules-webgl1/lighting/pbr/pbr.ts
-  var pbr = {
-    name: "pbr",
+  // ../shadertools/src/modules/lighting/pbr-material/pbr-projection.ts
+  var uniformBlock = glsl`\
+uniform pbrProjectionUniforms {
+  mat4 modelViewProjectionMatrix;
+  mat4 modelMatrix;
+  mat4 normalMatrix;
+  vec3 camera;
+} pbrProjection;
+`;
+  var pbrProjection = {
+    name: "pbrProjection",
+    vs: uniformBlock,
+    fs: uniformBlock,
+    // TODO why is this needed?
+    getUniforms: (props) => props,
+    uniformTypes: {
+      modelViewProjectionMatrix: "mat4x4<f32>",
+      modelMatrix: "mat4x4<f32>",
+      normalMatrix: "mat4x4<f32>",
+      camera: "vec3<i32>"
+    }
+  };
+
+  // ../shadertools/src/modules/lighting/pbr-material/pbr-material.ts
+  var pbrMaterial = {
+    name: "pbrMaterial",
     vs,
     fs,
     defines: {
       LIGHTING_FRAGMENT: 1
+      // TODO defining these as 0 breaks shader
+      // HAS_NORMALMAP: 0
+      // HAS_EMISSIVEMAP: 0,
+      // HAS_OCCLUSIONMAP: 0,
+      // HAS_BASECOLORMAP: 0,
+      // HAS_METALROUGHNESSMAP: 0,
+      // ALPHA_CUTOFF: 0
+      // USE_IBL: 0
+      // PBR_DEBUG: 0
     },
-    dependencies: [lights]
+    getUniforms: (props) => props,
+    uniformTypes: {
+      // Material is unlit
+      unlit: "i32",
+      // Base color map
+      baseColorMapEnabled: "i32",
+      baseColorFactor: "vec4<f32>",
+      normalMapEnabled: "i32",
+      normalScale: "f32",
+      // #ifdef HAS_NORMALMAP
+      emissiveMapEnabled: "i32",
+      emissiveFactor: "vec3<f32>",
+      // #ifdef HAS_EMISSIVEMAP
+      metallicRoughnessValues: "vec2<f32>",
+      metallicRoughnessMapEnabled: "i32",
+      occlusionMapEnabled: "i32",
+      occlusionStrength: "f32",
+      // #ifdef HAS_OCCLUSIONMAP
+      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>"
+    },
+    dependencies: [lighting, pbrProjection]
   };
 
   // src/gltf/create-gltf-model.ts
@@ -4176,7 +4351,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     #endif
 
     pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
-    gl_Position = u_MVPMatrix * positions;
+    gl_Position = pbrProjection.modelViewProjectionMatrix * positions;
   }
 `;
   var fs2 = `
@@ -4195,7 +4370,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
   function createGLTFModel(device, options) {
     const { id, geometry, material, vertexCount, materialOptions, modelOptions } = options;
     const parsedMaterial = parsePBRMaterial(device, material, geometry.attributes, materialOptions);
-    import_core4.log.info(4, "createGLTFModel defines: ", parsedMaterial.defines)();
+    import_core5.log.info(4, "createGLTFModel defines: ", parsedMaterial.defines)();
     const managedResources = [];
     const parameters = {
       depthWriteEnabled: true,
@@ -4208,16 +4383,22 @@ vec4 pbr_filterColor(vec4 colorUnused)
       geometry,
       topology: geometry.topology,
       vertexCount,
-      modules: [pbr],
+      modules: [pbrMaterial],
       vs: addVersionToShader(device, vs2),
       fs: addVersionToShader(device, fs2),
+      // TODO can this be removed? Does deck need it?
       ...modelOptions,
-      bindings: { ...parsedMaterial.bindings, ...modelOptions.bindings },
       defines: { ...parsedMaterial.defines, ...modelOptions.defines },
-      parameters: { ...parameters, ...parsedMaterial.parameters, ...modelOptions.parameters },
-      uniforms: { ...parsedMaterial.uniforms, ...modelOptions.uniforms }
+      parameters: { ...parameters, ...parsedMaterial.parameters, ...modelOptions.parameters }
     };
     const model = new import_engine.Model(device, modelProps);
+    const { camera, ...pbrMaterialProps } = {
+      ...parsedMaterial.uniforms,
+      ...modelOptions.uniforms,
+      ...parsedMaterial.bindings,
+      ...modelOptions.bindings
+    };
+    model.shaderInputs.setProps({ pbrMaterial: pbrMaterialProps, pbrProjection: { camera } });
     return new import_engine.ModelNode({ managedResources, model });
   }
   function addVersionToShader(device, source) {