@luma.gl/shadertools 9.0.17 → 9.0.20

package/dist/dist.dev.js

@@ -408,13 +408,13 @@ ${moduleSource}
       return this.defines;
     }
     // Warn about deprecated uniforms or functions
-    checkDeprecations(shaderSource, log2) {
+    checkDeprecations(shaderSource, log3) {
       this.deprecations.forEach((def) => {
         if (def.regex?.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)();
           }
         }
       });
@@ -752,7 +752,7 @@ precision highp float;
       // defines = {},
       hookFunctions = [],
       inject = {},
-      log: log2
+      log: log3
     } = options;
     assert(typeof source === "string", "shader source must be a string");
     const coreSource = source;
@@ -782,8 +782,8 @@ precision highp float;
     }
     const modulesToInject = platformInfo.type !== "webgpu" ? modules : [];
     for (const module of modulesToInject) {
-      if (log2) {
-        module.checkDeprecations(coreSource, log2);
+      if (log3) {
+        module.checkDeprecations(coreSource, log3);
       }
       const moduleSource = module.getModuleSource(stage, "wgsl");
       assembledSource += moduleSource;
@@ -819,7 +819,7 @@ precision highp float;
       hookFunctions = [],
       inject = {},
       prologue = true,
-      log: log2
+      log: log3
     } = options;
     assert(typeof source === "string", "shader source must be a string");
     const sourceVersion = language === "glsl" ? getShaderInfo(source).version : -1;
@@ -877,8 +877,8 @@ ${getApplicationDefines(allDefines)}
       }
     }
     for (const module of modules) {
-      if (log2) {
-        module.checkDeprecations(coreSource, log2);
+      if (log3) {
+        module.checkDeprecations(coreSource, log3);
       }
       const moduleSource = module.getModuleSource(stage);
       assembledSource += moduleSource;
@@ -5112,28 +5112,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;
+
+  vec3 lightColor1;
+  vec3 lightPosition1;
+  vec3 lightDirection1;
+  vec3 lightAttenuation1;
 
-  // AmbientLight ambientLight;
-  // PointLight pointLight[MAX_LIGHTS];
-  // DirectionalLight directionalLight[MAX_LIGHTS];
+  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) {
@@ -5146,7 +5169,8 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 `;
 
   // src/modules/lighting/lights/lighting-uniforms.ts
-  var MAX_LIGHTS = 5;
+  var import_core2 = __toESM(require_core(), 1);
+  var MAX_LIGHTS = 3;
   var COLOR_FACTOR = 255;
   var lighting = {
     name: "lighting",
@@ -5160,31 +5184,44 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     },
     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: 0 /* 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, 1, 1],
+      lightColor1: [1, 1, 1],
+      lightPosition1: [1, 1, 2],
+      lightDirection1: [1, 1, 1],
+      lightAttenuation1: [1, 1, 1],
+      lightColor2: [1, 1, 1],
+      lightPosition2: [1, 1, 2],
+      lightDirection2: [1, 1, 1],
+      lightAttenuation2: [1, 1, 1]
     }
   };
   function getUniforms2(props, prevUniforms = {}) {
@@ -5215,30 +5252,29 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     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 = 0 /* 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 = 1 /* 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_core2.log.warn("MAX_LIGHTS exceeded")();
+    }
+    lightSourceUniforms.directionalLightCount = directionalLights.length;
+    lightSourceUniforms.pointLightCount = pointLights.length;
     return lightSourceUniforms;
   }
   function extractLightTypes(lights2) {
@@ -5312,17 +5348,17 @@ vec4 dirlight_filterColor(vec4 color) {
     return uniforms;
   }
 
-  // src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts
-  var GOURAUD_VS = glsl`\
-uniform materialUniforms {
+  // src/modules/lighting/phong-material/phong-shaders-glsl.ts
+  var PHONG_VS = glsl`\
+uniform phongMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
   uniform vec3  specularColor;
 } material;
 `;
-  var GOURAUD_FS = glsl`\
-uniform materialUniforms {
+  var PHONG_FS = glsl`\
+uniform phongMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -5344,73 +5380,38 @@ 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;
 }
+
 `;
 
   // src/modules/lighting/gouraud-material/gouraud-material.ts
   var gouraudMaterial = {
-    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
     },
@@ -5432,105 +5433,9 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
     }
   };
 
-  // src/modules/lighting/phong-material/phong-shaders-glsl.ts
-  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;
-}
-`;
-
   // src/modules/lighting/phong-material/phong-material.ts
   var phongMaterial = {
-    name: "phong-lighting",
+    name: "phongMaterial",
     // Note these are switched between phong and gouraud
     vs: PHONG_VS,
     fs: PHONG_FS,