@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.6

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

@@ -0,0 +1,115 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lighting_wgsl_exports = {};
+__export(lighting_wgsl_exports, {
+  lightingUniformsWGSL: () => lightingUniformsWGSL
+});
+module.exports = __toCommonJS(lighting_wgsl_exports);
+const lightingUniformsWGSL = (
+  /* wgsl */
+  `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+const MAX_LIGHTS: i32 = 5;
+
+struct AmbientLight {
+  color: vec3<f32>,
+};
+
+struct PointLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  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 AreaLightUniform {
+  color: vec3f, position: vec3f, halfAxisX: vec3f, halfAxisY: vec3f, normal: vec3f, disk: i32,
+};
+
+struct lightingUniforms {
+  enabled: i32,
+  directionalLightCount: i32,
+  pointLightCount: i32,
+  spotLightCount: i32,
+  ambientColor: vec3<f32>,
+  lights: array<UniformLight, 5>,
+  areaLightCount: i32,
+  areaLights: array<AreaLightUniform, 4>,
+};
+
+@group(2) @binding(auto) var<uniform> lighting : lightingUniforms;
+
+fn lighting_getPointLight(index: i32) -> PointLight {
+  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 {
+  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);
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lightingUniformsWGSL
+});

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

@@ -0,0 +1,2 @@
+export declare const lightingUniformsWGSL = "// #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 AreaLightUniform {\n  color: vec3f, position: vec3f, halfAxisX: vec3f, halfAxisY: vec3f, normal: vec3f, disk: i32,\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  areaLightCount: i32,\n  areaLights: array<AreaLightUniform, 4>,\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";
+//# sourceMappingURL=lighting-wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lighting-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lights/lighting-wgsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB,qiFAsFhC,CAAC"}

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

@@ -0,0 +1,91 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export const lightingUniformsWGSL = /* wgsl */ `\
+// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+const MAX_LIGHTS: i32 = 5;
+
+struct AmbientLight {
+  color: vec3<f32>,
+};
+
+struct PointLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  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 AreaLightUniform {
+  color: vec3f, position: vec3f, halfAxisX: vec3f, halfAxisY: vec3f, normal: vec3f, disk: i32,
+};
+
+struct lightingUniforms {
+  enabled: i32,
+  directionalLightCount: i32,
+  pointLightCount: i32,
+  spotLightCount: i32,
+  ambientColor: vec3<f32>,
+  lights: array<UniformLight, 5>,
+  areaLightCount: i32,
+  areaLights: array<AreaLightUniform, 4>,
+};
+
+@group(2) @binding(auto) var<uniform> lighting : lightingUniforms;
+
+fn lighting_getPointLight(index: i32) -> PointLight {
+  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 {
+  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

@@ -0,0 +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,4DAA4D;AAE5D,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsF9C,CAAC"}

package/dist/modules/lighting/lights/lighting.cjs

@@ -0,0 +1,210 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lighting_exports = {};
+__export(lighting_exports, {
+  lighting: () => lighting
+});
+module.exports = __toCommonJS(lighting_exports);
+var import_area_light_types = require("../area-lighting/area-light-types.cjs");
+var import_lighting_glsl = require("./lighting-glsl.cjs");
+var import_lighting_wgsl = require("./lighting-wgsl.cjs");
+var import_normalize_byte_colors = require("../../../lib/color/normalize-byte-colors.cjs");
+const MAX_LIGHTS = 5;
+const LIGHT_UNIFORM_TYPE = {
+  color: "vec3<f32>",
+  position: "vec3<f32>",
+  direction: "vec3<f32>",
+  attenuation: "vec3<f32>",
+  coneCos: "vec2<f32>"
+};
+const lighting = {
+  props: {},
+  uniforms: {},
+  name: "lighting",
+  defines: {
+    // MAX_LIGHTS
+  },
+  uniformTypes: {
+    enabled: "i32",
+    directionalLightCount: "i32",
+    pointLightCount: "i32",
+    spotLightCount: "i32",
+    ambientColor: "vec3<f32>",
+    lights: [LIGHT_UNIFORM_TYPE, MAX_LIGHTS],
+    areaLightCount: "i32",
+    areaLights: [import_area_light_types.AREA_LIGHT_UNIFORM_TYPE, import_area_light_types.MAX_AREA_LIGHTS]
+  },
+  defaultUniforms: createDefaultLightingUniforms(),
+  bindingLayout: [{ name: "lighting", group: 2 }],
+  firstBindingSlot: 0,
+  source: import_lighting_wgsl.lightingUniformsWGSL,
+  vs: import_lighting_glsl.lightingUniformsGLSL,
+  fs: import_lighting_glsl.lightingUniformsGLSL,
+  getUniforms
+};
+function getUniforms(props, _prevUniforms = {}) {
+  props = props ? { ...props } : props;
+  const areaLights = ((props == null ? void 0 : props.lights) || []).filter((light) => light.type === "rect" || light.type === "disk");
+  if (!props) {
+    return createDefaultLightingUniforms();
+  }
+  if (props.lights) {
+    props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
+  }
+  const { useByteColors, ambientLight, pointLights, spotLights, directionalLights } = props || {};
+  const hasLights = ambientLight || pointLights && pointLights.length > 0 || spotLights && spotLights.length > 0 || directionalLights && directionalLights.length > 0;
+  if (!hasLights && areaLights.length === 0) {
+    return {
+      ...createDefaultLightingUniforms(),
+      enabled: 0
+    };
+  }
+  const uniforms = {
+    ...createDefaultLightingUniforms(),
+    ...getLightSourceUniforms({
+      useByteColors,
+      ambientLight,
+      pointLights,
+      spotLights,
+      directionalLights
+    })
+  };
+  uniforms.areaLightCount = Math.min(areaLights.length, import_area_light_types.MAX_AREA_LIGHTS);
+  uniforms.areaLights = (0, import_area_light_types.packAreaLights)(areaLights, (0, import_normalize_byte_colors.resolveUseByteColors)(props.useByteColors, true));
+  if (props.enabled !== void 0) {
+    uniforms.enabled = props.enabled ? 1 : 0;
+  }
+  return uniforms;
+}
+function getLightSourceUniforms({ useByteColors, ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
+  const lights = createDefaultLightUniforms();
+  let currentLight = 0;
+  let pointLightCount = 0;
+  let spotLightCount = 0;
+  let directionalLightCount = 0;
+  for (const pointLight of pointLights) {
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
+    lights[currentLight] = {
+      ...lights[currentLight],
+      color: convertColor(pointLight, useByteColors),
+      position: pointLight.position,
+      attenuation: pointLight.attenuation || [1, 0, 0]
+    };
+    currentLight++;
+    pointLightCount++;
+  }
+  for (const spotLight of spotLights) {
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
+    lights[currentLight] = {
+      ...lights[currentLight],
+      color: convertColor(spotLight, useByteColors),
+      position: spotLight.position,
+      direction: spotLight.direction,
+      attenuation: spotLight.attenuation || [1, 0, 0],
+      coneCos: getSpotConeCos(spotLight)
+    };
+    currentLight++;
+    spotLightCount++;
+  }
+  for (const directionalLight of directionalLights) {
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
+    lights[currentLight] = {
+      ...lights[currentLight],
+      color: convertColor(directionalLight, useByteColors),
+      direction: directionalLight.direction
+    };
+    currentLight++;
+    directionalLightCount++;
+  }
+  if (pointLights.length + spotLights.length + directionalLights.length > MAX_LIGHTS) {
+    console.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`);
+  }
+  return {
+    ambientColor: convertColor(ambientLight, useByteColors),
+    directionalLightCount,
+    pointLightCount,
+    spotLightCount,
+    lights
+  };
+}
+function extractLightTypes(lights) {
+  var _a, _b, _c;
+  const lightSources = { pointLights: [], spotLights: [], directionalLights: [] };
+  for (const light of lights || []) {
+    switch (light.type) {
+      case "ambient":
+        lightSources.ambientLight = light;
+        break;
+      case "directional":
+        (_a = lightSources.directionalLights) == null ? void 0 : _a.push(light);
+        break;
+      case "point":
+        (_b = lightSources.pointLights) == null ? void 0 : _b.push(light);
+        break;
+      case "spot":
+        (_c = lightSources.spotLights) == null ? void 0 : _c.push(light);
+        break;
+      default:
+    }
+  }
+  return lightSources;
+}
+function convertColor(colorDef = {}, useByteColors) {
+  const { color = [0, 0, 0], intensity = 1 } = colorDef;
+  const normalizedColor = (0, import_normalize_byte_colors.normalizeByteColor3)(color, (0, import_normalize_byte_colors.resolveUseByteColors)(useByteColors, true));
+  return normalizedColor.map((component) => component * intensity);
+}
+function createDefaultLightingUniforms() {
+  return {
+    enabled: 1,
+    directionalLightCount: 0,
+    pointLightCount: 0,
+    spotLightCount: 0,
+    ambientColor: [0.1, 0.1, 0.1],
+    lights: createDefaultLightUniforms(),
+    areaLightCount: 0,
+    areaLights: (0, import_area_light_types.packAreaLights)([])
+  };
+}
+function createDefaultLightUniforms() {
+  return Array.from({ length: MAX_LIGHTS }, () => createDefaultLightUniform());
+}
+function createDefaultLightUniform() {
+  return {
+    color: [1, 1, 1],
+    position: [1, 1, 2],
+    direction: [1, 1, 1],
+    attenuation: [1, 0, 0],
+    coneCos: [1, 0]
+  };
+}
+function getSpotConeCos(spotLight) {
+  const innerConeAngle = spotLight.innerConeAngle ?? 0;
+  const outerConeAngle = spotLight.outerConeAngle ?? Math.PI / 4;
+  return [Math.cos(innerConeAngle), Math.cos(outerConeAngle)];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lighting
+});

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

@@ -0,0 +1,163 @@
+import { type AreaLight, type AreaLightUniform } from "../area-lighting/area-light-types.js";
+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 | AreaLight;
+/** 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;
+    /** When true, light colors are interpreted as byte-style 0-255 values. */
+    useByteColors?: boolean;
+    /** Preferred API for supplying mixed ambient, point, spot, directional, rectangle, and disk lights. */
+    lights?: Light[];
+    /**
+     * Legacy ambient-light prop.
+     * @deprecated Use `lights` with `{type: 'ambient', ...}` entries instead.
+     */
+    ambientLight?: AmbientLight;
+    /**
+     * Legacy point-light prop.
+     * @deprecated Use `lights` with `{type: 'point', ...}` entries instead.
+     */
+    pointLights?: PointLight[];
+    /**
+     * 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;
+    /** Number of packed directional lights in the `lights` array. */
+    directionalLightCount: number;
+    /** Number of packed point lights in the `lights` array. */
+    pointLightCount: number;
+    /** 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>;
+    areaLightCount: number;
+    areaLights: readonly AreaLightUniform[];
+};
+/**
+ * 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;
+    readonly name: "lighting";
+    readonly defines: {};
+    readonly uniformTypes: {
+        readonly enabled: "i32";
+        readonly directionalLightCount: "i32";
+        readonly pointLightCount: "i32";
+        readonly spotLightCount: "i32";
+        readonly ambientColor: "vec3<f32>";
+        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 areaLightCount: "i32";
+        readonly areaLights: readonly [{
+            readonly color: "vec3<f32>";
+            readonly position: "vec3<f32>";
+            readonly halfAxisX: "vec3<f32>";
+            readonly halfAxisY: "vec3<f32>";
+            readonly normal: "vec3<f32>";
+            readonly disk: "i32";
+        }, 4];
+    };
+    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 AreaLightUniform {\n  color: vec3f, position: vec3f, halfAxisX: vec3f, halfAxisY: vec3f, normal: vec3f, disk: i32,\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  areaLightCount: i32,\n  areaLights: array<AreaLightUniform, 4>,\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\nstruct AreaLightUniform {\n  vec3 color; vec3 position; vec3 halfAxisX; vec3 halfAxisY; vec3 normal; int disk;\n};\n\nlayout(std140) uniform lightingUniforms {\n  int enabled;\n  int directionalLightCount;\n  int pointLightCount;\n  int spotLightCount;\n  vec3 ambientColor;\n  UniformLight lights[5];\n  int areaLightCount;\n  AreaLightUniform areaLights[4];\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\nstruct AreaLightUniform {\n  vec3 color; vec3 position; vec3 halfAxisX; vec3 halfAxisY; vec3 normal; int disk;\n};\n\nlayout(std140) uniform lightingUniforms {\n  int enabled;\n  int directionalLightCount;\n  int pointLightCount;\n  int spotLightCount;\n  vec3 ambientColor;\n  UniformLight lights[5];\n  int areaLightCount;\n  AreaLightUniform areaLights[4];\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;
+export {};
+//# sourceMappingURL=lighting.d.ts.map

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

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