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

package/dist/modules/lighting/area-lighting/area-lighting.cjs

@@ -0,0 +1,62 @@
+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 area_lighting_exports = {};
+__export(area_lighting_exports, {
+  areaLighting: () => areaLighting
+});
+module.exports = __toCommonJS(area_lighting_exports);
+var import_lighting = require("../lights/lighting.cjs");
+var import_ltc_shaders = require("./ltc-shaders.cjs");
+var import_area_lighting_shaders = require("./area-lighting-shaders.cjs");
+var import_area_light_types = require("./area-light-types.cjs");
+const areaLighting = {
+  name: "areaLighting",
+  props: {},
+  uniforms: {},
+  dependencies: [import_lighting.lighting],
+  defaultUniforms: {
+    lightCount: 0,
+    sampleCount: 64,
+    lights: Array.from({ length: import_area_light_types.MAX_AREA_LIGHTS }, import_area_light_types.makeEmptyLight)
+  },
+  uniformTypes: {
+    lightCount: "i32",
+    sampleCount: "i32",
+    lights: [import_area_light_types.AREA_LIGHT_UNIFORM_TYPE, import_area_light_types.MAX_AREA_LIGHTS]
+  },
+  bindingLayout: [
+    { name: "areaLighting", group: 2 },
+    { name: "areaLTCMatrix", group: 2 },
+    { name: "areaLTCAmplitude", group: 2 }
+  ],
+  source: import_area_lighting_shaders.areaLightingWGSL + import_ltc_shaders.areaLTCWGSL,
+  vs: import_area_lighting_shaders.areaLightingGLSL + import_ltc_shaders.areaLTCGLSL,
+  fs: import_area_lighting_shaders.areaLightingGLSL + import_ltc_shaders.areaLTCGLSL,
+  getUniforms(props = {}) {
+    const source = props.lights || [];
+    return {
+      lightCount: Math.min(source.length, import_area_light_types.MAX_AREA_LIGHTS),
+      sampleCount: props.sampleCount || 64,
+      lights: (0, import_area_light_types.packAreaLights)(source, props.useByteColors)
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  areaLighting
+});

package/dist/modules/lighting/area-lighting/area-lighting.d.ts

@@ -0,0 +1,89 @@
+export type { AreaLight } from "./area-light-types.js";
+import { type AreaLight, type AreaLightUniform } from "./area-light-types.js";
+export type AreaLightingProps = {
+    lights?: readonly AreaLight[];
+    useByteColors?: boolean;
+    sampleCount?: 16 | 64 | 256;
+};
+type AreaLightingUniforms = {
+    lightCount: number;
+    sampleCount: number;
+    lights: readonly AreaLightUniform[];
+};
+/** Area-light compatibility props and shader resources for LTC or numerical reference integration. */
+export declare const areaLighting: {
+    readonly name: "areaLighting";
+    readonly props: AreaLightingProps;
+    readonly uniforms: AreaLightingUniforms;
+    readonly dependencies: [{
+        readonly props: import("../lights/lighting").LightingProps;
+        readonly uniforms: import("../lights/lighting").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: import("../lights/lighting").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: (props?: import("../lights/lighting").LightingProps, _prevUniforms?: Partial<import("../lights/lighting").LightingUniforms>) => import("../lights/lighting").LightingUniforms;
+    }];
+    readonly defaultUniforms: {
+        readonly lightCount: 0;
+        readonly sampleCount: 64;
+        readonly lights: AreaLightUniform[];
+    };
+    readonly uniformTypes: {
+        readonly lightCount: "i32";
+        readonly sampleCount: "i32";
+        readonly lights: 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 bindingLayout: readonly [{
+        readonly name: "areaLighting";
+        readonly group: 2;
+    }, {
+        readonly name: "areaLTCMatrix";
+        readonly group: 2;
+    }, {
+        readonly name: "areaLTCAmplitude";
+        readonly group: 2;
+    }];
+    readonly source: string;
+    readonly vs: string;
+    readonly fs: string;
+    readonly getUniforms: (props?: AreaLightingProps) => AreaLightingUniforms;
+};
+//# sourceMappingURL=area-lighting.d.ts.map

package/dist/modules/lighting/area-lighting/area-lighting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"area-lighting.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/area-lighting/area-lighting.ts"],"names":[],"mappings":"AASA,YAAY,EAAC,SAAS,EAAC,8BAA2B;AAClD,OAAO,EACL,KAAK,SAAS,EACd,KAAK,gBAAgB,EAKtB,8BAA2B;AAE5B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;CAC7B,CAAC;AACF,KAAK,oBAAoB,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACrC,CAAC;AAEF,sGAAsG;AACtG,eAAO,MAAM,YAAY;;oBAEV,iBAAiB;uBACd,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAoBjB,iBAAiB,KAAQ,oBAAoB;CAQY,CAAC"}

package/dist/modules/lighting/area-lighting/area-lighting.js

