@luma.gl/shadertools 9.1.0-alpha.16 → 9.1.0-alpha.18

package/dist/index.cjs

@@ -316,6 +316,17 @@ function initializeShaderModule(module2) {
     instance.propValidators = makePropValidators(propTypes);
   }
   module2.instance = instance;
+  let defaultProps = {};
+  if (propTypes) {
+    defaultProps = Object.entries(propTypes).reduce((obj, [key, propType]) => {
+      const value = propType == null ? void 0 : propType.value;
+      if (value) {
+        obj[key] = value;
+      }
+      return obj;
+    }, {});
+  }
+  module2.defaultUniforms = { ...module2.defaultUniforms, ...defaultProps };
 }
 function getShaderModuleUniforms(module2, props, oldUniforms) {
   var _a;
@@ -326,15 +337,15 @@ function getShaderModuleUniforms(module2, props, oldUniforms) {
   }
   return getValidatedProperties(props, (_a = module2.instance) == null ? void 0 : _a.propValidators, module2.name);
 }
-function checkShaderModuleDeprecations(shaderModule, shaderSource, log2) {
+function checkShaderModuleDeprecations(shaderModule, shaderSource, log3) {
   var _a;
   (_a = shaderModule.deprecations) == null ? void 0 : _a.forEach((def) => {
     var _a2;
     if ((_a2 = def.regex) == null ? void 0 : _a2.test(shaderSource)) {
       if (def.deprecated) {
-        log2.deprecated(def.old, def.new)();
+        log3.deprecated(def.old, def.new)();
       } else {
-        log2.removed(def.old, def.new)();
+        log3.removed(def.old, def.new)();
       }
     }
   });
@@ -629,7 +640,7 @@ function assembleShaderWGSL(platformInfo, options) {
     // defines = {},
     hookFunctions = [],
     inject = {},
-    log: log2
+    log: log3
   } = options;
   assert(typeof source2 === "string", "shader source must be a string");
   const coreSource = source2;
@@ -659,8 +670,8 @@ function assembleShaderWGSL(platformInfo, options) {
   }
   const modulesToInject = modules;
   for (const module2 of modulesToInject) {
-    if (log2) {
-      checkShaderModuleDeprecations(module2, coreSource, log2);
+    if (log3) {
+      checkShaderModuleDeprecations(module2, coreSource, log3);
     }
     const moduleSource = getShaderModuleSource(module2, "wgsl");
     assembledSource += moduleSource;
@@ -687,7 +698,7 @@ function assembleShaderWGSL(platformInfo, options) {
 }
 function assembleShaderGLSL(platformInfo, options) {
   var _a;
-  const { id, source: source2, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log2 } = options;
+  const { id, source: source2, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log3 } = options;
   assert(typeof source2 === "string", "shader source must be a string");
   const sourceVersion = language === "glsl" ? getShaderInfo(source2).version : -1;
   const targetVersion = platformInfo.shaderLanguageVersion;
@@ -745,8 +756,8 @@ ${getApplicationDefines(allDefines)}
     }
   }
   for (const module2 of modules) {
-    if (log2) {
-      checkShaderModuleDeprecations(module2, coreSource, log2);
+    if (log3) {
+      checkShaderModuleDeprecations(module2, coreSource, log3);
     }
     const moduleSource = getShaderModuleSource(module2, stage);
     assembledSource += moduleSource;
@@ -1507,7 +1518,7 @@ var fp32 = {
 };
 
 // dist/modules/engine/picking/picking.js
-var DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);
+var DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
 var vs = (
   /* glsl */
   `uniform pickingUniforms {
@@ -1660,7 +1671,7 @@ var picking = {
     isAttribute: false,
     isHighlightActive: false,
     useFloatColors: true,
-    highlightedObjectColor: new Float32Array([0, 0, 0]),
+    highlightedObjectColor: [0, 0, 0],
     highlightColor: DEFAULT_HIGHLIGHT_COLOR
   },
   vs,
@@ -1694,6 +1705,9 @@ function getUniforms(opts = {}, prevUniforms) {
   return uniforms;
 }
 
+// dist/modules/lighting/lights/lighting.js
+var import_core3 = require("@luma.gl/core");
+
 // dist/modules/lighting/lights/lighting-uniforms-glsl.js
 var lightingUniformsGLSL = (
   /* glsl */
@@ -1717,28 +1731,51 @@ struct DirectionalLight {
 
 uniform lightingUniforms {
   int enabled;
-  int pointLightCount;
+  int lightType;
+
   int directionalLightCount;
+  int pointLightCount;
 
   vec3 ambientColor;
 
-  int lightType;
-  vec3 lightColor;
-  vec3 lightDirection;
-  vec3 lightPosition;
-  vec3 lightAttenuation;
+  vec3 lightColor0;
+  vec3 lightPosition0;
+  vec3 lightDirection0;
+  vec3 lightAttenuation0;
 
-  // AmbientLight ambientLight;
-  // PointLight pointLight[MAX_LIGHTS];
-  // DirectionalLight directionalLight[MAX_LIGHTS];
+  vec3 lightColor1;
+  vec3 lightPosition1;
+  vec3 lightDirection1;
+  vec3 lightAttenuation1;
+
+  vec3 lightColor2;
+  vec3 lightPosition2;
+  vec3 lightDirection2;
+  vec3 lightAttenuation2;
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
-  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:
+    default:  
+      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+  }
 }
 
 DirectionalLight lighting_getDirectionalLight(int index) {
-  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:
+    default:   
+      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+  }
 } 
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {
@@ -1809,7 +1846,7 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
 );
 
 // dist/modules/lighting/lights/lighting.js
-var MAX_LIGHTS = 5;
+var MAX_LIGHTS = 3;
 var COLOR_FACTOR = 255;
 var LIGHT_TYPE;
 (function(LIGHT_TYPE2) {
@@ -1825,31 +1862,44 @@ var lighting = {
   },
   uniformTypes: {
     enabled: "i32",
-    ambientLightColor: "vec3<f32>",
-    numberOfLights: "i32",
-    // , array: MAX_LIGHTS,
     lightType: "i32",
-    // , array: MAX_LIGHTS,
-    lightColor: "vec3<f32>",
-    // , array: MAX_LIGHTS,
-    lightPosition: "vec3<f32>",
-    // , array: MAX_LIGHTS,
+    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
-    lightDirection: "vec3<f32>",
-    // , array: MAX_LIGHTS,
-    lightAttenuation: "vec3<f32>"
-    // , array: MAX_LIGHTS},
+    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,
-    ambientLightColor: [0.1, 0.1, 0.1],
-    numberOfLights: 0,
     lightType: LIGHT_TYPE.POINT,
-    lightColor: [1, 1, 1],
-    lightPosition: [1, 1, 2],
+    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
-    lightDirection: [1, 1, 1],
-    lightAttenuation: [1, 1, 1]
+    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]
   },
   source: lightingUniformsWGSL,
   vs: lightingUniformsGLSL,
@@ -1880,30 +1930,29 @@ function getUniforms2(props, prevUniforms = {}) {
   return uniforms;
 }
 function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {
-  const lightSourceUniforms = {
-    // lightType: new Array(MAX_LIGHTS).fill(0),
-    // lightColor: new Array(MAX_LIGHTS).fill([0, 0, 0]),
-    // lightPosition: new Array(MAX_LIGHTS).fill([0, 0, 0]),
-    // lightDirection: new Array(MAX_LIGHTS).fill([0, 0, 0]),
-    // lightAttenuation: new Array(MAX_LIGHTS).fill([0, 0, 0])
-  };
+  const lightSourceUniforms = {};
   lightSourceUniforms.ambientLightColor = convertColor(ambientLight);
   let currentLight = 0;
   for (const pointLight of pointLights) {
     lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
-    lightSourceUniforms.lightColor = convertColor(pointLight);
-    lightSourceUniforms.lightPosition = pointLight.position;
-    lightSourceUniforms.lightAttenuation = [pointLight.attenuation || 1, 0, 0];
+    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 = LIGHT_TYPE.DIRECTIONAL;
-    lightSourceUniforms.lightColor = convertColor(directionalLight);
-    lightSourceUniforms.lightPosition = directionalLight.position;
-    lightSourceUniforms.lightDirection = directionalLight.direction;
+    const i = currentLight;
+    lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
+    lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
     currentLight++;
   }
-  lightSourceUniforms.numberOfLights = currentLight;
+  if (currentLight > MAX_LIGHTS) {
+    import_core3.log.warn("MAX_LIGHTS exceeded")();
+  }
+  lightSourceUniforms.directionalLightCount = directionalLights.length;
+  lightSourceUniforms.pointLightCount = pointLights.length;
   return lightSourceUniforms;
 }
 function extractLightTypes(lights2) {
@@ -2003,7 +2052,7 @@ var dirlight = {
     lightDirection: "vec3<f32>"
   },
   defaultUniforms: {
-    lightDirection: new Float32Array([1, 1, 2])
+    lightDirection: [1, 1, 2]
   },
   getUniforms: getUniforms3
 };
@@ -2015,10 +2064,10 @@ function getUniforms3(opts = dirlight.defaultUniforms) {
   return uniforms;
 }
 
-// dist/modules/lighting/gouraud-material/gouraud-shaders-glsl.js
-var GOURAUD_VS = (
+// dist/modules/lighting/phong-material/phong-shaders-glsl.js
+var PHONG_VS = (
   /* glsl */
-  `uniform materialUniforms {
+  `uniform phongMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -2026,9 +2075,9 @@ var GOURAUD_VS = (
 } material;
 `
 );
-var GOURAUD_FS = (
+var PHONG_FS = (
   /* glsl */
-  `uniform materialUniforms {
+  `uniform phongMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -2050,63 +2099,27 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
   vec3 lightColor = surfaceColor;
 
-  if (lighting.enabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-    lightColor = material.ambient * surfaceColor * lighting.ambientColor;
-
-    if (lighting.lightType == 0) {
-      PointLight pointLight = lighting_getPointLight(0);
-      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);
-    } else if (lighting.lightType == 1) {
-      DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-    /*
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting.pointLight[i];
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      DirectionalLight directionalLight = lighting.directionalLight[i];
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-    */
+  if (lighting.enabled == 0) {
+    return lightColor;
   }
-  return lightColor;
-}
-
-vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = vec3(0, 0, 0);
-  vec3 surfaceColor = vec3(0, 0, 0);
 
-  if (lighting.enabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 
-    switch (lighting.lightType) {
-      case 0:
-        PointLight pointLight = lighting_getPointLight(0);
-        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);
-        break;
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
 
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
-    }
+  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
+  for (int i = lighting.pointLightCount; i < totalLights; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }
+  
   return lightColor;
 }
 `
@@ -2115,11 +2128,10 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
 // dist/modules/lighting/gouraud-material/gouraud-material.js
 var gouraudMaterial = {
   props: {},
-  uniforms: {},
-  name: "gouraud-lighting",
+  name: "gouraudMaterial",
   // Note these are switched between phong and gouraud
-  vs: GOURAUD_VS,
-  fs: GOURAUD_FS,
+  vs: PHONG_FS.replace("phongMaterial", "gouraudMaterial"),
+  fs: PHONG_VS.replace("phongMaterial", "gouraudMaterial"),
   defines: {
     LIGHTING_VERTEX: 1
   },
@@ -2137,7 +2149,11 @@ var gouraudMaterial = {
     specularColor: [0.15, 0.15, 0.15]
   },
   getUniforms(props) {
-    return { ...gouraudMaterial.defaultUniforms, ...props };
+    const uniforms = { ...props };
+    if (uniforms.specularColor) {
+      uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+    }
+    return { ...gouraudMaterial.defaultUniforms, ...uniforms };
   }
 };
 
@@ -2232,111 +2248,9 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
 `
 );
 
-// dist/modules/lighting/phong-material/phong-shaders-glsl.js
-var PHONG_VS = (
-  /* glsl */
-  `uniform phongMaterialUniforms {
-  uniform float ambient;
-  uniform float diffuse;
-  uniform float shininess;
-  uniform vec3  specularColor;
-} material;
-`
-);
-var PHONG_FS = (
-  /* glsl */
-  `uniform phongMaterialUniforms {
-  uniform float ambient;
-  uniform float diffuse;
-  uniform float shininess;
-  uniform vec3  specularColor;
-} material;
-
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
-  vec3 halfway_direction = normalize(light_direction + view_direction);
-  float lambertian = dot(light_direction, normal_worldspace);
-  float specular = 0.0;
-  if (lambertian > 0.0) {
-    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
-    specular = pow(specular_angle, material.shininess);
-  }
-  lambertian = max(lambertian, 0.0);
-  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
-}
-
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = surfaceColor;
-
-  if (lighting.enabled == 0) {
-    return lightColor;
-  }
-
-  vec3 view_direction = normalize(cameraPosition - position_worldspace);
-  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
-
-  if (lighting.lightType == 0) {
-    PointLight pointLight = lighting_getPointLight(0);
-    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);
-  } else if (lighting.lightType == 1) {
-    DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-  }
-  
-  /*
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.pointLightCount) {
-      break;
-    }
-    PointLight pointLight = lighting.pointLight[i];
-    vec3 light_position_worldspace = pointLight.position;
-    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-  }
-
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.directionalLightCount) {
-      break;
-    }
-    DirectionalLight directionalLight = lighting.directionalLight[i];
-    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-  }
-  */
-  return lightColor;
-}
-
-vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = vec3(0, 0, 0);
-  vec3 surfaceColor = vec3(0, 0, 0);
-
-  if (lighting.enabled == 0) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-
-    switch (lighting.lightType) {
-      case 0:
-        PointLight pointLight = lighting_getPointLight(0);
-        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);
-        break;
-
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
-    }
-  }
-  return lightColor;
-}
-`
-);
-
 // dist/modules/lighting/phong-material/phong-material.js
 var phongMaterial = {
-  props: {},
-  uniforms: {},
-  name: "phong-lighting",
+  name: "phongMaterial",
   dependencies: [lighting],
   // Note these are switched between phong and gouraud
   source: PHONG_WGSL,
@@ -2358,45 +2272,41 @@ var phongMaterial = {
     specularColor: [0.15, 0.15, 0.15]
   },
   getUniforms(props) {
-    return { ...phongMaterial.defaultUniforms, ...props };
+    const uniforms = { ...props };
+    if (uniforms.specularColor) {
+      uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+    }
+    return { ...phongMaterial.defaultUniforms, ...uniforms };
   }
 };
 
 // dist/modules/lighting/pbr-material/pbr-vertex-glsl.js
 var vs2 = (
   /* glsl */
-  `uniform projection {
-  mat4 u_MVPMatrix;
-  mat4 u_ModelMatrix;
-  mat4 u_NormalMatrix;
-  // Projection
-  vec3 u_Camera;
-}
-
-varying vec3 pbr_vPosition;
-varying vec2 pbr_vUV;
+  `out vec3 pbr_vPosition;
+out vec2 pbr_vUV;
 
 #ifdef HAS_NORMALS
 # ifdef HAS_TANGENTS
-varying mat3 pbr_vTBN;
+out mat3 pbr_vTBN;
 # else
-varying vec3 pbr_vNormal;
+out vec3 pbr_vNormal;
 # endif
 #endif
 
 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
 
@@ -2414,12 +2324,7 @@ var fs3 = (
   /* glsl */
   `precision highp float;
 
-uniform Projection {
-  // Projection
-  uniform vec3 u_Camera;
-};
-
-uniform pbrMaterial {
+uniform pbrMaterialUniforms {
   // Material is unlit
   bool unlit;
 
@@ -2451,40 +2356,40 @@ uniform pbrMaterial {
   vec4 scaleDiffBaseMR;
   vec4 scaleFGDSpec;
   // #endif
-} u_pbrMaterial;
+} pbrMaterial;
 
 // Samplers
 #ifdef HAS_BASECOLORMAP
-uniform sampler2D u_BaseColorSampler;
+uniform sampler2D pbr_baseColorSampler;
 #endif
 #ifdef HAS_NORMALMAP
-uniform sampler2D u_NormalSampler;
+uniform sampler2D pbr_normalSampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-uniform sampler2D u_EmissiveSampler;
+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 sampler2D pbr_occlusionSampler;
 #endif
 #ifdef USE_IBL
-uniform samplerCube u_DiffuseEnvSampler;
-uniform samplerCube u_SpecularEnvSampler;
-uniform sampler2D u_brdfLUT;
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
 #endif
 
 // Inputs from vertex shader
 
-varying vec3 pbr_vPosition;
-varying vec2 pbr_vUV;
+in vec3 pbr_vPosition;
+in vec2 pbr_vUV;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-varying mat3 pbr_vTBN;
+in mat3 pbr_vTBN;
 #else
-varying vec3 pbr_vNormal;
+in vec3 pbr_vNormal;
 #endif
 #endif
 
@@ -2552,8 +2457,8 @@ vec3 getNormal()
 #endif
 
 #ifdef HAS_NORMALMAP
-  vec3 n = texture2D(u_NormalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_pbrMaterial.normalScale, u_pbrMaterial.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);
@@ -2571,22 +2476,22 @@ vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
   float mipCount = 9.0; // resolution of 512x512
   float lod = (pbrInfo.perceptualRoughness * mipCount);
   // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture2D(u_brdfLUT,
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
     vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
-  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).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 * pbrInfo.diffuseColor;
   vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
 
   // For presentation, this allows us to disable IBL terms
-  diffuse *= u_pbrMaterial.scaleIBLAmbient.x;
-  specular *= u_pbrMaterial.scaleIBLAmbient.y;
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
 
   return diffuse + specular;
 }
@@ -2678,32 +2583,32 @@ vec4 pbr_filterColor(vec4 colorUnused)
 {
   // The albedo may be defined from a base texture or a flat color
 #ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture2D(u_BaseColorSampler, pbr_vUV)) * u_pbrMaterial.baseColorFactor;
+  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
 #else
-  vec4 baseColor = u_pbrMaterial.baseColorFactor;
+  vec4 baseColor = pbrMaterial.baseColorFactor;
 #endif
 
 #ifdef ALPHA_CUTOFF
-  if (baseColor.a < u_pbrMaterial.alphaCutoff) {
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
     discard;
   }
 #endif
 
   vec3 color = vec3(0, 0, 0);
 
-  if(u_pbrMaterial.unlit){
+  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_pbrMaterial.metallicRoughnessValues.y;
-    float metallic = u_pbrMaterial.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 = texture2D(u_MetallicRoughnessSampler, pbr_vUV);
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
 #endif
@@ -2730,7 +2635,7 @@ 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));
@@ -2752,47 +2657,48 @@ vec4 pbr_filterColor(vec4 colorUnused)
       v
     );
 
+
 #ifdef USE_LIGHTS
     // Apply ambient light
     PBRInfo_setAmbientLight(pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting_uAmbientLight.color);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
 
     // Apply directional light
-    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {
-      if (i < lighting_uDirectionalLightCount) {
-        PBRInfo_setDirectionalLight(pbrInfo, lighting_uDirectionalLight[i].direction);
-        color += calculateFinalColor(pbrInfo, 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(pbrInfo, lighting_uPointLight[i]);
-        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
-        color += calculateFinalColor(pbrInfo, 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
-    if (u_pbrMateral.IBLEnabled) {
+    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
-    if (u_pbrMaterial.occlusionMapEnabled) {
-      float ao = texture2D(u_OcclusionSampler, pbr_vUV).r;
-      color = mix(color, color * ao, u_pbrMaterial.occlusionStrength);
+    if (pbrMaterial.occlusionMapEnabled) {
+      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
     }
 #endif
 
 #ifdef HAS_EMISSIVEMAP
-    if (u_pbrMaterial.emmissiveMapEnabled) {
-      vec3 emissive = SRGBtoLINEAR(texture2D(u_EmissiveSampler, pbr_vUV)).rgb * u_pbrMaterial.emissiveFactor;
+    if (pbrMaterial.emissiveMapEnabled) {
+      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
       color += emissive;
     }
 #endif
@@ -2802,15 +2708,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_pbrMaterial.scaleDiffBaseMR.y);
-    color = mix(color, vec3(metallic), u_pbrMaterial.scaleDiffBaseMR.z);
-    color = mix(color, vec3(perceptualRoughness), u_pbrMaterial.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
 
   }
@@ -2820,25 +2726,52 @@ vec4 pbr_filterColor(vec4 colorUnused)
 `
 );
 
+// dist/modules/lighting/pbr-material/pbr-projection.js
+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>"
+  }
+};
+
 // dist/modules/lighting/pbr-material/pbr-material.js
 var pbrMaterial = {
   props: {},
   uniforms: {},
-  name: "pbr",
-  dependencies: [lighting],
+  name: "pbrMaterial",
+  dependencies: [lighting, pbrProjection],
   vs: vs2,
   fs: fs3,
   defines: {
-    LIGHTING_FRAGMENT: 1,
-    HAS_NORMALMAP: 0,
-    HAS_EMISSIVEMAP: 0,
-    HAS_OCCLUSIONMAP: 0,
-    HAS_BASECOLORMAP: 0,
-    HAS_METALROUGHNESSMAP: 0,
-    ALPHA_CUTOFF: 0,
-    USE_IBL: 0,
-    PBR_DEBUG: 0
+    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",
@@ -2867,25 +2800,6 @@ var pbrMaterial = {
     // #ifdef PBR_DEBUG
     scaleDiffBaseMR: "vec4<f32>",
     scaleFGDSpec: "vec4<f32>"
-  },
-  bindings: {
-    baseColorSampler: { type: "texture", location: 8 },
-    // #ifdef HAS_BASECOLORMAP
-    normalSampler: { type: "texture", location: 9 },
-    // #ifdef HAS_NORMALMAP
-    emissiveSampler: { type: "texture", location: 10 },
-    // #ifdef HAS_EMISSIVEMAP
-    metallicRoughnessSampler: { type: "texture", location: 11 },
-    // #ifdef HAS_METALROUGHNESSMAP
-    occlusionSampler: { type: "texture", location: 12 },
-    // #ifdef HAS_OCCLUSIONMAP
-    // IBL Samplers
-    diffuseEnvSampler: { type: "texture", location: 13 },
-    // #ifdef USE_IBL (samplerCube)
-    specularEnvSampler: { type: "texture", location: 14 },
-    // #ifdef USE_IBL (samplerCube)
-    brdfLUT: { type: "texture", location: 15 }
-    // #ifdef USE_IBL
   }
 };
 
@@ -2935,7 +2849,6 @@ vec4 brightnessContrast_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord)
 );
 var brightnessContrast = {
   props: {},
-  uniforms: {},
   name: "brightnessContrast",
   uniformTypes: {
     brightness: "f32",
@@ -3034,7 +2947,6 @@ vec4 hueSaturation_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
 );
 var hueSaturation = {
   props: {},
-  uniforms: {},
   name: "hueSaturation",
   fs: fs6,
   uniformTypes: {
@@ -3145,6 +3057,9 @@ var vibrance = {
   props: {},
   uniforms: {},
   name: "vibrance",
+  uniformTypes: {
+    amount: "f32"
+  },
   propTypes: {
     amount: { value: 0, min: -1, max: 1 }
   },
@@ -3478,11 +3393,11 @@ var fs16 = (
   /* glsl */
   `uniform edgeWorkUniforms {
   float radius;
-  vec2 delta;
+  int mode;
 } edgeWork;
 
-vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
+vec4 edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * delta / texSize;
 
   vec2 color = vec2(0.0);
   vec2 total = vec2(0.0);
@@ -3506,8 +3421,8 @@ vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
   return vec4(color / total, 0.0, 1.0);
 }
 
-vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
+vec4 edgeWork_sampleColorXY(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * delta / texSize;
 
   vec2 color = vec2(0.0);
   vec2 total = vec2(0.0);
@@ -3530,6 +3445,16 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);
   return vec4(c, c, c, 1.0);
 }
+
+vec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  switch (edgeWork.mode) {
+    case 0: 
+    return edgeWork_sampleColorRGB(source, texSize, texCoord, vec2(1., 0.));
+    case 1: 
+    default:
+      return edgeWork_sampleColorXY(source, texSize, texCoord, vec2(0., 1.));
+  }
+}
 `
 );
 var edgeWork = {
@@ -3538,20 +3463,22 @@ var edgeWork = {
   name: "edgeWork",
   dependencies: [random],
   fs: fs16,
+  uniformTypes: {
+    radius: "f32",
+    mode: "i32"
+  },
   propTypes: {
     radius: { value: 2, min: 1, softMax: 50 },
-    delta: { value: [1, 0], private: true }
+    mode: { value: 0, private: true }
   },
   passes: [
     {
-      // @ts-expect-error
-      sampler: "edgeWork_sampleColor1",
-      propTypes: { delta: [1, 0] }
+      sampler: true,
+      uniforms: { mode: 0 }
     },
     {
-      // @ts-expect-error
-      sampler: "edgeWork_sampleColor2",
-      propTypes: { delta: [0, 1] }
+      sampler: true,
+      uniforms: { mode: 1 }
     }
   ]
 };
@@ -3837,7 +3764,9 @@ var swirl = {
 };
 
 // dist/passes/postprocessing/fxaa/fxaa.js
-var fs23 = `
+var fs23 = (
+  /* glsl */
+  `
 #define FXAA_QUALITY_PRESET 29
 
 #if (FXAA_QUALITY_PRESET == 10)
@@ -4417,7 +4346,8 @@ vec4 fxaa_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
         fxaa_QualityEdgeThresholdMin
     );
 }
-`;
+`
+);
 var fxaa = {
   name: "fxaa",
   propTypes: {},
@@ -5338,7 +5268,7 @@ var geometry = {
 };
 
 // dist/modules-webgl1/project/project.js
-var import_core3 = require("@math.gl/core");
+var import_core4 = require("@math.gl/core");
 var IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 var DEFAULT_MODULE_OPTIONS = {
   modelMatrix: IDENTITY_MATRIX,
@@ -5361,7 +5291,7 @@ function getUniforms5(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {
     uniforms.cameraPositionWorld = opts.cameraPositionWorld;
   }
   if (opts.projectionMatrix !== void 0 && opts.viewMatrix !== void 0) {
-    uniforms.viewProjectionMatrix = new import_core3.Matrix4(opts.projectionMatrix).multiplyRight(opts.viewMatrix);
+    uniforms.viewProjectionMatrix = new import_core4.Matrix4(opts.projectionMatrix).multiplyRight(opts.viewMatrix);
   }
   return uniforms;
 }