@luma.gl/gltf 9.0.25 → 9.0.27

package/dist/dist.dev.js

@@ -73,9 +73,9 @@ var __exports__ = (() => {
       bindings: {},
       uniforms: {
         // TODO: find better values?
-        camera: [0, 0, 0],
+        u_Camera: [0, 0, 0],
         // Model should override
-        metallicRoughnessValues: [1, 1]
+        u_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.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler;
-      parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler;
-      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture;
-      parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
+      parsedMaterial.bindings.u_DiffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler;
+      parsedMaterial.bindings.u_SpecularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler;
+      parsedMaterial.bindings.u_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture;
+      parsedMaterial.uniforms.u_ScaleIBLAmbient = [1, 1];
     }
     if (options?.pbrDebug) {
       parsedMaterial.defines.PBR_DEBUG = 1;
-      parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
-      parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
+      parsedMaterial.uniforms.u_ScaleDiffBaseMR = [0, 0, 0, 0];
+      parsedMaterial.uniforms.u_ScaleFGDSpec = [0, 0, 0, 0];
     }
     if (attributes.NORMAL)
       parsedMaterial.defines.HAS_NORMALS = 1;
@@ -111,47 +111,41 @@ var __exports__ = (() => {
     return parsedMaterial;
   }
   function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+    parsedMaterial.uniforms.pbr_uUnlit = Boolean(material.unlit);
     if (material.pbrMetallicRoughness) {
       parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
     }
     if (material.normalTexture) {
-      addTexture(
-        device,
-        material.normalTexture,
-        "pbr_normalSampler",
-        "HAS_NORMALMAP",
-        parsedMaterial
-      );
+      addTexture(device, material.normalTexture, "u_NormalSampler", "HAS_NORMALMAP", parsedMaterial);
       const { scale: scale4 = 1 } = material.normalTexture;
-      parsedMaterial.uniforms.normalScale = scale4;
+      parsedMaterial.uniforms.u_NormalScale = scale4;
     }
     if (material.occlusionTexture) {
       addTexture(
         device,
         material.occlusionTexture,
-        "pbr_occlusionSampler",
+        "u_OcclusionSampler",
         "HAS_OCCLUSIONMAP",
         parsedMaterial
       );
       const { strength = 1 } = material.occlusionTexture;
-      parsedMaterial.uniforms.occlusionStrength = strength;
+      parsedMaterial.uniforms.u_OcclusionStrength = strength;
     }
     if (material.emissiveTexture) {
       addTexture(
         device,
         material.emissiveTexture,
-        "pbr_emissiveSampler",
+        "u_EmissiveSampler",
         "HAS_EMISSIVEMAP",
         parsedMaterial
       );
-      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+      parsedMaterial.uniforms.u_EmissiveFactor = material.emissiveFactor || [0, 0, 0];
     }
     switch (material.alphaMode) {
       case "MASK":
         const { alphaCutoff = 0.5 } = material;
         parsedMaterial.defines.ALPHA_CUTOFF = 1;
-        parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
+        parsedMaterial.uniforms.u_AlphaCutoff = alphaCutoff;
         break;
       case "BLEND":
         import_core.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
@@ -177,23 +171,23 @@ var __exports__ = (() => {
       addTexture(
         device,
         pbrMetallicRoughness.baseColorTexture,
-        "pbr_baseColorSampler",
+        "u_BaseColorSampler",
         "HAS_BASECOLORMAP",
         parsedMaterial
       );
     }
-    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
+    parsedMaterial.uniforms.u_BaseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
     if (pbrMetallicRoughness.metallicRoughnessTexture) {
       addTexture(
         device,
         pbrMetallicRoughness.metallicRoughnessTexture,
-        "pbr_metallicRoughnessSampler",
+        "u_MetallicRoughnessSampler",
         "HAS_METALROUGHNESSMAP",
         parsedMaterial
       );
     }
     const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
-    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
+    parsedMaterial.uniforms.u_MetallicRoughnessValues = [metallicFactor, roughnessFactor];
   }
   function addTexture(device, gltfTexture, uniformName, define = null, parsedMaterial) {
     const parameters = gltfTexture?.texture?.sampler?.parameters || {};
@@ -3576,24 +3570,25 @@ var __exports__ = (() => {
   }
 
   // src/gltf/create-gltf-model.ts
-  var import_core5 = __toESM(require_core(), 1);
+  var import_core4 = __toESM(require_core(), 1);
 
   // ../shadertools/src/lib/glsl-utils/highlight.ts
   var glsl = (x) => `${x}`;
 
-  // ../shadertools/src/modules/lighting/lights/lighting-uniforms-glsl.ts
-  var lightingUniforms = glsl`\
-precision highp int;
+  // ../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))
 
-// #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;
-  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
+ vec3 color;
+ vec3 position;
+
+ // Constant-Linear-Exponential
+ vec3 attenuation;
 };
 
 struct DirectionalLight {
@@ -3601,54 +3596,13 @@ struct DirectionalLight {
   vec3 direction;
 };
 
-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 AmbientLight lighting_uAmbientLight;
+uniform PointLight lighting_uPointLight[MAX_LIGHTS];
+uniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];
+uniform int lighting_uPointLightCount;
+uniform int lighting_uDirectionalLightCount;
 
-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);
-  }
-} 
+uniform bool lighting_uEnabled;
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {
   return pointLight.attenuation.x
@@ -3656,87 +3610,16 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
        + pointLight.attenuation.z * distance * distance;
 }
 
-// #endif
+#endif
 `;
 
-  // ../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]
-    }
+  // ../shadertools/src/modules-webgl1/lighting/lights/lights.ts
+  var INITIAL_MODULE_OPTIONS = {
+    lightSources: {}
   };
-  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 convertColor(colorDef = {}) {
+    const { color = [0, 0, 0], intensity = 1 } = colorDef;
+    return color.map((component) => component * intensity / 255);
   }
   function getLightSourceUniforms({
     ambientLight,
@@ -3744,55 +3627,79 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     directionalLights = []
   }) {
     const lightSourceUniforms = {};
-    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;
+    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;
     return lightSourceUniforms;
   }
-  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:
+  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
+        }
+      );
     }
-    return lightSources;
-  }
-  function convertColor(colorDef = {}) {
-    const { color = [0, 0, 0], intensity = 1 } = colorDef;
-    return color.map((component) => component * intensity / COLOR_FACTOR);
+    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:
+        }
+      }
+      return getUniforms({ lightSources });
+    }
+    return {};
   }
