@luma.gl/shadertools 9.0.19 → 9.0.21

package/dist/index.cjs

@@ -353,14 +353,14 @@ ${moduleSource}
     return this.defines;
   }
   // Warn about deprecated uniforms or functions
-  checkDeprecations(shaderSource, log2) {
+  checkDeprecations(shaderSource, log3) {
     this.deprecations.forEach((def) => {
       var _a;
       if ((_a = def.regex) == null ? void 0 : _a.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)();
         }
       }
     });
@@ -684,7 +684,7 @@ function assembleWGSLShader(platformInfo, options) {
     // defines = {},
     hookFunctions = [],
     inject = {},
-    log: log2
+    log: log3
   } = options;
   assert(typeof source === "string", "shader source must be a string");
   const coreSource = source;
@@ -714,8 +714,8 @@ function assembleWGSLShader(platformInfo, options) {
   }
   const modulesToInject = platformInfo.type !== "webgpu" ? modules : [];
   for (const module2 of modulesToInject) {
-    if (log2) {
-      module2.checkDeprecations(coreSource, log2);
+    if (log3) {
+      module2.checkDeprecations(coreSource, log3);
     }
     const moduleSource = module2.getModuleSource(stage, "wgsl");
     assembledSource += moduleSource;
@@ -741,7 +741,7 @@ function assembleWGSLShader(platformInfo, options) {
   return assembledSource;
 }
 function assembleGLSLShader(platformInfo, options) {
-  const { id, source, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log2 } = options;
+  const { id, source, stage, language = "glsl", modules, defines = {}, hookFunctions = [], inject = {}, prologue = true, log: log3 } = options;
   assert(typeof source === "string", "shader source must be a string");
   const sourceVersion = language === "glsl" ? getShaderInfo(source).version : -1;
   const targetVersion = platformInfo.shaderLanguageVersion;
@@ -798,8 +798,8 @@ ${getApplicationDefines(allDefines)}
     }
   }
   for (const module2 of modules) {
-    if (log2) {
-      module2.checkDeprecations(coreSource, log2);
+    if (log3) {
+      module2.checkDeprecations(coreSource, log3);
     }
     const moduleSource = module2.getModuleSource(stage);
     assembledSource += moduleSource;
@@ -1527,16 +1527,40 @@ int lightType;
 int directionalLightCount;
 int pointLightCount;
 vec3 ambientColor;
-vec3 lightColor;
-vec3 lightPosition;
-vec3 lightDirection;
-vec3 lightAttenuation;
+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) {
-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) {
 return pointLight.attenuation.x
@@ -1546,7 +1570,8 @@ return pointLight.attenuation.x
 `;
 
 // dist/modules/lighting/lights/lighting-uniforms.js
-var MAX_LIGHTS = 5;
+var import_core2 = require("@luma.gl/core");
+var MAX_LIGHTS = 3;
 var COLOR_FACTOR = 255;
 var LIGHT_TYPE;
 (function(LIGHT_TYPE2) {
@@ -1566,21 +1591,23 @@ var lighting = {
   uniformTypes: {
     enabled: "i32",
     lightType: "i32",
-    // , array: MAX_LIGHTS,
     directionalLightCount: "i32",
-    // , array: MAX_LIGHTS,
     pointLightCount: "i32",
-    // , array: MAX_LIGHTS,
     ambientLightColor: "vec3<f32>",
-    lightColor: "vec3<f32>",
-    // , array: MAX_LIGHTS,
-    lightPosition: "vec3<f32>",
-    // , array: MAX_LIGHTS,
+    // 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,
@@ -1588,11 +1615,19 @@ var lighting = {
     directionalLightCount: 0,
     pointLightCount: 0,
     ambientLightColor: [0.1, 0.1, 0.1],
-    lightColor: [1, 1, 1],
-    lightPosition: [1, 1, 2],
+    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]
   }
 };
 function getUniforms2(props, prevUniforms = {}) {
@@ -1619,29 +1654,27 @@ 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++;
   }
+  if (currentLight > MAX_LIGHTS) {
+    import_core2.log.warn("MAX_LIGHTS exceeded")();
+  }
   lightSourceUniforms.directionalLightCount = directionalLights.length;
   lightSourceUniforms.pointLightCount = pointLights.length;
   return lightSourceUniforms;
@@ -1712,8 +1745,15 @@ function getUniforms3(opts = dirlight.defaultUniforms) {
   return uniforms;
 }
 
-// dist/modules/lighting/gouraud-material/gouraud-shaders-glsl.js
-var GOURAUD_VS = `uniform gouraudMaterialUniforms {
+// dist/modules/lighting/phong-material/phong-shaders-glsl.js
+var PHONG_VS = `uniform phongMaterialUniforms {
+uniform float ambient;
+uniform float diffuse;
+uniform float shininess;
+uniform vec3  specularColor;
+} material;
+`;
+var PHONG_FS = `uniform phongMaterialUniforms {
 uniform float ambient;
 uniform float diffuse;
 uniform float shininess;
@@ -1737,53 +1777,28 @@ return lightColor;
 }
 vec3 view_direction = normalize(cameraPosition - position_worldspace);
 lightColor = material.ambient * surfaceColor * lighting.ambientColor;
-if (lighting.lightType == 0) {
-PointLight pointLight = lighting_getPointLight(0);
+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);
-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);
-}
-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) {
-return lightColor;
+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);
 }
-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);
+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);
-break;
 }
 return lightColor;
 }
 `;
-var GOURAUD_FS = `uniform gouraudMaterialUniforms {
-uniform float ambient;
-uniform float diffuse;
-uniform float shininess;
-uniform vec3  specularColor;
-} material;
-`;
 
 // dist/modules/lighting/gouraud-material/gouraud-material.js
 var gouraudMaterial = {
   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
   },
@@ -1801,76 +1816,14 @@ var gouraudMaterial = {
     specularColor: [0.15, 0.15, 0.15]
   },
   getUniforms(props) {
+    const uniforms = { ...props };
+    if (uniforms.specularColor) {
+      uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+    }
     return { ...gouraudMaterial.defaultUniforms, ...props };
   }
 };
 
-// dist/modules/lighting/phong-material/phong-shaders-glsl.js
-var PHONG_VS = `uniform phongMaterialUniforms {
-uniform float ambient;
-uniform float diffuse;
-uniform float shininess;
-uniform vec3  specularColor;
-} material;
-`;
-var PHONG_FS = `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);
-}
-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) {
-return lightColor;
-}
-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 = {
   name: "phongMaterial",
@@ -1894,6 +1847,10 @@ var phongMaterial = {
     specularColor: [0.15, 0.15, 0.15]
   },
   getUniforms(props) {
+    const uniforms = { ...props };
+    if (uniforms.specularColor) {
+      uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+    }
     return { ...phongMaterial.defaultUniforms, ...props };
   }
 };
@@ -4341,7 +4298,7 @@ var geometry = {
 };
 
 // dist/modules-webgl1/project/project.js
-var import_core2 = require("@math.gl/core");
+var import_core3 = 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,
@@ -4364,7 +4321,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_core2.Matrix4(opts.projectionMatrix).multiplyRight(opts.viewMatrix);
+    uniforms.viewProjectionMatrix = new import_core3.Matrix4(opts.projectionMatrix).multiplyRight(opts.viewMatrix);
   }
   return uniforms;
 }