@luma.gl/shaders 10.0.0-alpha.10 → 10.0.0-alpha.11

package/dist/modules/lighting/shadow/shadow.js

@@ -0,0 +1,450 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { SHADOW_GLSL } from "./shadow-glsl.js";
+const MAX_CASCADES = 4;
+const MAX_SPOT_LIGHTS = 4;
+const MAX_POINT_LIGHTS = 4;
+const MAX_POINT_MATRICES = 24;
+const DIRECTIONAL_LIGHT_UNIFORM_TYPE = {
+    direction: 'vec3<f32>',
+    strength: 'f32',
+    normalBias: 'f32',
+    sourceAngularRadius: 'f32',
+    cascadeBlendFraction: 'f32',
+    farFadeFraction: 'f32',
+    shadowDistance: 'f32'
+};
+const SPOT_LIGHT_UNIFORM_TYPE = {
+    position: 'vec3<f32>',
+    range: 'f32',
+    direction: 'vec3<f32>',
+    outerConeCos: 'f32',
+    sourceRadius: 'f32',
+    normalBias: 'f32',
+    strength: 'f32',
+    nearPlane: 'f32'
+};
+const POINT_LIGHT_UNIFORM_TYPE = {
+    position: 'vec3<f32>',
+    range: 'f32',
+    sourceRadius: 'f32',
+    normalBias: 'f32',
+    strength: 'f32',
+    nearPlane: 'f32'
+};
+const SHADOW_WGSL = /* wgsl */ `\
+const SHADOW_PI: f32 = 3.141592653589793;
+
+struct DirectionalShadowLightUniform {
+  direction: vec3f,
+  strength: f32,
+  normalBias: f32,
+  sourceAngularRadius: f32,
+  cascadeBlendFraction: f32,
+  farFadeFraction: f32,
+  shadowDistance: f32,
+};
+
+struct SpotShadowLightUniform {
+  position: vec3f,
+  range: f32,
+  direction: vec3f,
+  outerConeCos: f32,
+  sourceRadius: f32,
+  normalBias: f32,
+  strength: f32,
+  nearPlane: f32,
+};
+
+struct PointShadowLightUniform {
+  position: vec3f,
+  range: f32,
+  sourceRadius: f32,
+  normalBias: f32,
+  strength: f32,
+  nearPlane: f32,
+};
+
+struct ShadowUniforms {
+  directionalLightCount: i32,
+  spotLightCount: i32,
+  pointLightCount: i32,
+  cascadeCount: i32,
+  blockerSampleCount: i32,
+  filterSampleCount: i32,
+  cascadeSplits: vec4f,
+  directionalViewProjectionMatrices: array<mat4x4f, 4>,
+  spotViewProjectionMatrices: array<mat4x4f, 4>,
+  pointViewProjectionMatrices: array<mat4x4f, 24>,
+  directionalLights: array<DirectionalShadowLightUniform, 1>,
+  spotLights: array<SpotShadowLightUniform, 4>,
+  pointLights: array<PointShadowLightUniform, 4>,
+};
+
+@group(2) @binding(auto) var<uniform> shadow: ShadowUniforms;
+@group(2) @binding(auto) var directionalShadowTexture: texture_depth_2d_array;
+@group(2) @binding(auto) var spotShadowTexture: texture_depth_2d_array;
+@group(2) @binding(auto) var pointShadowTexture: texture_depth_cube_array;
+@group(2) @binding(auto) var directionalShadowTextureSampler: sampler;
+@group(2) @binding(auto) var shadowComparisonSampler: sampler_comparison;
+
+fn shadow_hash(position: vec3f) -> f32 {
+  return fract(sin(dot(position, vec3f(12.9898, 78.233, 37.719))) * 43758.5453);
+}
+
+fn shadow_diskSample(index: i32, count: i32, rotation: f32) -> vec2f {
+  let fraction = (f32(index) + 0.5) / max(f32(count), 1.0);
+  let angle = f32(index) * 2.39996323 + rotation;
+  return sqrt(fraction) * vec2f(cos(angle), sin(angle));
+}
+
+fn shadow_project(matrix: mat4x4f, worldPosition: vec3f) -> vec3f {
+  let clip = matrix * vec4f(worldPosition, 1.0);
+  let ndc = clip.xyz / max(abs(clip.w), 0.00001);
+  return vec3f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5, ndc.z);
+}
+
+fn shadow_validProjection(projected: vec3f) -> bool {
+  return all(projected.xy >= vec2f(0.0)) && all(projected.xy <= vec2f(1.0)) &&
+    projected.z >= 0.0 && projected.z <= 1.0;
+}
+
+fn shadow_directionalCascadeIndex(viewDepth: f32) -> i32 {
+  var cascadeIndex = 0;
+  for (var index: i32 = 0; index < 4; index++) {
+    if (index >= shadow.cascadeCount) { break; }
+    cascadeIndex = index;
+    if (viewDepth <= shadow.cascadeSplits[index]) { break; }
+  }
+  return cascadeIndex;
+}
+
+fn shadow_getDirectionalCascadeIndex(viewDepth: f32) -> i32 {
+  if (shadow.directionalLightCount == 0) { return -1; }
+  return shadow_directionalCascadeIndex(viewDepth);
+}
+
+fn shadow_directionalPCSS(cascadeIndex: i32, worldPosition: vec3f, viewDepth: f32) -> f32 {
+  let projected = shadow_project(shadow.directionalViewProjectionMatrices[cascadeIndex], worldPosition);
+  if (!shadow_validProjection(projected)) { return 1.0; }
+  let dimensions = vec2f(textureDimensions(directionalShadowTexture));
+  let texel = 1.0 / dimensions;
+  let light = shadow.directionalLights[0];
+  let rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;
+  let searchRadius = max(texel.x, light.sourceAngularRadius * viewDepth / max(light.shadowDistance, 0.001));
+  var blockerDepth = 0.0;
+  var blockerCount = 0.0;
+  for (var index: i32 = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) { break; }
+    let offset = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;
+    let sampleDepth = textureSampleLevel(
+      directionalShadowTexture,
+      directionalShadowTextureSampler,
+      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),
+      cascadeIndex,
+      0
+    );
+    if (sampleDepth < projected.z) {
+      blockerDepth += sampleDepth;
+      blockerCount += 1.0;
+    }
+  }
+  if (blockerCount == 0.0) { return 1.0; }
+  let averageBlocker = blockerDepth / blockerCount;
+  let penumbra = clamp((projected.z - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  let filterRadius = max(texel.x, searchRadius * (1.0 + penumbra * 18.0));
+  var visibility = 0.0;
+  for (var index: i32 = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) { break; }
+    let offset = shadow_diskSample(index, shadow.filterSampleCount, rotation) * filterRadius;
+    visibility += textureSampleCompareLevel(
+      directionalShadowTexture,
+      shadowComparisonSampler,
+      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),
+      cascadeIndex,
+      projected.z
+    );
+  }
+  return visibility / max(f32(shadow.filterSampleCount), 1.0);
+}
+
+fn shadow_getDirectionalFactor(worldPosition: vec3f, worldNormal: vec3f, viewDepth: f32) -> f32 {
+  if (shadow.directionalLightCount == 0 || viewDepth <= 0.0) { return 1.0; }
+  let light = shadow.directionalLights[0];
+  if (viewDepth >= light.shadowDistance) { return 1.0; }
+  let biasedPosition = worldPosition + normalize(worldNormal) * light.normalBias;
+  let cascadeIndex = shadow_directionalCascadeIndex(viewDepth);
+  var visibility = shadow_directionalPCSS(cascadeIndex, biasedPosition, viewDepth);
+  if (cascadeIndex + 1 < shadow.cascadeCount) {
+    var cascadeStart = 0.0;
+    if (cascadeIndex > 0) { cascadeStart = shadow.cascadeSplits[cascadeIndex - 1]; }
+    let cascadeEnd = shadow.cascadeSplits[cascadeIndex];
+    let blendWidth = max((cascadeEnd - cascadeStart) * light.cascadeBlendFraction, 0.0001);
+    let blend = smoothstep(cascadeEnd - blendWidth, cascadeEnd, viewDepth);
+    if (blend > 0.0) {
+      visibility = mix(
+        visibility,
+        shadow_directionalPCSS(cascadeIndex + 1, biasedPosition, viewDepth),
+        blend
+      );
+    }
+  }
+  let fadeWidth = max(light.shadowDistance * light.farFadeFraction, 0.0001);
+  let farFade = smoothstep(light.shadowDistance - fadeWidth, light.shadowDistance, viewDepth);
+  visibility = mix(visibility, 1.0, farFade);
+  return mix(1.0, visibility, light.strength);
+}
+
+fn shadow_spotPCSS(lightIndex: i32, worldPosition: vec3f) -> f32 {
+  let projected = shadow_project(shadow.spotViewProjectionMatrices[lightIndex], worldPosition);
+  if (!shadow_validProjection(projected)) { return 1.0; }
+  let light = shadow.spotLights[lightIndex];
+  let dimensions = vec2f(textureDimensions(spotShadowTexture));
+  let texel = 1.0 / dimensions;
+  let distanceToLight = length(worldPosition - light.position);
+  let searchRadius = max(texel.x, light.sourceRadius / max(distanceToLight, 0.001) * 0.5);
+  let rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;
+  var blockerDepth = 0.0;
+  var blockerCount = 0.0;
+  for (var index: i32 = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) { break; }
+    let offset = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;
+    let sampleDepth = textureSampleLevel(
+      spotShadowTexture,
+      directionalShadowTextureSampler,
+      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),
+      lightIndex,
+      0
+    );
+    if (sampleDepth < projected.z) { blockerDepth += sampleDepth; blockerCount += 1.0; }
+  }
+  if (blockerCount == 0.0) { return 1.0; }
+  let averageBlocker = blockerDepth / blockerCount;
+  let penumbra = clamp((projected.z - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  let filterRadius = max(texel.x, searchRadius * (1.0 + penumbra * 16.0));
+  var visibility = 0.0;
+  for (var index: i32 = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) { break; }
+    let offset = shadow_diskSample(index, shadow.filterSampleCount, rotation) * filterRadius;
+    visibility += textureSampleCompareLevel(
+      spotShadowTexture,
+      shadowComparisonSampler,
+      clamp(projected.xy + offset, vec2f(0.0), vec2f(1.0)),
+      lightIndex,
+      projected.z
+    );
+  }
+  return visibility / max(f32(shadow.filterSampleCount), 1.0);
+}
+
+fn shadow_getSpotFactor(lightIndex: i32, worldPosition: vec3f, worldNormal: vec3f) -> f32 {
+  if (lightIndex < 0 || lightIndex >= shadow.spotLightCount) { return 1.0; }
+  let light = shadow.spotLights[lightIndex];
+  let fromLight = worldPosition - light.position;
+  let distanceToLight = length(fromLight);
+  let coneCos = dot(normalize(fromLight), normalize(light.direction));
+  if (distanceToLight >= light.range || coneCos < light.outerConeCos) { return 1.0; }
+  let biasedPosition = worldPosition + normalize(worldNormal) * light.normalBias;
+  return mix(1.0, shadow_spotPCSS(lightIndex, biasedPosition), light.strength);
+}
+
+fn shadow_pointReferenceDepth(majorDistance: f32, nearPlane: f32, farPlane: f32) -> f32 {
+  // Match the cube-face projection and stored WebGPU depth in [0, 1].
+  return farPlane / (farPlane - nearPlane) -
+    (farPlane * nearPlane) / ((farPlane - nearPlane) * majorDistance);
+}
+
+fn shadow_pointBasis(direction: vec3f) -> mat2x3f {
+  let reference = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(direction.y) > 0.99);
+  let tangent = normalize(cross(direction, reference));
+  return mat2x3f(tangent, normalize(cross(direction, tangent)));
+}
+
+fn shadow_getPointFactor(lightIndex: i32, worldPosition: vec3f, worldNormal: vec3f) -> f32 {
+  if (lightIndex < 0 || lightIndex >= shadow.pointLightCount) { return 1.0; }
+  let light = shadow.pointLights[lightIndex];
+  let biasedPosition = worldPosition + normalize(worldNormal) * light.normalBias;
+  let fromLight = biasedPosition - light.position;
+  let distanceToLight = length(fromLight);
+  if (distanceToLight >= light.range || distanceToLight <= light.nearPlane) { return 1.0; }
+  let direction = normalize(fromLight);
+  let majorDistance = max(max(abs(fromLight.x), abs(fromLight.y)), abs(fromLight.z));
+  let referenceDepth = shadow_pointReferenceDepth(majorDistance, light.nearPlane, light.range);
+  let searchRadius = light.sourceRadius / max(distanceToLight, 0.001);
+  let rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;
+  let basis = shadow_pointBasis(direction);
+  var blockerDepth = 0.0;
+  var blockerCount = 0.0;
+  for (var index: i32 = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) { break; }
+    let disk = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;
+    let sampleDirection = normalize(direction + basis[0] * disk.x + basis[1] * disk.y);
+    let sampleDepth = textureSampleLevel(
+      pointShadowTexture,
+      directionalShadowTextureSampler,
+      sampleDirection,
+      lightIndex,
+      0
+    );
+    if (sampleDepth < referenceDepth) { blockerDepth += sampleDepth; blockerCount += 1.0; }
+  }
+  if (blockerCount == 0.0) { return 1.0; }
+  let averageBlocker = blockerDepth / blockerCount;
+  let penumbra = clamp((referenceDepth - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  let filterRadius = searchRadius * (1.0 + penumbra * 12.0);
+  var visibility = 0.0;
+  for (var index: i32 = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) { break; }
+    let disk = shadow_diskSample(index, shadow.filterSampleCount, rotation) * filterRadius;
+    let sampleDirection = normalize(direction + basis[0] * disk.x + basis[1] * disk.y);
+    visibility += textureSampleCompareLevel(
+      pointShadowTexture,
+      shadowComparisonSampler,
+      sampleDirection,
+      lightIndex,
+      referenceDepth
+    );
+  }
+  visibility /= max(f32(shadow.filterSampleCount), 1.0);
+  return mix(1.0, visibility, light.strength);
+}
+`;
+/** Backend-aware shadow sampling module. Applications explicitly apply factors to direct-light terms. */
+export const shadow = {
+    name: 'shadow',
+    source: SHADOW_WGSL,
+    fs: SHADOW_GLSL,
+    props: {},
+    uniforms: {},
+    bindings: {},
+    uniformTypes: {
+        directionalLightCount: 'i32',
+        spotLightCount: 'i32',
+        pointLightCount: 'i32',
+        cascadeCount: 'i32',
+        blockerSampleCount: 'i32',
+        filterSampleCount: 'i32',
+        cascadeSplits: 'vec4<f32>',
+        directionalViewProjectionMatrices: ['mat4x4<f32>', MAX_CASCADES],
+        spotViewProjectionMatrices: ['mat4x4<f32>', MAX_SPOT_LIGHTS],
+        pointViewProjectionMatrices: ['mat4x4<f32>', MAX_POINT_MATRICES],
+        directionalLights: [DIRECTIONAL_LIGHT_UNIFORM_TYPE, 1],
+        spotLights: [SPOT_LIGHT_UNIFORM_TYPE, MAX_SPOT_LIGHTS],
+        pointLights: [POINT_LIGHT_UNIFORM_TYPE, MAX_POINT_LIGHTS]
+    },
+    bindingLayout: [
+        { name: 'shadow', group: 2 },
+        { name: 'directionalShadowTexture', group: 2 },
+        { name: 'spotShadowTexture', group: 2 },
+        { name: 'pointShadowTexture', group: 2 },
+        { name: 'shadowComparisonSampler', group: 2 }
+    ],
+    getUniforms(props) {
+        if (!props.directionalLights ||
+            !props.spotLights ||
+            !props.pointLights ||
+            !props.cascadeSplits ||
+            !props.directionalViewProjectionMatrices ||
+            !props.spotViewProjectionMatrices ||
+            !props.pointViewProjectionMatrices ||
+            !props.directionalShadowTexture ||
+            !props.spotShadowTexture ||
+            !props.pointShadowTexture ||
+            !props.nonFilteringSampler ||
+            !props.comparisonSampler) {
+            return {};
+        }
+        return {
+            directionalLightCount: props.directionalLights.length,
+            spotLightCount: props.spotLights.length,
+            pointLightCount: props.pointLights.length,
+            cascadeCount: props.cascadeCount,
+            blockerSampleCount: props.blockerSampleCount,
+            filterSampleCount: props.filterSampleCount,
+            cascadeSplits: props.cascadeSplits,
+            directionalViewProjectionMatrices: props.directionalViewProjectionMatrices,
+            spotViewProjectionMatrices: props.spotViewProjectionMatrices,
+            pointViewProjectionMatrices: props.pointViewProjectionMatrices,
+            directionalLights: padDirectionalLights(props.directionalLights),
+            spotLights: padSpotLights(props.spotLights),
+            pointLights: padPointLights(props.pointLights),
+            directionalShadowTexture: props.directionalShadowTexture,
+            spotShadowTexture: props.spotShadowTexture,
+            pointShadowTexture: props.pointShadowTexture,
+            ...(props.directionalShadowTexture.device.type === 'webgpu'
+                ? { shadowComparisonSampler: props.comparisonSampler }
+                : {})
+        };
+    }
+};
+function padDirectionalLights(lights) {
+    const light = lights[0];
+    return [
+        light
+            ? {
+                direction: light.direction,
+                strength: light.strength ?? 1,
+                normalBias: light.normalBias ?? 0.04,
+                sourceAngularRadius: light.sourceAngularRadius ?? 0.00465,
+                cascadeBlendFraction: light.cascadeBlendFraction ?? 0.1,
+                farFadeFraction: light.farFadeFraction ?? 0.1,
+                shadowDistance: light.shadowDistance ?? 1
+            }
+            : {
+                direction: [0, 1, 0],
+                strength: 0,
+                normalBias: 0,
+                sourceAngularRadius: 0,
+                cascadeBlendFraction: 0,
+                farFadeFraction: 0,
+                shadowDistance: 1
+            }
+    ];
+}
+function padSpotLights(lights) {
+    return padArray(lights.map(light => ({
+        position: light.position,
+        range: light.range,
+        direction: light.direction,
+        outerConeCos: Math.cos(light.outerConeAngle),
+        sourceRadius: light.sourceRadius ?? 0.2,
+        normalBias: light.normalBias ?? 0.025,
+        strength: light.strength ?? 1,
+        nearPlane: light.nearPlane ?? 0.1
+    })), MAX_SPOT_LIGHTS, {
+        position: [0, 0, 0],
+        range: 1,
+        direction: [0, -1, 0],
+        outerConeCos: 1,
+        sourceRadius: 0,
+        normalBias: 0,
+        strength: 0,
+        nearPlane: 0.1
+    });
+}
+function padPointLights(lights) {
+    return padArray(lights.map(light => ({
+        position: light.position,
+        range: light.range,
+        sourceRadius: light.sourceRadius ?? 0.2,
+        normalBias: light.normalBias ?? 0.025,
+        strength: light.strength ?? 1,
+        nearPlane: light.nearPlane ?? 0.1
+    })), MAX_POINT_LIGHTS, {
+        position: [0, 0, 0],
+        range: 1,
+        sourceRadius: 0,
+        normalBias: 0,
+        strength: 0,
+        nearPlane: 0.1
+    });
+}
+function padArray(values, length, fallback) {
+    const result = values.slice(0, length);
+    while (result.length < length) {
+        result.push(fallback);
+    }
+    return result;
+}
+//# sourceMappingURL=shadow.js.map

