@luma.gl/shadertools 9.3.0-alpha.6 → 9.3.0-alpha.8

package/src/modules/lighting/lights/lighting-glsl.ts

@@ -16,77 +16,51 @@ struct PointLight {
   vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 struct DirectionalLight {
   vec3 color;
   vec3 direction;
 };
 
+struct UniformLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 uniform lightingUniforms {
   int enabled;
-  int lightType;
-
   int directionalLightCount;
   int pointLightCount;
-
+  int spotLightCount;
   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;
-
-  vec3 lightColor3;
-  vec3 lightPosition3;
-  vec3 lightDirection3;
-  vec3 lightAttenuation3;
-
-  vec3 lightColor4;
-  vec3 lightPosition4;
-  vec3 lightDirection4;
-  vec3 lightAttenuation4;
+  UniformLight lights[5];
 } 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:
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
-    case 3:
-      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
-    case 4:
-    default:  
-      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
-  }
+  UniformLight light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+SpotLight lighting_getSpotLight(int index) {
+  UniformLight light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
 }
 
 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:
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-    case 3:
-      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
-    case 4:
-    default:   
-      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
-  }
-} 
+  UniformLight light =
+    lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {
   return pointLight.attenuation.x
@@ -94,5 +68,19 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
        + pointLight.attenuation.z * distance * distance;
 }
 
+float getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {
+  vec3 light_direction = normalize(positionWorldspace - spotLight.position);
+  float coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), light_direction)
+  );
+  float distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
+
 // #endif
 `;

package/src/modules/lighting/lights/lighting-wgsl.ts

@@ -16,92 +16,70 @@ struct PointLight {
   attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct DirectionalLight {
   color: vec3<f32>,
   direction: vec3<f32>,
 };
 
+struct UniformLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct lightingUniforms {
   enabled: i32,
-  lightType: i32,
-
   directionalLightCount: i32,
   pointLightCount: i32,
-
+  spotLightCount: i32,
   ambientColor: vec3<f32>,
-
-  lightColor0: vec3<f32>,
-  lightPosition0: vec3<f32>,
-  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>,
-
-  lightColor3: vec3<f32>,
-  lightPosition3: vec3<f32>,
-  lightDirection3: vec3<f32>,
-  lightAttenuation3: vec3<f32>,
-
-  lightColor4: vec3<f32>,
-  lightPosition4: vec3<f32>,
-  lightDirection4: vec3<f32>,
-  lightAttenuation4: vec3<f32>,
+  lights: array<UniformLight, 5>,
 };
 
-// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
-@binding(1) @group(0) var<uniform> lighting : lightingUniforms;
+@group(2) @binding(auto) var<uniform> lighting : lightingUniforms;
 
 fn lighting_getPointLight(index: i32) -> PointLight {
-  switch (index) {
-    case 0: {
-      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
-    }
-    case 1: {
-      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
-    }
-    case 2: {
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
-    }
-    case 3: {
-      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
-    }
-    case 4, default: {
-      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
-    }
-  }
+  let light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+fn lighting_getSpotLight(index: i32) -> SpotLight {
+  let light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
 }
 
 fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
-  switch (index) {
-    case 0: {
-      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
-    }
-    case 1: {
-      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
-    }
-    case 2: {
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-    }
-    case 3: {
-      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
-    }
-    case 4, default: {
-      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
-    }
-  }
-} 
+  let light = lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
   return pointLight.attenuation.x
        + pointLight.attenuation.y * distance
        + pointLight.attenuation.z * distance * distance;
 }
+
+fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>) -> f32 {
+  let lightDirection = normalize(positionWorldspace - spotLight.position);
+  let coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), lightDirection)
+  );
+  let distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
 `;