+  var lights = {
+    name: "lights",
+    vs: lightingShader,
+    fs: lightingShader,
+    getUniforms,
+    defines: {
+      MAX_LIGHTS: 3
+    }
+  };
 
-  // ../shadertools/src/modules/lighting/pbr-material/pbr-vertex-glsl.ts
+  // ../shadertools/src/modules-webgl1/lighting/pbr/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;
 
@@ -3806,17 +3713,17 @@ out vec3 pbr_vNormal;
 
 void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
 {
-  vec4 pos = pbrProjection.modelMatrix * position;
+  vec4 pos = u_ModelMatrix * position;
   pbr_vPosition = vec3(pos.xyz) / pos.w;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
-  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));
+  vec3 tangentW = normalize(vec3(u_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(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 
@@ -3828,69 +3735,55 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 }
 `;
 
-  // ../shadertools/src/modules/lighting/pbr-material/pbr-fragment-glsl.ts
+  // ../shadertools/src/modules-webgl1/lighting/pbr/pbr-fragment-glsl.ts
   var fs = glsl`\
 precision highp float;
 
-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
+uniform bool pbr_uUnlit;
+
+#ifdef USE_IBL
+uniform samplerCube u_DiffuseEnvSampler;
+uniform samplerCube u_SpecularEnvSampler;
+uniform sampler2D u_brdfLUT;
+uniform vec2 u_ScaleIBLAmbient;
+#endif
+
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D pbr_baseColorSampler;
+uniform sampler2D u_BaseColorSampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D pbr_normalSampler;
+uniform sampler2D u_NormalSampler;
+uniform float u_NormalScale;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D pbr_emissiveSampler;
+uniform sampler2D u_EmissiveSampler;
+uniform vec3 u_EmissiveFactor;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D pbr_metallicRoughnessSampler;
+uniform sampler2D u_MetallicRoughnessSampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-uniform sampler2D pbr_occlusionSampler;
+uniform sampler2D u_OcclusionSampler;
+uniform float u_OcclusionStrength;
 #endif
-#ifdef USE_IBL
-uniform samplerCube pbr_diffuseEnvSampler;
-uniform samplerCube pbr_specularEnvSampler;
-uniform sampler2D pbr_brdfLUT;
+
+#ifdef ALPHA_CUTOFF
+uniform float u_AlphaCutoff;
 #endif
 
-// Inputs from vertex shader
+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
 
 in vec3 pbr_vPosition;
+
 in vec2 pbr_vUV;
 
 #ifdef HAS_NORMALS
@@ -3904,7 +3797,8 @@ 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
@@ -3929,7 +3823,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
@@ -3965,8 +3859,8 @@ vec3 getNormal()
 #endif
 
 #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 = texture(u_NormalSampler, pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_NormalScale, u_NormalScale, 1.0)));
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   vec3 n = normalize(tbn[2].xyz);
@@ -3979,27 +3873,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 pbrInfo, vec3 n, vec3 reflection)
+vec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)
 {
   float mipCount = 9.0; // resolution of 512x512
-  float lod = (pbrInfo.perceptualRoughness * mipCount);
+  float lod = (pbrInputs.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;
+  vec3 brdf = SRGBtoLINEAR(texture(u_brdfLUT,
+    vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
 
 #ifdef USE_TEX_LOD
-  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
 #else
-  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
 #endif
 
-  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
-  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
+  vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;
+  vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);
 
   // For presentation, this allows us to disable IBL terms
-  diffuse *= pbrMaterial.scaleIBLAmbient.x;
-  specular *= pbrMaterial.scaleIBLAmbient.y;
+  diffuse *= u_ScaleIBLAmbient.x;
+  specular *= u_ScaleIBLAmbient.y;
 
   return diffuse + specular;
 }
@@ -4008,29 +3902,29 @@ vec3 getIBLContribution(PBRInfo pbrInfo, 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 pbrInfo)
+vec3 diffuse(PBRInfo pbrInputs)
 {
-  return pbrInfo.diffuseColor / M_PI;
+  return pbrInputs.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 pbrInfo)
+vec3 specularReflection(PBRInfo pbrInputs)
 {
-  return pbrInfo.reflectance0 +
-    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
-    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+  return pbrInputs.reflectance0 +
+    (pbrInputs.reflectance90 - pbrInputs.reflectance0) *
+    pow(clamp(1.0 - pbrInputs.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 pbrInfo)
+float geometricOcclusion(PBRInfo pbrInputs)
 {
-  float NdotL = pbrInfo.NdotL;
-  float NdotV = pbrInfo.NdotV;
-  float r = pbrInfo.alphaRoughness;
+  float NdotL = pbrInputs.NdotL;
+  float NdotV = pbrInputs.NdotV;
+  float r = pbrInputs.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)));
@@ -4043,80 +3937,80 @@ float geometricOcclusion(PBRInfo pbrInfo)
 // 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 pbrInfo)
+float microfacetDistribution(PBRInfo pbrInputs)
 {
-  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
-  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
+  float roughnessSq = pbrInputs.alphaRoughness * pbrInputs.alphaRoughness;
+  float f = (pbrInputs.NdotH * roughnessSq - pbrInputs.NdotH) * pbrInputs.NdotH + 1.0;
   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;
+void PBRInfo_setAmbientLight(inout PBRInfo pbrInputs) {
+  pbrInputs.NdotL = 1.0;
+  pbrInputs.NdotH = 0.0;
+  pbrInputs.LdotH = 0.0;
+  pbrInputs.VdotH = 1.0;
 }
 
-void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
-  vec3 n = pbrInfo.n;
-  vec3 v = pbrInfo.v;
+void PBRInfo_setDirectionalLight(inout PBRInfo pbrInputs, vec3 lightDirection) {
+  vec3 n = pbrInputs.n;
+  vec3 v = pbrInputs.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);
+  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);
 }
 
-void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
+void PBRInfo_setPointLight(inout PBRInfo pbrInputs, PointLight pointLight) {
   vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
-  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+  PBRInfo_setDirectionalLight(pbrInputs, light_direction);
 }
 
-vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
+vec3 calculateFinalColor(PBRInfo pbrInputs, vec3 lightColor) {
   // Calculate the shading terms for the microfacet specular shading model
-  vec3 F = specularReflection(pbrInfo);
-  float G = geometricOcclusion(pbrInfo);
-  float D = microfacetDistribution(pbrInfo);
+  vec3 F = specularReflection(pbrInputs);
+  float G = geometricOcclusion(pbrInputs);
+  float D = microfacetDistribution(pbrInputs);
 
   // Calculation of analytical lighting contribution
-  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
-  vec3 specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
+  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);
+  vec3 specContrib = F * G * D / (4.0 * pbrInputs.NdotL * pbrInputs.NdotV);
   // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
-  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
+  return pbrInputs.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(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
+  vec4 baseColor = SRGBtoLINEAR(texture(u_BaseColorSampler, pbr_vUV)) * u_BaseColorFactor;
 #else
-  vec4 baseColor = pbrMaterial.baseColorFactor;
+  vec4 baseColor = u_BaseColorFactor;
 #endif
 
 #ifdef ALPHA_CUTOFF
-  if (baseColor.a < pbrMaterial.alphaCutoff) {
+  if (baseColor.a < u_AlphaCutoff) {
     discard;
   }
 #endif
 
   vec3 color = vec3(0, 0, 0);
 
-  if(pbrMaterial.unlit){
+  if(pbr_uUnlit){
     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 = pbrMaterial.metallicRoughnessValues.y;
-    float metallic = pbrMaterial.metallicRoughnessValues.x;
+    float perceptualRoughness = u_MetallicRoughnessValues.y;
+    float metallic = u_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(pbr_metallicRoughnessSampler, pbr_vUV);
+    vec4 mrSample = texture(u_MetallicRoughnessSampler, pbr_vUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
 #endif
@@ -4143,12 +4037,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(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
+    vec3 v = normalize(u_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(
+    PBRInfo pbrInputs = PBRInfo(
       0.0, // NdotL
       NdotV,
       0.0, // NdotH
@@ -4165,50 +4059,43 @@ vec4 pbr_filterColor(vec4 colorUnused)
       v
     );
 
-
 #ifdef USE_LIGHTS
     // Apply ambient light
-    PBRInfo_setAmbientLight(pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+    PBRInfo_setAmbientLight(pbrInputs);
+    color += calculateFinalColor(pbrInputs, lighting_uAmbientLight.color);
 
     // 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);
+    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);
       }
     }
 
     // Apply point light
-    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_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);
       }
     }
 #endif
 
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
-    if (pbrMaterial.IBLenabled) {
-      color += getIBLContribution(pbrInfo, n, reflection);
-    }
+    color += getIBLContribution(pbrInputs, n, reflection);
 #endif
 
- // Apply optional PBR terms for additional (optional) shading
+    // Apply optional PBR terms for additional (optional) shading
 #ifdef HAS_OCCLUSIONMAP
-    if (pbrMaterial.occlusionMapEnabled) {
-      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
-      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
-    }
+    float ao = texture(u_OcclusionSampler, pbr_vUV).r;
+    color = mix(color, color * ao, u_OcclusionStrength);
 #endif
 
 #ifdef HAS_EMISSIVEMAP
-    if (pbrMaterial.emissiveMapEnabled) {
-      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
-      color += emissive;
-    }
+    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;
+    color += emissive;
 #endif
 
     // This section uses mix to override final color for reference app visualization
@@ -4216,15 +4103,15 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef PBR_DEBUG
     // TODO: Figure out how to debug multiple lights
 
-    // 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, 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, 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);
+    // 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);
 #endif
 
   }
@@ -4233,77 +4120,15 @@ vec4 pbr_filterColor(vec4 colorUnused)
 }
 `;
 
-  // ../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",
+  // ../shadertools/src/modules-webgl1/lighting/pbr/pbr.ts
+  var pbr = {
+    name: "pbr",
     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
     },
-    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]
+    dependencies: [lights]
   };
 
   // src/gltf/create-gltf-model.ts
@@ -4351,7 +4176,7 @@ uniform pbrProjectionUniforms {
     #endif
 
     pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
-    gl_Position = pbrProjection.modelViewProjectionMatrix * positions;
+    gl_Position = u_MVPMatrix * positions;
   }
 `;
   var fs2 = `
@@ -4370,7 +4195,7 @@ uniform pbrProjectionUniforms {
   function createGLTFModel(device, options) {
     const { id, geometry, material, vertexCount, materialOptions, modelOptions } = options;
     const parsedMaterial = parsePBRMaterial(device, material, geometry.attributes, materialOptions);
-    import_core5.log.info(4, "createGLTFModel defines: ", parsedMaterial.defines)();
+    import_core4.log.info(4, "createGLTFModel defines: ", parsedMaterial.defines)();
     const managedResources = [];
     const parameters = {
       depthWriteEnabled: true,
@@ -4383,22 +4208,16 @@ uniform pbrProjectionUniforms {
       geometry,
       topology: geometry.topology,
       vertexCount,
-      modules: [pbrMaterial],
+      modules: [pbr],
       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 }
+      parameters: { ...parameters, ...parsedMaterial.parameters, ...modelOptions.parameters },
+      uniforms: { ...parsedMaterial.uniforms, ...modelOptions.uniforms }
     };
     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) {