package/dist/modules/lighting/shadow/shadow.js.map

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

package/dist/modules/lighting/unlit-material/unlit-material.cjs

@@ -0,0 +1,60 @@
+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 unlit_material_exports = {};
+__export(unlit_material_exports, {
+  unlitMaterial: () => unlitMaterial
+});
+module.exports = __toCommonJS(unlit_material_exports);
+const SOURCE_WGSL = (
+  /* wgsl */
+  `fn unlitMaterial_getColor(surfaceColor: vec4<f32>) -> vec4<f32> {
+  return surfaceColor;
+}
+
+// Compatibility with the aggregate Phong/Gouraud material evaluation function.
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, positionWorldspace: vec3<f32>, normalWorldspace: vec3<f32>) -> vec3<f32> {
+  return surfaceColor;
+}
+`
+);
+const SOURCE_GLSL = (
+  /* glsl */
+  `vec4 unlitMaterial_getColor(vec4 surfaceColor) {
+  return surfaceColor;
+}
+
+// Compatibility with the aggregate Phong/Gouraud material evaluation function.
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positionWorldspace, vec3 normalWorldspace) {
+  return surfaceColor;
+}
+`
+);
+const unlitMaterial = {
+  name: "unlitMaterial",
+  source: SOURCE_WGSL,
+  vs: SOURCE_GLSL,
+  fs: SOURCE_GLSL,
+  dependencies: [],
+  bindingLayout: [],
+  uniformTypes: {},
+  defaultUniforms: {}
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  unlitMaterial
+});

