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

package/dist/modules/lighting/lights/lighting-wgsl.js

@@ -15,93 +15,71 @@ 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);
+}
 `;
 //# sourceMappingURL=lighting-wgsl.js.map

package/dist/modules/lighting/lights/lighting-wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"lighting-wgsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-wgsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsG9C,CAAC"}
+{"version":3,"file":"lighting-wgsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-wgsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgF9C,CAAC"}

package/dist/modules/lighting/lights/lighting.d.ts

@@ -1,67 +1,119 @@
-import type { NumberArray3 } from '@math.gl/core';
-/** Shader type field for lights */
-export declare enum LIGHT_TYPE {
-    POINT = 0,
-    DIRECTIONAL = 1
-}
-/** Lighting helper types */
-export type Light = AmbientLight | PointLight | DirectionalLight;
+import type { NumberArray2, NumberArray3 } from '@math.gl/core';
+/** Supported light source descriptions accepted by the lighting shader module. */
+export type Light = AmbientLight | PointLight | SpotLight | DirectionalLight;
+/** Ambient light contribution shared across the entire scene. */
 export type AmbientLight = {
+    /** Discriminator used to identify ambient lights in `lights: Light[]`. */
     type: 'ambient';
+    /** RGB light color in the existing `0..255` convention used by luma.gl materials. */
     color?: Readonly<NumberArray3>;
+    /** Scalar intensity multiplier applied to the light color. */
     intensity?: number;
 };
+/** Omnidirectional point light emitted from a world-space position. */
 export type PointLight = {
+    /** Discriminator used to identify point lights in `lights: Light[]`. */
     type: 'point';
+    /** World-space light position. */
     position: Readonly<NumberArray3>;
+    /** RGB light color in the existing `0..255` convention used by luma.gl materials. */
     color?: Readonly<NumberArray3>;
+    /** Scalar intensity multiplier applied to the light color. */
     intensity?: number;
+    /** Constant, linear, and quadratic attenuation coefficients. */
     attenuation?: Readonly<NumberArray3>;
 };
+/** Directional light defined only by its incoming world-space direction. */
 export type DirectionalLight = {
+    /** Discriminator used to identify directional lights in `lights: Light[]`. */
     type: 'directional';
+    /** World-space light direction. */
     direction: Readonly<NumberArray3>;
+    /** RGB light color in the existing `0..255` convention used by luma.gl materials. */
     color?: Readonly<NumberArray3>;
+    /** Scalar intensity multiplier applied to the light color. */
     intensity?: number;
 };
+/** Cone-shaped light emitted from a position and focused along a direction. */
+export type SpotLight = {
+    /** Discriminator used to identify spot lights in `lights: Light[]`. */
+    type: 'spot';
+    /** World-space light position. */
+    position: Readonly<NumberArray3>;
+    /** World-space light direction. */
+    direction: Readonly<NumberArray3>;
+    /** RGB light color in the existing `0..255` convention used by luma.gl materials. */
+    color?: Readonly<NumberArray3>;
+    /** Scalar intensity multiplier applied to the light color. */
+    intensity?: number;
+    /** Constant, linear, and quadratic attenuation coefficients. */
+    attenuation?: Readonly<NumberArray3>;
+    /** Inner spotlight cone angle in radians. */
+    innerConeAngle?: number;
+    /** Outer spotlight cone angle in radians. */
+    outerConeAngle?: number;
+};
+/** Public JavaScript props accepted by the `lighting` shader module. */
 export type LightingProps = {
+    /** Enables or disables lighting calculations for the module. */
     enabled?: boolean;
+    /** Preferred API for supplying mixed ambient, point, spot, and directional lights. */
     lights?: Light[];
-    /** @deprecated */
+    /**
+     * Legacy ambient-light prop.
+     * @deprecated Use `lights` with `{type: 'ambient', ...}` entries instead.
+     */
     ambientLight?: AmbientLight;
-    /** @deprecated */
+    /**
+     * Legacy point-light prop.
+     * @deprecated Use `lights` with `{type: 'point', ...}` entries instead.
+     */
     pointLights?: PointLight[];
-    /** @deprecated */
+    /**
+     * Legacy spot-light prop.
+     * @deprecated Use `lights` with `{type: 'spot', ...}` entries instead.
+     */
+    spotLights?: SpotLight[];
+    /**
+     * Legacy directional-light prop.
+     * @deprecated Use `lights` with `{type: 'directional', ...}` entries instead.
+     */
     directionalLights?: DirectionalLight[];
 };
+/** Packed per-light data written into the module's fixed-size uniform array. */
+export type LightingLightUniform = {
+    /** Light color converted to normalized shader-space RGB. */
+    color: Readonly<NumberArray3>;
+    /** World-space light position or a default placeholder for non-positional lights. */
+    position: Readonly<NumberArray3>;
+    /** World-space light direction or a default placeholder for positional lights. */
+    direction: Readonly<NumberArray3>;
+    /** Constant, linear, and quadratic attenuation coefficients. */
+    attenuation: Readonly<NumberArray3>;
+    /** Cosines of the inner and outer spotlight cone angles. */
+    coneCos: Readonly<NumberArray2>;
+};
+/** Fully normalized uniform values produced by the `lighting` shader module. */
 export type LightingUniforms = {
+    /** `1` when lighting is enabled, otherwise `0`. */
     enabled: number;
-    ambientColor: Readonly<NumberArray3>;
+    /** Number of packed directional lights in the `lights` array. */
     directionalLightCount: number;
+    /** Number of packed point lights in the `lights` array. */
     pointLightCount: number;
-    lightType: number;
-    lightColor0: Readonly<NumberArray3>;
-    lightPosition0: Readonly<NumberArray3>;
-    lightDirection0: Readonly<NumberArray3>;
-    lightAttenuation0: Readonly<NumberArray3>;
-    lightColor1: Readonly<NumberArray3>;
-    lightPosition1: Readonly<NumberArray3>;
-    lightDirection1: Readonly<NumberArray3>;
-    lightAttenuation1: Readonly<NumberArray3>;
-    lightColor2: Readonly<NumberArray3>;
-    lightPosition2: Readonly<NumberArray3>;
-    lightDirection2: Readonly<NumberArray3>;
-    lightAttenuation2: Readonly<NumberArray3>;
-    lightColor3: Readonly<NumberArray3>;
-    lightPosition3: Readonly<NumberArray3>;
-    lightDirection3: Readonly<NumberArray3>;
-    lightAttenuation3: Readonly<NumberArray3>;
-    lightColor4: Readonly<NumberArray3>;
-    lightPosition4: Readonly<NumberArray3>;
-    lightDirection4: Readonly<NumberArray3>;
-    lightAttenuation4: Readonly<NumberArray3>;
+    /** Number of packed spot lights in the `lights` array. */
+    spotLightCount: number;
+    /** Accumulated ambient color converted to normalized shader-space RGB. */
+    ambientColor: Readonly<NumberArray3>;
+    /** Packed trailing array of non-ambient light structs. */
+    lights: ReadonlyArray<LightingLightUniform>;
 };
-/** UBO ready lighting module */
+/**
+ * Portable lighting shader module shared by the Phong, Gouraud, and PBR material modules.
+ *
+ * The public JavaScript API accepts `lights: Light[]`, while the uniform buffer packs
+ * non-ambient lights into a fixed-size trailing array for portability across WebGL2 and WebGPU.
+ */
 export declare const lighting: {
     readonly props: LightingProps;
     readonly uniforms: LightingUniforms;
@@ -69,63 +121,29 @@ export declare const lighting: {
     readonly defines: {};
     readonly uniformTypes: {
         readonly enabled: "i32";
-        readonly lightType: "i32";
         readonly directionalLightCount: "i32";
         readonly pointLightCount: "i32";
+        readonly spotLightCount: "i32";
         readonly ambientColor: "vec3<f32>";
-        readonly lightColor0: "vec3<f32>";
-        readonly lightPosition0: "vec3<f32>";
-        readonly lightDirection0: "vec3<f32>";
-        readonly lightAttenuation0: "vec3<f32>";
-        readonly lightColor1: "vec3<f32>";
-        readonly lightPosition1: "vec3<f32>";
-        readonly lightDirection1: "vec3<f32>";
-        readonly lightAttenuation1: "vec3<f32>";
-        readonly lightColor2: "vec3<f32>";
-        readonly lightPosition2: "vec3<f32>";
-        readonly lightDirection2: "vec3<f32>";
-        readonly lightAttenuation2: "vec3<f32>";
-        readonly lightColor3: "vec3<f32>";
-        readonly lightPosition3: "vec3<f32>";
-        readonly lightDirection3: "vec3<f32>";
-        readonly lightAttenuation3: "vec3<f32>";
-        readonly lightColor4: "vec3<f32>";
-        readonly lightPosition4: "vec3<f32>";
-        readonly lightDirection4: "vec3<f32>";
-        readonly lightAttenuation4: "vec3<f32>";
-    };
-    readonly defaultUniforms: {
-        readonly enabled: 1;
-        readonly lightType: LIGHT_TYPE.POINT;
-        readonly directionalLightCount: 0;
-        readonly pointLightCount: 0;
-        readonly ambientColor: readonly [0.1, 0.1, 0.1];
-        readonly lightColor0: readonly [1, 1, 1];
-        readonly lightPosition0: readonly [1, 1, 2];
-        readonly lightDirection0: readonly [1, 1, 1];
-        readonly lightAttenuation0: readonly [1, 0, 0];
-        readonly lightColor1: readonly [1, 1, 1];
-        readonly lightPosition1: readonly [1, 1, 2];
-        readonly lightDirection1: readonly [1, 1, 1];
-        readonly lightAttenuation1: readonly [1, 0, 0];
-        readonly lightColor2: readonly [1, 1, 1];
-        readonly lightPosition2: readonly [1, 1, 2];
-        readonly lightDirection2: readonly [1, 1, 1];
-        readonly lightAttenuation2: readonly [1, 0, 0];
-        readonly lightColor3: readonly [1, 1, 1];
-        readonly lightPosition3: readonly [1, 1, 2];
-        readonly lightDirection3: readonly [1, 1, 1];
-        readonly lightAttenuation3: readonly [1, 0, 0];
-        readonly lightColor4: readonly [1, 1, 1];
-        readonly lightPosition4: readonly [1, 1, 2];
-        readonly lightDirection4: readonly [1, 1, 1];
-        readonly lightAttenuation4: readonly [1, 0, 0];
+        readonly lights: readonly [{
+            readonly color: "vec3<f32>";
+            readonly position: "vec3<f32>";
+            readonly direction: "vec3<f32>";
+            readonly attenuation: "vec3<f32>";
+            readonly coneCos: "vec2<f32>";
+        }, 5];
     };
-    readonly source: "// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nconst MAX_LIGHTS: i32 = 5;\n\nstruct AmbientLight {\n  color: vec3<f32>,\n};\n\nstruct PointLight {\n  color: vec3<f32>,\n  position: vec3<f32>,\n  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct DirectionalLight {\n  color: vec3<f32>,\n  direction: vec3<f32>,\n};\n\nstruct lightingUniforms {\n  enabled: i32,\n  lightType: i32,\n\n  directionalLightCount: i32,\n  pointLightCount: i32,\n\n  ambientColor: vec3<f32>,\n\n  lightColor0: vec3<f32>,\n  lightPosition0: vec3<f32>,\n  lightDirection0: vec3<f32>,\n  lightAttenuation0: vec3<f32>,\n\n  lightColor1: vec3<f32>,\n  lightPosition1: vec3<f32>,\n  lightDirection1: vec3<f32>,\n  lightAttenuation1: vec3<f32>,\n\n  lightColor2: vec3<f32>,\n  lightPosition2: vec3<f32>,\n  lightDirection2: vec3<f32>,\n  lightAttenuation2: vec3<f32>,\n\n  lightColor3: vec3<f32>,\n  lightPosition3: vec3<f32>,\n  lightDirection3: vec3<f32>,\n  lightAttenuation3: vec3<f32>,\n\n  lightColor4: vec3<f32>,\n  lightPosition4: vec3<f32>,\n  lightDirection4: vec3<f32>,\n  lightAttenuation4: vec3<f32>,\n};\n\n// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)\n@binding(1) @group(0) var<uniform> lighting : lightingUniforms;\n\nfn lighting_getPointLight(index: i32) -> PointLight {\n  switch (index) {\n    case 0: {\n      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);\n    }\n    case 1: {\n      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);\n    }\n    case 2: {\n      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);\n    }\n    case 3: {\n      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);\n    }\n    case 4, default: {\n      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);\n    }\n  }\n}\n\nfn lighting_getDirectionalLight(index: i32) -> DirectionalLight {\n  switch (index) {\n    case 0: {\n      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);\n    }\n    case 1: {\n      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);\n    }\n    case 2: {\n      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);\n    }\n    case 3: {\n      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);\n    }\n    case 4, default: {\n      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);\n    }\n  }\n} \n\nfn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n";
-    readonly vs: "precision highp int;\n\n// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  vec3 color;\n};\n\nstruct PointLight {\n  vec3 color;\n  vec3 position;\n  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform lightingUniforms {\n  int enabled;\n  int lightType;\n\n  int directionalLightCount;\n  int pointLightCount;\n\n  vec3 ambientColor;\n\n  vec3 lightColor0;\n  vec3 lightPosition0;\n  vec3 lightDirection0;\n  vec3 lightAttenuation0;\n\n  vec3 lightColor1;\n  vec3 lightPosition1;\n  vec3 lightDirection1;\n  vec3 lightAttenuation1;\n\n  vec3 lightColor2;\n  vec3 lightPosition2;\n  vec3 lightDirection2;\n  vec3 lightAttenuation2;\n\n  vec3 lightColor3;\n  vec3 lightPosition3;\n  vec3 lightDirection3;\n  vec3 lightAttenuation3;\n\n  vec3 lightColor4;\n  vec3 lightPosition4;\n  vec3 lightDirection4;\n  vec3 lightAttenuation4;\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  switch (index) {\n    case 0:\n      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);\n    case 1:\n      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);\n    case 2:\n      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);\n    case 3:\n      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);\n    case 4:\n    default:  \n      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);\n  }\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  switch (index) {\n    case 0:\n      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);\n    case 1:\n      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);\n    case 2:\n      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);\n    case 3:\n      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);\n    case 4:\n    default:   \n      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);\n  }\n} \n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n// #endif\n";
-    readonly fs: "precision highp int;\n\n// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  vec3 color;\n};\n\nstruct PointLight {\n  vec3 color;\n  vec3 position;\n  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform lightingUniforms {\n  int enabled;\n  int lightType;\n\n  int directionalLightCount;\n  int pointLightCount;\n\n  vec3 ambientColor;\n\n  vec3 lightColor0;\n  vec3 lightPosition0;\n  vec3 lightDirection0;\n  vec3 lightAttenuation0;\n\n  vec3 lightColor1;\n  vec3 lightPosition1;\n  vec3 lightDirection1;\n  vec3 lightAttenuation1;\n\n  vec3 lightColor2;\n  vec3 lightPosition2;\n  vec3 lightDirection2;\n  vec3 lightAttenuation2;\n\n  vec3 lightColor3;\n  vec3 lightPosition3;\n  vec3 lightDirection3;\n  vec3 lightAttenuation3;\n\n  vec3 lightColor4;\n  vec3 lightPosition4;\n  vec3 lightDirection4;\n  vec3 lightAttenuation4;\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  switch (index) {\n    case 0:\n      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);\n    case 1:\n      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);\n    case 2:\n      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);\n    case 3:\n      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);\n    case 4:\n    default:  \n      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);\n  }\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  switch (index) {\n    case 0:\n      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);\n    case 1:\n      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);\n    case 2:\n      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);\n    case 3:\n      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);\n    case 4:\n    default:   \n      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);\n  }\n} \n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n// #endif\n";
+    readonly defaultUniforms: LightingUniforms;
+    readonly bindingLayout: readonly [{
+        readonly name: "lighting";
+        readonly group: 2;
+    }];
+    readonly firstBindingSlot: 0;
+    readonly source: "// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nconst MAX_LIGHTS: i32 = 5;\n\nstruct AmbientLight {\n  color: vec3<f32>,\n};\n\nstruct PointLight {\n  color: vec3<f32>,\n  position: vec3<f32>,\n  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct SpotLight {\n  color: vec3<f32>,\n  position: vec3<f32>,\n  direction: vec3<f32>,\n  attenuation: vec3<f32>,\n  coneCos: vec2<f32>,\n};\n\nstruct DirectionalLight {\n  color: vec3<f32>,\n  direction: vec3<f32>,\n};\n\nstruct UniformLight {\n  color: vec3<f32>,\n  position: vec3<f32>,\n  direction: vec3<f32>,\n  attenuation: vec3<f32>,\n  coneCos: vec2<f32>,\n};\n\nstruct lightingUniforms {\n  enabled: i32,\n  directionalLightCount: i32,\n  pointLightCount: i32,\n  spotLightCount: i32,\n  ambientColor: vec3<f32>,\n  lights: array<UniformLight, 5>,\n};\n\n@group(2) @binding(auto) var<uniform> lighting : lightingUniforms;\n\nfn lighting_getPointLight(index: i32) -> PointLight {\n  let light = lighting.lights[index];\n  return PointLight(light.color, light.position, light.attenuation);\n}\n\nfn lighting_getSpotLight(index: i32) -> SpotLight {\n  let light = lighting.lights[lighting.pointLightCount + index];\n  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);\n}\n\nfn lighting_getDirectionalLight(index: i32) -> DirectionalLight {\n  let light = lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];\n  return DirectionalLight(light.color, light.direction);\n}\n\nfn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\nfn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>) -> f32 {\n  let lightDirection = normalize(positionWorldspace - spotLight.position);\n  let coneFactor = smoothstep(\n    spotLight.coneCos.y,\n    spotLight.coneCos.x,\n    dot(normalize(spotLight.direction), lightDirection)\n  );\n  let distanceAttenuation = getPointLightAttenuation(\n    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),\n    distance(spotLight.position, positionWorldspace)\n  );\n  return distanceAttenuation / max(coneFactor, 0.0001);\n}\n";
+    readonly vs: "precision highp int;\n\n// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  vec3 color;\n};\n\nstruct PointLight {\n  vec3 color;\n  vec3 position;\n  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct SpotLight {\n  vec3 color;\n  vec3 position;\n  vec3 direction;\n  vec3 attenuation;\n  vec2 coneCos;\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nstruct UniformLight {\n  vec3 color;\n  vec3 position;\n  vec3 direction;\n  vec3 attenuation;\n  vec2 coneCos;\n};\n\nuniform lightingUniforms {\n  int enabled;\n  int directionalLightCount;\n  int pointLightCount;\n  int spotLightCount;\n  vec3 ambientColor;\n  UniformLight lights[5];\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  UniformLight light = lighting.lights[index];\n  return PointLight(light.color, light.position, light.attenuation);\n}\n\nSpotLight lighting_getSpotLight(int index) {\n  UniformLight light = lighting.lights[lighting.pointLightCount + index];\n  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  UniformLight light =\n    lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];\n  return DirectionalLight(light.color, light.direction);\n}\n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\nfloat getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {\n  vec3 light_direction = normalize(positionWorldspace - spotLight.position);\n  float coneFactor = smoothstep(\n    spotLight.coneCos.y,\n    spotLight.coneCos.x,\n    dot(normalize(spotLight.direction), light_direction)\n  );\n  float distanceAttenuation = getPointLightAttenuation(\n    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),\n    distance(spotLight.position, positionWorldspace)\n  );\n  return distanceAttenuation / max(coneFactor, 0.0001);\n}\n\n// #endif\n";
+    readonly fs: "precision highp int;\n\n// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\nstruct AmbientLight {\n  vec3 color;\n};\n\nstruct PointLight {\n  vec3 color;\n  vec3 position;\n  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential\n};\n\nstruct SpotLight {\n  vec3 color;\n  vec3 position;\n  vec3 direction;\n  vec3 attenuation;\n  vec2 coneCos;\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nstruct UniformLight {\n  vec3 color;\n  vec3 position;\n  vec3 direction;\n  vec3 attenuation;\n  vec2 coneCos;\n};\n\nuniform lightingUniforms {\n  int enabled;\n  int directionalLightCount;\n  int pointLightCount;\n  int spotLightCount;\n  vec3 ambientColor;\n  UniformLight lights[5];\n} lighting;\n\nPointLight lighting_getPointLight(int index) {\n  UniformLight light = lighting.lights[index];\n  return PointLight(light.color, light.position, light.attenuation);\n}\n\nSpotLight lighting_getSpotLight(int index) {\n  UniformLight light = lighting.lights[lighting.pointLightCount + index];\n  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);\n}\n\nDirectionalLight lighting_getDirectionalLight(int index) {\n  UniformLight light =\n    lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];\n  return DirectionalLight(light.color, light.direction);\n}\n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\nfloat getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {\n  vec3 light_direction = normalize(positionWorldspace - spotLight.position);\n  float coneFactor = smoothstep(\n    spotLight.coneCos.y,\n    spotLight.coneCos.x,\n    dot(normalize(spotLight.direction), light_direction)\n  );\n  float distanceAttenuation = getPointLightAttenuation(\n    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),\n    distance(spotLight.position, positionWorldspace)\n  );\n  return distanceAttenuation / max(coneFactor, 0.0001);\n}\n\n// #endif\n";
     readonly getUniforms: typeof getUniforms;
 };
-declare function getUniforms(props?: LightingProps, prevUniforms?: Partial<LightingUniforms>): LightingUniforms;
+declare function getUniforms(props?: LightingProps, _prevUniforms?: Partial<LightingUniforms>): LightingUniforms;
 export {};
 //# sourceMappingURL=lighting.d.ts.map

package/dist/modules/lighting/lights/lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lighting.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lighting.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting.ts"],"names":[],"mappings":"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"}