@@ -0,0 +1,41 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { lighting } from "../lights/lighting.js";
+import { areaLTCGLSL, areaLTCWGSL } from "./ltc-shaders.js";
+import { areaLightingGLSL, areaLightingWGSL } from "./area-lighting-shaders.js";
+import { MAX_AREA_LIGHTS, AREA_LIGHT_UNIFORM_TYPE, packAreaLights, makeEmptyLight } from "./area-light-types.js";
+/** Area-light compatibility props and shader resources for LTC or numerical reference integration. */
+export const areaLighting = {
+    name: 'areaLighting',
+    props: {},
+    uniforms: {},
+    dependencies: [lighting],
+    defaultUniforms: {
+        lightCount: 0,
+        sampleCount: 64,
+        lights: Array.from({ length: MAX_AREA_LIGHTS }, makeEmptyLight)
+    },
+    uniformTypes: {
+        lightCount: 'i32',
+        sampleCount: 'i32',
+        lights: [AREA_LIGHT_UNIFORM_TYPE, MAX_AREA_LIGHTS]
+    },
+    bindingLayout: [
+        { name: 'areaLighting', group: 2 },
+        { name: 'areaLTCMatrix', group: 2 },
+        { name: 'areaLTCAmplitude', group: 2 }
+    ],
+    source: areaLightingWGSL + areaLTCWGSL,
+    vs: areaLightingGLSL + areaLTCGLSL,
+    fs: areaLightingGLSL + areaLTCGLSL,
+    getUniforms(props = {}) {
+        const source = props.lights || [];
+        return {
+            lightCount: Math.min(source.length, MAX_AREA_LIGHTS),
+            sampleCount: props.sampleCount || 64,
+            lights: packAreaLights(source, props.useByteColors)
+        };
+    }
+};
+//# sourceMappingURL=area-lighting.js.map

package/dist/modules/lighting/area-lighting/area-lighting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"area-lighting.js","sourceRoot":"","sources":["../../../../src/modules/lighting/area-lighting/area-lighting.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAG5D,OAAO,EAAC,QAAQ,EAAC,8BAA2B;AAC5C,OAAO,EAAC,WAAW,EAAE,WAAW,EAAC,yBAAsB;AACvD,OAAO,EAAC,gBAAgB,EAAE,gBAAgB,EAAC,mCAAgC;AAG3E,OAAO,EAGL,eAAe,EACf,uBAAuB,EACvB,cAAc,EACd,cAAc,EACf,8BAA2B;AAa5B,sGAAsG;AACtG,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,KAAK,EAAE,EAAuB;IAC9B,QAAQ,EAAE,EAA0B;IACpC,YAAY,EAAE,CAAC,QAAQ,CAAC;IACxB,eAAe,EAAE;QACf,UAAU,EAAE,CAAC;QACb,WAAW,EAAE,EAAE;QACf,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,EAAC,MAAM,EAAE,eAAe,EAAC,EAAE,cAAc,CAAC;KAC9D;IACD,YAAY,EAAE;QACZ,UAAU,EAAE,KAAK;QACjB,WAAW,EAAE,KAAK;QAClB,MAAM,EAAE,CAAC,uBAAuB,EAAE,eAAe,CAAC;KACnD;IACD,aAAa,EAAE;QACb,EAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,EAAC;QAChC,EAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,EAAC;QACjC,EAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC,EAAC;KACrC;IACD,MAAM,EAAE,gBAAgB,GAAG,WAAW;IACtC,EAAE,EAAE,gBAAgB,GAAG,WAAW;IAClC,EAAE,EAAE,gBAAgB,GAAG,WAAW;IAClC,WAAW,CAAC,QAA2B,EAAE;QACvC,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC;QAClC,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;YACpD,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,EAAE;YACpC,MAAM,EAAE,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC;SACpD,CAAC;IACJ,CAAC;CAC2E,CAAC"}

package/dist/modules/lighting/area-lighting/ltc-shaders.cjs