package/dist/modules/lighting/unlit-material/unlit-material.d.ts

@@ -0,0 +1,9 @@
+import type { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+/**
+ * Preserves surface RGBA without lighting dependencies, uniforms, or bindings.
+ * Use instead of a lit material module when lighting is never needed. The caller
+ * supplies color/texture sampling and remains responsible for output color space
+ * and alpha conventions. Available in both vertex and fragment stages.
+ */
+export declare const unlitMaterial: ShaderModule<Record<string, never>>;
+//# sourceMappingURL=unlit-material.d.ts.map

package/dist/modules/lighting/unlit-material/unlit-material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlit-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/unlit-material/unlit-material.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,oDAAiD;AAwB3E;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAS7D,CAAC"}

package/dist/modules/lighting/unlit-material/unlit-material.js

@@ -0,0 +1,40 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const SOURCE_WGSL = /* wgsl */ `\
+fn unlitMaterial_getColor(surfaceColor: vec4<f32>) -> vec4<f32> {
+  return surfaceColor;
+}
+
+// Compatibility with the aggregate Phong/Gouraud material evaluation function.
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, positionWorldspace: vec3<f32>, normalWorldspace: vec3<f32>) -> vec3<f32> {
+  return surfaceColor;
+}
+`;
+const SOURCE_GLSL = /* glsl */ `\
+vec4 unlitMaterial_getColor(vec4 surfaceColor) {
+  return surfaceColor;
+}
+
+// Compatibility with the aggregate Phong/Gouraud material evaluation function.
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positionWorldspace, vec3 normalWorldspace) {
+  return surfaceColor;
+}
+`;
+/**
+ * Preserves surface RGBA without lighting dependencies, uniforms, or bindings.
+ * Use instead of a lit material module when lighting is never needed. The caller
+ * supplies color/texture sampling and remains responsible for output color space
+ * and alpha conventions. Available in both vertex and fragment stages.
+ */
+export const unlitMaterial = {
+    name: 'unlitMaterial',
+    source: SOURCE_WGSL,
+    vs: SOURCE_GLSL,
+    fs: SOURCE_GLSL,
+    dependencies: [],
+    bindingLayout: [],
+    uniformTypes: {},
+    defaultUniforms: {}
+};
+//# sourceMappingURL=unlit-material.js.map

package/dist/modules/lighting/unlit-material/unlit-material.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlit-material.js","sourceRoot":"","sources":["../../../../src/modules/lighting/unlit-material/unlit-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAI5D,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;;;;CAS9B,CAAC;AAEF,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;;;;CAS9B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAwC;IAChE,IAAI,EAAE,eAAe;IACrB,MAAM,EAAE,WAAW;IACnB,EAAE,EAAE,WAAW;IACf,EAAE,EAAE,WAAW;IACf,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE,EAAE;IACjB,YAAY,EAAE,EAAE;IAChB,eAAe,EAAE,EAAE;CACpB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/shaders",
-  "version": "10.0.0-alpha.10",
+  "version": "10.0.0-alpha.11",
   "description": "Shader module system for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -61,7 +61,7 @@
     "prepublishOnly": "npm run build-minified-bundle && npm run build-dev-bundle"
   },
   "dependencies": {
-    "@math.gl/core": "~5.0.0-beta.4"
+    "@math.gl/core": "~5.0.0-beta.5"
   },
-  "gitHead": "52679fe4f3e20ca1f966ea4ba978cf708f440b4f"
+  "gitHead": "abf0b44182fb51a73368e71f1166ca1cf4de63d6"
 }

package/src/index.ts

@@ -168,6 +168,7 @@ export {lighting} from './modules/lighting/lights/lighting';
 export type {IBLBindings} from './modules/lighting/ibl/ibl';
 export {ibl} from './modules/lighting/ibl/ibl';
 export {dirlight} from './modules/lighting/no-material/dirlight';
+export {unlitMaterial} from './modules/lighting/unlit-material/unlit-material';
 export type {LambertMaterialProps} from './modules/lighting/lambert-material/lambert-material';
 export {lambertMaterial} from './modules/lighting/lambert-material/lambert-material';
 export type {GouraudMaterialProps} from './modules/lighting/gouraud-material/gouraud-material';
@@ -257,3 +258,50 @@ export {
   type AreaLight,
   type AreaLightingProps
 } from './modules/lighting/area-lighting/area-lighting';
+
+export {
+  pbrEnvironmentFilter,
+  PBR_ENVIRONMENT_FRAGMENT_GLSL,
+  PBR_ENVIRONMENT_FRAGMENT_WGSL
+} from './modules/lighting/prefiltered-environment/prefiltered-environment';
+export type {
+  PBREnvironmentFilterProps,
+  PBREnvironmentFilterUniforms,
+  PBREnvironmentFilterBindings
+} from './modules/lighting/prefiltered-environment/prefiltered-environment';
+
+export {shadow} from './modules/lighting/shadow/shadow';
+export type {ShadowBindings, ShadowUniforms} from './modules/lighting/shadow/shadow';
+export type {
+  DirectionalShadowLight,
+  SpotShadowLight,
+  PointShadowLight,
+  ShadowProps,
+  ShadowTexture,
+  ShadowBiasProps
+} from './modules/lighting/shadow/shadow-types';
+
+export {pbrShadow} from './modules/lighting/pbr-shadow/pbr-shadow';
+export type {PBRShadowProps, PBRShadowUniforms} from './modules/lighting/pbr-shadow/pbr-shadow';
+
+export {pbrSurface} from './modules/lighting/pbr-surface/pbr-surface';
+export type {PBRSurfaceProps, PBRSurfaceUniforms} from './modules/lighting/pbr-surface/pbr-surface';
+
+export {
+  contactShadowTrace,
+  contactShadowBilateralBlur,
+  contactShadowComposite
+} from './modules/lighting/contact-shadow/contact-shadow';
+export type {
+  ContactTraceUniforms,
+  ContactBlurUniforms,
+  ContactShadowBindings,
+  ContactShadowProps
+} from './modules/lighting/contact-shadow/contact-shadow';
+
+export {pbrContactShadow} from './modules/lighting/pbr-contact-shadow/pbr-contact-shadow';
+export type {PBRContactShadowProps} from './modules/lighting/pbr-contact-shadow/pbr-contact-shadow';
+
+export {clusteredLightGrid} from './modules/lighting/clustered-light-grid/clustered-light-grid';
+export {pbrAmbientOcclusion} from './modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion';
+export type {PBRAmbientOcclusionProps} from './modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion';

package/src/modules/lighting/clustered-light-grid/clustered-light-grid.ts

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+/** Renderer-independent lookup for top-left normalized screen coordinates and positive view depth. */
+export const clusteredLightGrid = {
+  name: 'clusteredLightGrid',
+  source: /* wgsl */ `
+fn clusteredLightGrid_getIndex(coordinates: vec2f, viewDepth: f32, dimensions: vec3u, nearPlane: f32, farPlane: f32) -> u32 {
+  let tile = min(vec2u(clamp(coordinates, vec2f(0.0), vec2f(0.999999)) * vec2f(dimensions.xy)), dimensions.xy - vec2u(1));
+  let normalizedDepth = clamp(log(clamp(viewDepth, nearPlane, farPlane) / nearPlane) / log(farPlane / nearPlane), 0.0, 0.999999);
+  let depthSlice = min(u32(normalizedDepth * f32(dimensions.z)), dimensions.z - 1u);
+  return (depthSlice * dimensions.y + tile.y) * dimensions.x + tile.x;
+}
+`
+} as const satisfies ShaderModule;