@@ -0,0 +1,192 @@
+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 ltc_shaders_exports = {};
+__export(ltc_shaders_exports, {
+  areaLTCGLSL: () => areaLTCGLSL,
+  areaLTCWGSL: () => areaLTCWGSL
+});
+module.exports = __toCommonJS(ltc_shaders_exports);
+const areaLTCGLSL = (
+  /* glsl */
+  `
+#ifdef USE_AREA_LIGHT_LTC
+uniform sampler2D areaLTCMatrix;
+uniform sampler2D areaLTCAmplitude;
+// GGX fit and Fresnel decomposition: Heitz, Dupuy, Hill and Neubelt, SIGGRAPH 2016.
+// Explicit bilinear lookup avoids requiring filterable float32 textures on WebGPU.
+vec4 areaLTC_lookup(sampler2D table, vec2 coordinate) {
+  vec2 position = clamp(coordinate, 0.0, 1.0) * 63.0;
+  ivec2 lower = ivec2(floor(position));
+  ivec2 upper = min(lower + ivec2(1), ivec2(63));
+  vec2 fraction = fract(position);
+  return mix(mix(texelFetch(table, lower, 0), texelFetch(table, ivec2(upper.x, lower.y), 0), fraction.x),
+             mix(texelFetch(table, ivec2(lower.x, upper.y), 0), texelFetch(table, upper, 0), fraction.x), fraction.y);
+}
+
+// Exact horizon clipping followed by the spherical polygon edge integral.
+// Disk support uses an inscribed 32-gon; the area error is below 0.65 percent.
+float areaLTC_integral(AreaLightUniform light, vec3 receiver, vec3 normal, vec3 view, mat3 inverseTransform) {
+  if (dot(light.normal, receiver - light.position) <= 0.0) return 0.0;
+  vec3 tangent = view - normal * dot(view, normal);
+  if (dot(tangent, tangent) < 1e-8) {
+    vec3 axis = abs(normal.z) < 0.9 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+    tangent = cross(axis, normal);
+  }
+  tangent = normalize(tangent);
+  mat3 transform = inverseTransform * transpose(mat3(tangent, -cross(normal, tangent), normal));
+  vec3 vertices[33];
+  int count = light.disk != 0 ? 32 : 4;
+  for (int index = 0; index < 32; index++) {
+    if (index >= count) break;
+    vec2 coordinate;
+    if (light.disk != 0) {
+      float angle = float(index) * 6.28318530718 / 32.0;
+      coordinate = vec2(cos(angle), -sin(angle));
+    } else {
+      coordinate = index == 0 ? vec2(1.0, -1.0) : index == 1 ? vec2(-1.0, -1.0) : index == 2 ? vec2(-1.0, 1.0) : vec2(1.0, 1.0);
+    }
+    vertices[index] = transform * (light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY - receiver);
+  }
+  vec3 clipped[34];
+  int clippedCount = 0;
+  for (int index = 0; index < 32; index++) {
+    if (index >= count) break;
+    vec3 start = vertices[index];
+    vec3 end = vertices[(index + 1) % count];
+    if (start.z > 0.0) { clipped[clippedCount] = start; clippedCount++; }
+    if ((start.z > 0.0) != (end.z > 0.0)) {
+      clipped[clippedCount] = mix(start, end, start.z / (start.z - end.z));
+      clippedCount++;
+    }
+  }
+  if (clippedCount < 3) return 0.0;
+  vec3 integral = vec3(0.0);
+  for (int index = 0; index < 34; index++) {
+    if (index >= clippedCount) break;
+    vec3 start = normalize(clipped[index]);
+    vec3 end = normalize(clipped[(index + 1) % clippedCount]);
+    vec3 edge = cross(start, end);
+    float sine = length(edge);
+    if (sine > 1e-7) integral += edge * (acos(clamp(dot(start, end), -1.0, 1.0)) / sine);
+  }
+  return min(abs(integral.z) / 6.28318530718, 1.0);
+}
+
+vec3 areaLTC_specular(AreaLightUniform light, vec3 receiver, vec3 normal, vec3 view, float roughness, vec3 reflectance0, vec3 reflectance90) {
+  vec2 coordinate = vec2(roughness, sqrt(1.0 - clamp(dot(normal, view), 0.0, 1.0)));
+  vec4 coefficients = areaLTC_lookup(areaLTCMatrix, coordinate);
+  vec4 amplitude = areaLTC_lookup(areaLTCAmplitude, coordinate);
+  mat3 inverseTransform = mat3(vec3(coefficients.x, 0.0, coefficients.y), vec3(0.0, 1.0, 0.0), vec3(coefficients.z, 0.0, coefficients.w));
+  vec3 fresnel = reflectance0 * amplitude.x + (reflectance90 - reflectance0) * amplitude.y;
+  return light.color * fresnel * areaLTC_integral(light, receiver, normal, view, inverseTransform);
+}
+
+vec3 areaLTC_evaluate(int index, vec3 receiver, vec3 normal, vec3 view, float roughness, vec3 diffuseColor, vec3 reflectance0, vec3 reflectance90) {
+  AreaLightUniform light = areaLighting_getLight(index);
+  float diffuseIntegral = areaLTC_integral(light, receiver, normal, view, mat3(1.0));
+  return light.color * diffuseColor * (vec3(1.0) - reflectance0) * diffuseIntegral +
+    areaLTC_specular(light, receiver, normal, view, roughness, reflectance0, reflectance90);
+}
+#endif
+`
+);
+const areaLTCWGSL = (
+  /* wgsl */
+  `
+#ifdef USE_AREA_LIGHT_LTC
+@group(2) @binding(auto) var areaLTCMatrix: texture_2d<f32>;
+@group(2) @binding(auto) var areaLTCAmplitude: texture_2d<f32>;
+fn areaLTC_lookup(table: texture_2d<f32>, coordinate: vec2f) -> vec4f {
+  let position = clamp(coordinate, vec2f(0.0), vec2f(1.0)) * 63.0;
+  let lower = vec2i(floor(position));
+  let upper = min(lower + vec2i(1), vec2i(63));
+  let fraction = fract(position);
+  return mix(mix(textureLoad(table, lower, 0), textureLoad(table, vec2i(upper.x, lower.y), 0), fraction.x),
+             mix(textureLoad(table, vec2i(lower.x, upper.y), 0), textureLoad(table, upper, 0), fraction.x), fraction.y);
+}
+fn areaLTC_integral(light: AreaLightUniform, receiver: vec3f, normal: vec3f, view: vec3f, inverseTransform: mat3x3f) -> f32 {
+  if (dot(light.normal, receiver - light.position) <= 0.0) { return 0.0; }
+  var tangent = view - normal * dot(view, normal);
+  if (dot(tangent, tangent) < 1e-8) {
+    let axis = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(normal.z) < 0.9);
+    tangent = cross(axis, normal);
+  }
+  tangent = normalize(tangent);
+  let transform = inverseTransform * transpose(mat3x3f(tangent, -cross(normal, tangent), normal));
+  var vertices: array<vec3f, 33>;
+  let count = select(4, 32, light.disk != 0);
+  for (var index = 0; index < 32; index++) {
+    if (index >= count) { break; }
+    var coordinate: vec2f;
+    if (light.disk != 0) {
+      let angle = f32(index) * 6.28318530718 / 32.0;
+      coordinate = vec2f(cos(angle), -sin(angle));
+    } else {
+      coordinate = vec2f(1.0, 1.0);
+      if (index == 0) { coordinate = vec2f(1.0, -1.0); }
+      if (index == 1) { coordinate = vec2f(-1.0, -1.0); }
+      if (index == 2) { coordinate = vec2f(-1.0, 1.0); }
+    }
+    vertices[index] = transform * (light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY - receiver);
+  }
+  var clipped: array<vec3f, 34>;
+  var clippedCount = 0;
+  for (var index = 0; index < 32; index++) {
+    if (index >= count) { break; }
+    let start = vertices[index];
+    let end = vertices[(index + 1) % count];
+    if (start.z > 0.0) { clipped[clippedCount] = start; clippedCount++; }
+    if ((start.z > 0.0) != (end.z > 0.0)) {
+      clipped[clippedCount] = mix(start, end, start.z / (start.z - end.z));
+      clippedCount++;
+    }
+  }
+  if (clippedCount < 3) { return 0.0; }
+  var integral = vec3f(0.0);
+  for (var index = 0; index < 34; index++) {
+    if (index >= clippedCount) { break; }
+    let start = normalize(clipped[index]);
+    let end = normalize(clipped[(index + 1) % clippedCount]);
+    let edge = cross(start, end);
+    let sine = length(edge);
+    if (sine > 1e-7) { integral += edge * (acos(clamp(dot(start, end), -1.0, 1.0)) / sine); }
+  }
+  return min(abs(integral.z) / 6.28318530718, 1.0);
+}
+fn areaLTC_specular(light: AreaLightUniform, receiver: vec3f, normal: vec3f, view: vec3f, roughness: f32, reflectance0: vec3f, reflectance90: vec3f) -> vec3f {
+  let coordinate = vec2f(roughness, sqrt(1.0 - clamp(dot(normal, view), 0.0, 1.0)));
+  let coefficients = areaLTC_lookup(areaLTCMatrix, coordinate);
+  let amplitude = areaLTC_lookup(areaLTCAmplitude, coordinate);
+  let inverseTransform = mat3x3f(vec3f(coefficients.x, 0.0, coefficients.y), vec3f(0.0, 1.0, 0.0), vec3f(coefficients.z, 0.0, coefficients.w));
+  let fresnel = reflectance0 * amplitude.x + (reflectance90 - reflectance0) * amplitude.y;
+  return light.color * fresnel * areaLTC_integral(light, receiver, normal, view, inverseTransform);
+}
+fn areaLTC_evaluate(index: i32, receiver: vec3f, normal: vec3f, view: vec3f, roughness: f32, diffuseColor: vec3f, reflectance0: vec3f, reflectance90: vec3f) -> vec3f {
+  let light = areaLighting_getLight(index);
+  let diffuseIntegral = areaLTC_integral(light, receiver, normal, view, mat3x3f(vec3f(1.0,0.0,0.0),vec3f(0.0,1.0,0.0),vec3f(0.0,0.0,1.0)));
+  return light.color * diffuseColor * (vec3f(1.0) - reflectance0) * diffuseIntegral +
+    areaLTC_specular(light, receiver, normal, view, roughness, reflectance0, reflectance90);
+}
+#endif
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  areaLTCGLSL,
+  areaLTCWGSL
+});

package/dist/modules/lighting/area-lighting/ltc-shaders.d.ts

@@ -0,0 +1,3 @@
+export declare const areaLTCGLSL = "\n#ifdef USE_AREA_LIGHT_LTC\nuniform sampler2D areaLTCMatrix;\nuniform sampler2D areaLTCAmplitude;\n// GGX fit and Fresnel decomposition: Heitz, Dupuy, Hill and Neubelt, SIGGRAPH 2016.\n// Explicit bilinear lookup avoids requiring filterable float32 textures on WebGPU.\nvec4 areaLTC_lookup(sampler2D table, vec2 coordinate) {\n  vec2 position = clamp(coordinate, 0.0, 1.0) * 63.0;\n  ivec2 lower = ivec2(floor(position));\n  ivec2 upper = min(lower + ivec2(1), ivec2(63));\n  vec2 fraction = fract(position);\n  return mix(mix(texelFetch(table, lower, 0), texelFetch(table, ivec2(upper.x, lower.y), 0), fraction.x),\n             mix(texelFetch(table, ivec2(lower.x, upper.y), 0), texelFetch(table, upper, 0), fraction.x), fraction.y);\n}\n\n// Exact horizon clipping followed by the spherical polygon edge integral.\n// Disk support uses an inscribed 32-gon; the area error is below 0.65 percent.\nfloat areaLTC_integral(AreaLightUniform light, vec3 receiver, vec3 normal, vec3 view, mat3 inverseTransform) {\n  if (dot(light.normal, receiver - light.position) <= 0.0) return 0.0;\n  vec3 tangent = view - normal * dot(view, normal);\n  if (dot(tangent, tangent) < 1e-8) {\n    vec3 axis = abs(normal.z) < 0.9 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);\n    tangent = cross(axis, normal);\n  }\n  tangent = normalize(tangent);\n  mat3 transform = inverseTransform * transpose(mat3(tangent, -cross(normal, tangent), normal));\n  vec3 vertices[33];\n  int count = light.disk != 0 ? 32 : 4;\n  for (int index = 0; index < 32; index++) {\n    if (index >= count) break;\n    vec2 coordinate;\n    if (light.disk != 0) {\n      float angle = float(index) * 6.28318530718 / 32.0;\n      coordinate = vec2(cos(angle), -sin(angle));\n    } else {\n      coordinate = index == 0 ? vec2(1.0, -1.0) : index == 1 ? vec2(-1.0, -1.0) : index == 2 ? vec2(-1.0, 1.0) : vec2(1.0, 1.0);\n    }\n    vertices[index] = transform * (light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY - receiver);\n  }\n  vec3 clipped[34];\n  int clippedCount = 0;\n  for (int index = 0; index < 32; index++) {\n    if (index >= count) break;\n    vec3 start = vertices[index];\n    vec3 end = vertices[(index + 1) % count];\n    if (start.z > 0.0) { clipped[clippedCount] = start; clippedCount++; }\n    if ((start.z > 0.0) != (end.z > 0.0)) {\n      clipped[clippedCount] = mix(start, end, start.z / (start.z - end.z));\n      clippedCount++;\n    }\n  }\n  if (clippedCount < 3) return 0.0;\n  vec3 integral = vec3(0.0);\n  for (int index = 0; index < 34; index++) {\n    if (index >= clippedCount) break;\n    vec3 start = normalize(clipped[index]);\n    vec3 end = normalize(clipped[(index + 1) % clippedCount]);\n    vec3 edge = cross(start, end);\n    float sine = length(edge);\n    if (sine > 1e-7) integral += edge * (acos(clamp(dot(start, end), -1.0, 1.0)) / sine);\n  }\n  return min(abs(integral.z) / 6.28318530718, 1.0);\n}\n\nvec3 areaLTC_specular(AreaLightUniform light, vec3 receiver, vec3 normal, vec3 view, float roughness, vec3 reflectance0, vec3 reflectance90) {\n  vec2 coordinate = vec2(roughness, sqrt(1.0 - clamp(dot(normal, view), 0.0, 1.0)));\n  vec4 coefficients = areaLTC_lookup(areaLTCMatrix, coordinate);\n  vec4 amplitude = areaLTC_lookup(areaLTCAmplitude, coordinate);\n  mat3 inverseTransform = mat3(vec3(coefficients.x, 0.0, coefficients.y), vec3(0.0, 1.0, 0.0), vec3(coefficients.z, 0.0, coefficients.w));\n  vec3 fresnel = reflectance0 * amplitude.x + (reflectance90 - reflectance0) * amplitude.y;\n  return light.color * fresnel * areaLTC_integral(light, receiver, normal, view, inverseTransform);\n}\n\nvec3 areaLTC_evaluate(int index, vec3 receiver, vec3 normal, vec3 view, float roughness, vec3 diffuseColor, vec3 reflectance0, vec3 reflectance90) {\n  AreaLightUniform light = areaLighting_getLight(index);\n  float diffuseIntegral = areaLTC_integral(light, receiver, normal, view, mat3(1.0));\n  return light.color * diffuseColor * (vec3(1.0) - reflectance0) * diffuseIntegral +\n    areaLTC_specular(light, receiver, normal, view, roughness, reflectance0, reflectance90);\n}\n#endif\n";
+export declare const areaLTCWGSL = "\n#ifdef USE_AREA_LIGHT_LTC\n@group(2) @binding(auto) var areaLTCMatrix: texture_2d<f32>;\n@group(2) @binding(auto) var areaLTCAmplitude: texture_2d<f32>;\nfn areaLTC_lookup(table: texture_2d<f32>, coordinate: vec2f) -> vec4f {\n  let position = clamp(coordinate, vec2f(0.0), vec2f(1.0)) * 63.0;\n  let lower = vec2i(floor(position));\n  let upper = min(lower + vec2i(1), vec2i(63));\n  let fraction = fract(position);\n  return mix(mix(textureLoad(table, lower, 0), textureLoad(table, vec2i(upper.x, lower.y), 0), fraction.x),\n             mix(textureLoad(table, vec2i(lower.x, upper.y), 0), textureLoad(table, upper, 0), fraction.x), fraction.y);\n}\nfn areaLTC_integral(light: AreaLightUniform, receiver: vec3f, normal: vec3f, view: vec3f, inverseTransform: mat3x3f) -> f32 {\n  if (dot(light.normal, receiver - light.position) <= 0.0) { return 0.0; }\n  var tangent = view - normal * dot(view, normal);\n  if (dot(tangent, tangent) < 1e-8) {\n    let axis = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(normal.z) < 0.9);\n    tangent = cross(axis, normal);\n  }\n  tangent = normalize(tangent);\n  let transform = inverseTransform * transpose(mat3x3f(tangent, -cross(normal, tangent), normal));\n  var vertices: array<vec3f, 33>;\n  let count = select(4, 32, light.disk != 0);\n  for (var index = 0; index < 32; index++) {\n    if (index >= count) { break; }\n    var coordinate: vec2f;\n    if (light.disk != 0) {\n      let angle = f32(index) * 6.28318530718 / 32.0;\n      coordinate = vec2f(cos(angle), -sin(angle));\n    } else {\n      coordinate = vec2f(1.0, 1.0);\n      if (index == 0) { coordinate = vec2f(1.0, -1.0); }\n      if (index == 1) { coordinate = vec2f(-1.0, -1.0); }\n      if (index == 2) { coordinate = vec2f(-1.0, 1.0); }\n    }\n    vertices[index] = transform * (light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY - receiver);\n  }\n  var clipped: array<vec3f, 34>;\n  var clippedCount = 0;\n  for (var index = 0; index < 32; index++) {\n    if (index >= count) { break; }\n    let start = vertices[index];\n    let end = vertices[(index + 1) % count];\n    if (start.z > 0.0) { clipped[clippedCount] = start; clippedCount++; }\n    if ((start.z > 0.0) != (end.z > 0.0)) {\n      clipped[clippedCount] = mix(start, end, start.z / (start.z - end.z));\n      clippedCount++;\n    }\n  }\n  if (clippedCount < 3) { return 0.0; }\n  var integral = vec3f(0.0);\n  for (var index = 0; index < 34; index++) {\n    if (index >= clippedCount) { break; }\n    let start = normalize(clipped[index]);\n    let end = normalize(clipped[(index + 1) % clippedCount]);\n    let edge = cross(start, end);\n    let sine = length(edge);\n    if (sine > 1e-7) { integral += edge * (acos(clamp(dot(start, end), -1.0, 1.0)) / sine); }\n  }\n  return min(abs(integral.z) / 6.28318530718, 1.0);\n}\nfn areaLTC_specular(light: AreaLightUniform, receiver: vec3f, normal: vec3f, view: vec3f, roughness: f32, reflectance0: vec3f, reflectance90: vec3f) -> vec3f {\n  let coordinate = vec2f(roughness, sqrt(1.0 - clamp(dot(normal, view), 0.0, 1.0)));\n  let coefficients = areaLTC_lookup(areaLTCMatrix, coordinate);\n  let amplitude = areaLTC_lookup(areaLTCAmplitude, coordinate);\n  let inverseTransform = mat3x3f(vec3f(coefficients.x, 0.0, coefficients.y), vec3f(0.0, 1.0, 0.0), vec3f(coefficients.z, 0.0, coefficients.w));\n  let fresnel = reflectance0 * amplitude.x + (reflectance90 - reflectance0) * amplitude.y;\n  return light.color * fresnel * areaLTC_integral(light, receiver, normal, view, inverseTransform);\n}\nfn areaLTC_evaluate(index: i32, receiver: vec3f, normal: vec3f, view: vec3f, roughness: f32, diffuseColor: vec3f, reflectance0: vec3f, reflectance90: vec3f) -> vec3f {\n  let light = areaLighting_getLight(index);\n  let diffuseIntegral = areaLTC_integral(light, receiver, normal, view, mat3x3f(vec3f(1.0,0.0,0.0),vec3f(0.0,1.0,0.0),vec3f(0.0,0.0,1.0)));\n  return light.color * diffuseColor * (vec3f(1.0) - reflectance0) * diffuseIntegral +\n    areaLTC_specular(light, receiver, normal, view, roughness, reflectance0, reflectance90);\n}\n#endif\n";
+//# sourceMappingURL=ltc-shaders.d.ts.map

package/dist/modules/lighting/area-lighting/ltc-shaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ltc-shaders.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/area-lighting/ltc-shaders.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,iiIAgFvB,CAAC;AAEF,eAAO,MAAM,WAAW,ohIA4EvB,CAAC"}

package/dist/modules/lighting/area-lighting/ltc-shaders.js

@@ -0,0 +1,162 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export const areaLTCGLSL = /* glsl */ `
+#ifdef USE_AREA_LIGHT_LTC
+uniform sampler2D areaLTCMatrix;
+uniform sampler2D areaLTCAmplitude;
+// GGX fit and Fresnel decomposition: Heitz, Dupuy, Hill and Neubelt, SIGGRAPH 2016.
+// Explicit bilinear lookup avoids requiring filterable float32 textures on WebGPU.
+vec4 areaLTC_lookup(sampler2D table, vec2 coordinate) {
+  vec2 position = clamp(coordinate, 0.0, 1.0) * 63.0;
+  ivec2 lower = ivec2(floor(position));
+  ivec2 upper = min(lower + ivec2(1), ivec2(63));
+  vec2 fraction = fract(position);
+  return mix(mix(texelFetch(table, lower, 0), texelFetch(table, ivec2(upper.x, lower.y), 0), fraction.x),
+             mix(texelFetch(table, ivec2(lower.x, upper.y), 0), texelFetch(table, upper, 0), fraction.x), fraction.y);
+}
+
+// Exact horizon clipping followed by the spherical polygon edge integral.
+// Disk support uses an inscribed 32-gon; the area error is below 0.65 percent.
+float areaLTC_integral(AreaLightUniform light, vec3 receiver, vec3 normal, vec3 view, mat3 inverseTransform) {
+  if (dot(light.normal, receiver - light.position) <= 0.0) return 0.0;
+  vec3 tangent = view - normal * dot(view, normal);
+  if (dot(tangent, tangent) < 1e-8) {
+    vec3 axis = abs(normal.z) < 0.9 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+    tangent = cross(axis, normal);
+  }
+  tangent = normalize(tangent);
+  mat3 transform = inverseTransform * transpose(mat3(tangent, -cross(normal, tangent), normal));
+  vec3 vertices[33];
+  int count = light.disk != 0 ? 32 : 4;
+  for (int index = 0; index < 32; index++) {
+    if (index >= count) break;
+    vec2 coordinate;
+    if (light.disk != 0) {
+      float angle = float(index) * 6.28318530718 / 32.0;
+      coordinate = vec2(cos(angle), -sin(angle));
+    } else {
+      coordinate = index == 0 ? vec2(1.0, -1.0) : index == 1 ? vec2(-1.0, -1.0) : index == 2 ? vec2(-1.0, 1.0) : vec2(1.0, 1.0);
+    }
+    vertices[index] = transform * (light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY - receiver);
+  }
+  vec3 clipped[34];
+  int clippedCount = 0;
+  for (int index = 0; index < 32; index++) {
+    if (index >= count) break;
+    vec3 start = vertices[index];
+    vec3 end = vertices[(index + 1) % count];
+    if (start.z > 0.0) { clipped[clippedCount] = start; clippedCount++; }
+    if ((start.z > 0.0) != (end.z > 0.0)) {
+      clipped[clippedCount] = mix(start, end, start.z / (start.z - end.z));
+      clippedCount++;
+    }
+  }
+  if (clippedCount < 3) return 0.0;
+  vec3 integral = vec3(0.0);
+  for (int index = 0; index < 34; index++) {
+    if (index >= clippedCount) break;
+    vec3 start = normalize(clipped[index]);
+    vec3 end = normalize(clipped[(index + 1) % clippedCount]);
+    vec3 edge = cross(start, end);
+    float sine = length(edge);
+    if (sine > 1e-7) integral += edge * (acos(clamp(dot(start, end), -1.0, 1.0)) / sine);
+  }
+  return min(abs(integral.z) / 6.28318530718, 1.0);
+}
+
+vec3 areaLTC_specular(AreaLightUniform light, vec3 receiver, vec3 normal, vec3 view, float roughness, vec3 reflectance0, vec3 reflectance90) {
+  vec2 coordinate = vec2(roughness, sqrt(1.0 - clamp(dot(normal, view), 0.0, 1.0)));
+  vec4 coefficients = areaLTC_lookup(areaLTCMatrix, coordinate);
+  vec4 amplitude = areaLTC_lookup(areaLTCAmplitude, coordinate);
+  mat3 inverseTransform = mat3(vec3(coefficients.x, 0.0, coefficients.y), vec3(0.0, 1.0, 0.0), vec3(coefficients.z, 0.0, coefficients.w));
+  vec3 fresnel = reflectance0 * amplitude.x + (reflectance90 - reflectance0) * amplitude.y;
+  return light.color * fresnel * areaLTC_integral(light, receiver, normal, view, inverseTransform);
+}
+
+vec3 areaLTC_evaluate(int index, vec3 receiver, vec3 normal, vec3 view, float roughness, vec3 diffuseColor, vec3 reflectance0, vec3 reflectance90) {
+  AreaLightUniform light = areaLighting_getLight(index);
+  float diffuseIntegral = areaLTC_integral(light, receiver, normal, view, mat3(1.0));
+  return light.color * diffuseColor * (vec3(1.0) - reflectance0) * diffuseIntegral +
+    areaLTC_specular(light, receiver, normal, view, roughness, reflectance0, reflectance90);
+}
+#endif
+`;
+export const areaLTCWGSL = /* wgsl */ `
+#ifdef USE_AREA_LIGHT_LTC
+@group(2) @binding(auto) var areaLTCMatrix: texture_2d<f32>;
+@group(2) @binding(auto) var areaLTCAmplitude: texture_2d<f32>;
+fn areaLTC_lookup(table: texture_2d<f32>, coordinate: vec2f) -> vec4f {
+  let position = clamp(coordinate, vec2f(0.0), vec2f(1.0)) * 63.0;
+  let lower = vec2i(floor(position));
+  let upper = min(lower + vec2i(1), vec2i(63));
+  let fraction = fract(position);
+  return mix(mix(textureLoad(table, lower, 0), textureLoad(table, vec2i(upper.x, lower.y), 0), fraction.x),
+             mix(textureLoad(table, vec2i(lower.x, upper.y), 0), textureLoad(table, upper, 0), fraction.x), fraction.y);
+}
+fn areaLTC_integral(light: AreaLightUniform, receiver: vec3f, normal: vec3f, view: vec3f, inverseTransform: mat3x3f) -> f32 {
+  if (dot(light.normal, receiver - light.position) <= 0.0) { return 0.0; }
+  var tangent = view - normal * dot(view, normal);
+  if (dot(tangent, tangent) < 1e-8) {
+    let axis = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(normal.z) < 0.9);
+    tangent = cross(axis, normal);
+  }
+  tangent = normalize(tangent);
+  let transform = inverseTransform * transpose(mat3x3f(tangent, -cross(normal, tangent), normal));
+  var vertices: array<vec3f, 33>;
+  let count = select(4, 32, light.disk != 0);
+  for (var index = 0; index < 32; index++) {
+    if (index >= count) { break; }
+    var coordinate: vec2f;
+    if (light.disk != 0) {
+      let angle = f32(index) * 6.28318530718 / 32.0;
+      coordinate = vec2f(cos(angle), -sin(angle));
+    } else {
+      coordinate = vec2f(1.0, 1.0);
+      if (index == 0) { coordinate = vec2f(1.0, -1.0); }
+      if (index == 1) { coordinate = vec2f(-1.0, -1.0); }
+      if (index == 2) { coordinate = vec2f(-1.0, 1.0); }
+    }
+    vertices[index] = transform * (light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY - receiver);
+  }
+  var clipped: array<vec3f, 34>;
+  var clippedCount = 0;
+  for (var index = 0; index < 32; index++) {
+    if (index >= count) { break; }
+    let start = vertices[index];
+    let end = vertices[(index + 1) % count];
+    if (start.z > 0.0) { clipped[clippedCount] = start; clippedCount++; }
+    if ((start.z > 0.0) != (end.z > 0.0)) {
+      clipped[clippedCount] = mix(start, end, start.z / (start.z - end.z));
+      clippedCount++;
+    }
+  }
+  if (clippedCount < 3) { return 0.0; }
+  var integral = vec3f(0.0);
+  for (var index = 0; index < 34; index++) {
+    if (index >= clippedCount) { break; }
+    let start = normalize(clipped[index]);
+    let end = normalize(clipped[(index + 1) % clippedCount]);
+    let edge = cross(start, end);
+    let sine = length(edge);
+    if (sine > 1e-7) { integral += edge * (acos(clamp(dot(start, end), -1.0, 1.0)) / sine); }
+  }
+  return min(abs(integral.z) / 6.28318530718, 1.0);
+}
+fn areaLTC_specular(light: AreaLightUniform, receiver: vec3f, normal: vec3f, view: vec3f, roughness: f32, reflectance0: vec3f, reflectance90: vec3f) -> vec3f {
+  let coordinate = vec2f(roughness, sqrt(1.0 - clamp(dot(normal, view), 0.0, 1.0)));
+  let coefficients = areaLTC_lookup(areaLTCMatrix, coordinate);
+  let amplitude = areaLTC_lookup(areaLTCAmplitude, coordinate);
+  let inverseTransform = mat3x3f(vec3f(coefficients.x, 0.0, coefficients.y), vec3f(0.0, 1.0, 0.0), vec3f(coefficients.z, 0.0, coefficients.w));
+  let fresnel = reflectance0 * amplitude.x + (reflectance90 - reflectance0) * amplitude.y;
+  return light.color * fresnel * areaLTC_integral(light, receiver, normal, view, inverseTransform);
+}
+fn areaLTC_evaluate(index: i32, receiver: vec3f, normal: vec3f, view: vec3f, roughness: f32, diffuseColor: vec3f, reflectance0: vec3f, reflectance90: vec3f) -> vec3f {
+  let light = areaLighting_getLight(index);
+  let diffuseIntegral = areaLTC_integral(light, receiver, normal, view, mat3x3f(vec3f(1.0,0.0,0.0),vec3f(0.0,1.0,0.0),vec3f(0.0,0.0,1.0)));
+  return light.color * diffuseColor * (vec3f(1.0) - reflectance0) * diffuseIntegral +
+    areaLTC_specular(light, receiver, normal, view, roughness, reflectance0, reflectance90);
+}
+#endif
+`;
+//# sourceMappingURL=ltc-shaders.js.map

package/dist/modules/lighting/area-lighting/ltc-shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ltc-shaders.js","sourceRoot":"","sources":["../../../../src/modules/lighting/area-lighting/ltc-shaders.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFrC,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4ErC,CAAC"}