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

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

@@ -0,0 +1,204 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** WebGL2 sampling uses raw depth arrays and explicit comparisons; cube arrays are face arrays. */
+export const SHADOW_GLSL = /* glsl */ `
+precision highp sampler2DArray;
+struct DirectionalShadowLightUniform {
+  vec3 direction;
+  float strength;
+  float normalBias;
+  float sourceAngularRadius;
+  float cascadeBlendFraction;
+  float farFadeFraction;
+  float shadowDistance;
+};
+struct SpotShadowLightUniform {
+  vec3 position;
+  float range;
+  vec3 direction;
+  float outerConeCos;
+  float sourceRadius;
+  float normalBias;
+  float strength;
+  float nearPlane;
+};
+struct PointShadowLightUniform {
+  vec3 position;
+  float range;
+  float sourceRadius;
+  float normalBias;
+  float strength;
+  float nearPlane;
+};
+layout(std140) uniform shadowUniforms {
+  int directionalLightCount;
+  int spotLightCount;
+  int pointLightCount;
+  int cascadeCount;
+  int blockerSampleCount;
+  int filterSampleCount;
+  vec4 cascadeSplits;
+  mat4 directionalViewProjectionMatrices[4];
+  mat4 spotViewProjectionMatrices[4];
+  mat4 pointViewProjectionMatrices[24];
+  DirectionalShadowLightUniform directionalLights[1];
+  SpotShadowLightUniform spotLights[4];
+  PointShadowLightUniform pointLights[4];
+} shadow;
+uniform sampler2DArray directionalShadowTexture;
+uniform sampler2DArray spotShadowTexture;
+uniform sampler2DArray pointShadowTexture;
+const float SHADOW_PI = 3.141592653589793;
+float shadow_hash(vec3 position) {
+  return fract(sin(dot(position, vec3(12.9898, 78.233, 37.719))) * 43758.5453);
+}
+vec2 shadow_diskSample(int index, int count, float rotation) {
+  float fraction = (float(index) + 0.5) / max(float(count), 1.0);
+  float angle = float(index) * 2.39996323 + rotation;
+  return sqrt(fraction) * vec2(cos(angle), sin(angle));
+}
+vec3 shadow_project(mat4 matrix, vec3 worldPosition) {
+  vec4 clip = matrix * vec4(worldPosition, 1.0);
+  vec3 projected = clip.xyz / max(abs(clip.w), 0.00001);
+  // Shared matrices retain [0,1] depth; WebGL texture rows start at the bottom.
+  return vec3(projected.xy * 0.5 + 0.5, projected.z);
+}
+bool shadow_validProjection(vec3 projected) {
+  return all(greaterThanEqual(projected, vec3(0.0))) && all(lessThanEqual(projected, vec3(1.0)));
+}
+// Bilinear interpolation of four depth comparisons matches a hardware 2x2 PCF lookup.
+float shadow_compare(sampler2DArray shadowMap, vec2 coordinate, int layer, float reference) {
+  ivec2 dimensions = textureSize(shadowMap, 0).xy;
+  vec2 position = coordinate * vec2(dimensions) - 0.5;
+  ivec2 base = ivec2(floor(position));
+  vec2 fraction = fract(position);
+  ivec2 maximum = dimensions - 1;
+  float lowerLeft = step(reference, texelFetch(shadowMap, ivec3(clamp(base, ivec2(0), maximum), layer), 0).r);
+  float lowerRight = step(reference, texelFetch(shadowMap, ivec3(clamp(base + ivec2(1,0), ivec2(0), maximum), layer), 0).r);
+  float upperLeft = step(reference, texelFetch(shadowMap, ivec3(clamp(base + ivec2(0,1), ivec2(0), maximum), layer), 0).r);
+  float upperRight = step(reference, texelFetch(shadowMap, ivec3(clamp(base + ivec2(1,1), ivec2(0), maximum), layer), 0).r);
+  return mix(mix(lowerLeft, lowerRight, fraction.x), mix(upperLeft, upperRight, fraction.x), fraction.y);
+}
+float shadow_arrayPCSS(sampler2DArray shadowMap, int layer, vec3 projected, float searchRadius, float rotation, float penumbraScale) {
+  if (!shadow_validProjection(projected)) return 1.0;
+  float texel = 1.0 / float(textureSize(shadowMap, 0).x);
+  searchRadius = max(texel, searchRadius);
+  float blockerDepth = 0.0;
+  float blockerCount = 0.0;
+  for (int index = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) break;
+    vec2 coordinate = clamp(projected.xy + shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius, vec2(0.0), vec2(1.0));
+    float depth = textureLod(shadowMap, vec3(coordinate, float(layer)), 0.0).r;
+    if (depth < projected.z) { blockerDepth += depth; blockerCount += 1.0; }
+  }
+  if (blockerCount == 0.0) return 1.0;
+  float averageBlocker = blockerDepth / blockerCount;
+  float penumbra = clamp((projected.z - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  float radius = max(texel, searchRadius * (1.0 + penumbra * penumbraScale));
+  float visibility = 0.0;
+  for (int index = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) break;
+    vec2 coordinate = clamp(projected.xy + shadow_diskSample(index, shadow.filterSampleCount, rotation) * radius, vec2(0.0), vec2(1.0));
+    visibility += shadow_compare(shadowMap, coordinate, layer, projected.z);
+  }
+  return visibility / max(float(shadow.filterSampleCount), 1.0);
+}
+int shadow_directionalCascadeIndex(float viewDepth) {
+  int cascadeIndex = 0;
+  for (int index = 0; index < 4; index++) {
+    if (index >= shadow.cascadeCount) break;
+    cascadeIndex = index;
+    if (viewDepth <= shadow.cascadeSplits[index]) break;
+  }
+  return cascadeIndex;
+}
+int shadow_getDirectionalCascadeIndex(float viewDepth) {
+  return shadow.directionalLightCount == 0 ? -1 : shadow_directionalCascadeIndex(viewDepth);
+}
+float shadow_directionalPCSS(int cascadeIndex, vec3 worldPosition, float viewDepth) {
+  DirectionalShadowLightUniform light = shadow.directionalLights[0];
+  return shadow_arrayPCSS(directionalShadowTexture, cascadeIndex,
+    shadow_project(shadow.directionalViewProjectionMatrices[cascadeIndex], worldPosition),
+    light.sourceAngularRadius * viewDepth / max(light.shadowDistance, 0.001),
+    shadow_hash(worldPosition) * 2.0 * SHADOW_PI, 18.0);
+}
+float shadow_getDirectionalFactor(vec3 worldPosition, vec3 worldNormal, float viewDepth) {
+  if (shadow.directionalLightCount == 0 || viewDepth <= 0.0) return 1.0;
+  DirectionalShadowLightUniform light = shadow.directionalLights[0];
+  if (viewDepth >= light.shadowDistance) return 1.0;
+  vec3 position = worldPosition + normalize(worldNormal) * light.normalBias;
+  int cascadeIndex = shadow_directionalCascadeIndex(viewDepth);
+  float visibility = shadow_directionalPCSS(cascadeIndex, position, viewDepth);
+  if (cascadeIndex + 1 < shadow.cascadeCount) {
+    float cascadeStart = cascadeIndex > 0 ? shadow.cascadeSplits[cascadeIndex - 1] : 0.0;
+    float cascadeEnd = shadow.cascadeSplits[cascadeIndex];
+    float blendWidth = max((cascadeEnd - cascadeStart) * light.cascadeBlendFraction, 0.0001);
+    float blend = smoothstep(cascadeEnd - blendWidth, cascadeEnd, viewDepth);
+    if (blend > 0.0) visibility = mix(visibility, shadow_directionalPCSS(cascadeIndex + 1, position, viewDepth), blend);
+  }
+  float fadeWidth = max(light.shadowDistance * light.farFadeFraction, 0.0001);
+  visibility = mix(visibility, 1.0, smoothstep(light.shadowDistance - fadeWidth, light.shadowDistance, viewDepth));
+  return mix(1.0, visibility, light.strength);
+}
+float shadow_getSpotFactor(int lightIndex, vec3 worldPosition, vec3 worldNormal) {
+  if (lightIndex < 0 || lightIndex >= shadow.spotLightCount) return 1.0;
+  SpotShadowLightUniform light = shadow.spotLights[lightIndex];
+  vec3 fromLight = worldPosition - light.position;
+  float distanceToLight = length(fromLight);
+  if (distanceToLight >= light.range || dot(normalize(fromLight), normalize(light.direction)) < light.outerConeCos) return 1.0;
+  vec3 position = worldPosition + normalize(worldNormal) * light.normalBias;
+  float visibility = shadow_arrayPCSS(spotShadowTexture, lightIndex,
+    shadow_project(shadow.spotViewProjectionMatrices[lightIndex], position),
+    light.sourceRadius / max(distanceToLight, 0.001) * 0.5,
+    shadow_hash(worldPosition) * 2.0 * SHADOW_PI, 16.0);
+  return mix(1.0, visibility, light.strength);
+}
+float shadow_pointReferenceDepth(float majorDistance, float nearPlane, float farPlane) {
+  return farPlane / (farPlane - nearPlane) - (farPlane * nearPlane) / ((farPlane - nearPlane) * majorDistance);
+}
+vec3 shadow_pointCoordinate(int lightIndex, vec3 direction) {
+  vec3 magnitude = abs(direction);
+  int face = magnitude.x >= magnitude.y && magnitude.x >= magnitude.z ? (direction.x >= 0.0 ? 0 : 1)
+    : magnitude.y >= magnitude.z ? (direction.y >= 0.0 ? 2 : 3) : (direction.z >= 0.0 ? 4 : 5);
+  PointShadowLightUniform light = shadow.pointLights[lightIndex];
+  vec3 projected = shadow_project(shadow.pointViewProjectionMatrices[lightIndex * 6 + face], light.position + direction * light.range * 0.5);
+  return vec3(projected.xy, float(lightIndex * 6 + face));
+}
+float shadow_getPointFactor(int lightIndex, vec3 worldPosition, vec3 worldNormal) {
+  if (lightIndex < 0 || lightIndex >= shadow.pointLightCount) return 1.0;
+  PointShadowLightUniform light = shadow.pointLights[lightIndex];
+  vec3 fromLight = worldPosition + normalize(worldNormal) * light.normalBias - light.position;
+  float distanceToLight = length(fromLight);
+  if (distanceToLight >= light.range || distanceToLight <= light.nearPlane) return 1.0;
+  vec3 direction = normalize(fromLight);
+  float referenceDepth = shadow_pointReferenceDepth(max(max(abs(fromLight.x), abs(fromLight.y)), abs(fromLight.z)), light.nearPlane, light.range);
+  vec3 reference = abs(direction.y) > 0.99 ? vec3(0,0,1) : vec3(0,1,0);
+  vec3 tangent = normalize(cross(direction, reference));
+  vec3 bitangent = normalize(cross(direction, tangent));
+  float searchRadius = light.sourceRadius / max(distanceToLight, 0.001);
+  float rotation = shadow_hash(worldPosition) * 2.0 * SHADOW_PI;
+  float blockerDepth = 0.0;
+  float blockerCount = 0.0;
+  for (int index = 0; index < 24; index++) {
+    if (index >= shadow.blockerSampleCount) break;
+    vec2 disk = shadow_diskSample(index, shadow.blockerSampleCount, rotation) * searchRadius;
+    vec3 coordinate = shadow_pointCoordinate(lightIndex, normalize(direction + tangent * disk.x + bitangent * disk.y));
+    float depth = textureLod(pointShadowTexture, coordinate, 0.0).r;
+    if (depth < referenceDepth) { blockerDepth += depth; blockerCount += 1.0; }
+  }
+  if (blockerCount == 0.0) return 1.0;
+  float averageBlocker = blockerDepth / blockerCount;
+  float penumbra = clamp((referenceDepth - averageBlocker) / max(abs(averageBlocker), 0.001), 0.0, 1.0);
+  float radius = searchRadius * (1.0 + penumbra * 12.0);
+  float visibility = 0.0;
+  for (int index = 0; index < 48; index++) {
+    if (index >= shadow.filterSampleCount) break;
+    vec2 disk = shadow_diskSample(index, shadow.filterSampleCount, rotation) * radius;
+    vec3 coordinate = shadow_pointCoordinate(lightIndex, normalize(direction + tangent * disk.x + bitangent * disk.y));
+    visibility += shadow_compare(pointShadowTexture, coordinate.xy, int(coordinate.z), referenceDepth);
+  }
+  return mix(1.0, visibility / max(float(shadow.filterSampleCount), 1.0), light.strength);
+}
+`;
+//# sourceMappingURL=shadow-glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-glsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/shadow/shadow-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D,mGAAmG;AACnG,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsMrC,CAAC"}

package/dist/modules/lighting/shadow/shadow-types.cjs

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 shadow_types_exports = {};
+module.exports = __toCommonJS(shadow_types_exports);

package/dist/modules/lighting/shadow/shadow-types.d.ts

@@ -0,0 +1,63 @@
+import type { Matrix4, NumberArray3, NumberArray16 } from '@math.gl/core';
+/** Minimal texture metadata used to select backend-specific sampler bindings. */
+export type ShadowTexture = {
+    readonly device: {
+        readonly type: string;
+    };
+};
+export type ShadowBiasProps = {
+    /** Receiver displacement along the world-space normal. */
+    normalBias?: number;
+    /** Constant raster depth bias applied by the caster pipeline. */
+    depthBias?: number;
+    /** Slope-scaled raster depth bias applied by the caster pipeline. */
+    depthBiasSlopeScale?: number;
+    /** Fraction of the direct-light contribution affected by the shadow. */
+    strength?: number;
+};
+/** Directional light shadow configuration. `direction` points from a surface toward the light. */
+export type DirectionalShadowLight = ShadowBiasProps & {
+    direction: Readonly<NumberArray3>;
+    shadowDistance?: number;
+    casterDistance?: number;
+    sourceAngularRadius?: number;
+    cascadeSplitLambda?: number;
+    cascadeBlendFraction?: number;
+    farFadeFraction?: number;
+};
+/** Perspective shadow configuration for a spot light. */
+export type SpotShadowLight = ShadowBiasProps & {
+    position: Readonly<NumberArray3>;
+    direction: Readonly<NumberArray3>;
+    range: number;
+    outerConeAngle: number;
+    nearPlane?: number;
+    sourceRadius?: number;
+};
+/** Cube-array shadow configuration for an omnidirectional point light. */
+export type PointShadowLight = ShadowBiasProps & {
+    position: Readonly<NumberArray3>;
+    range: number;
+    nearPlane?: number;
+    sourceRadius?: number;
+};
+/** Fully resolved props returned by the renderer and consumed by the `shadow` shader module. */
+export type ShadowProps<TextureT extends ShadowTexture = ShadowTexture, SamplerT = unknown> = {
+    quality: 'low' | 'balanced' | 'cinematic';
+    cascadeCount: number;
+    cascadeSplits: readonly number[];
+    blockerSampleCount: number;
+    filterSampleCount: number;
+    directionalLights: readonly DirectionalShadowLight[];
+    spotLights: readonly SpotShadowLight[];
+    pointLights: readonly PointShadowLight[];
+    directionalViewProjectionMatrices: readonly Readonly<Matrix4 | NumberArray16>[];
+    spotViewProjectionMatrices: readonly Readonly<Matrix4 | NumberArray16>[];
+    pointViewProjectionMatrices: readonly Readonly<Matrix4 | NumberArray16>[];
+    directionalShadowTexture: TextureT;
+    spotShadowTexture: TextureT;
+    pointShadowTexture: TextureT;
+    comparisonSampler: SamplerT;
+    nonFilteringSampler: SamplerT;
+};
+//# sourceMappingURL=shadow-types.d.ts.map

package/dist/modules/lighting/shadow/shadow-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-types.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/shadow/shadow-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAC,MAAM,eAAe,CAAC;AAExE,iFAAiF;AACjF,MAAM,MAAM,aAAa,GAAG;IAAC,QAAQ,CAAC,MAAM,EAAE;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAA;CAAC,CAAC;AAEvE,MAAM,MAAM,eAAe,GAAG;IAC5B,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,kGAAkG;AAClG,MAAM,MAAM,sBAAsB,GAAG,eAAe,GAAG;IACrD,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG;IAC9C,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACjC,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,0EAA0E;AAC1E,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG;IAC/C,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,gGAAgG;AAChG,MAAM,MAAM,WAAW,CAAC,QAAQ,SAAS,aAAa,GAAG,aAAa,EAAE,QAAQ,GAAG,OAAO,IAAI;IAC5F,OAAO,EAAE,KAAK,GAAG,UAAU,GAAG,WAAW,CAAC;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACrD,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;IACvC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACzC,iCAAiC,EAAE,SAAS,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,CAAC;IAChF,0BAA0B,EAAE,SAAS,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,CAAC;IACzE,2BAA2B,EAAE,SAAS,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,CAAC;IAC1E,wBAAwB,EAAE,QAAQ,CAAC;IACnC,iBAAiB,EAAE,QAAQ,CAAC;IAC5B,kBAAkB,EAAE,QAAQ,CAAC;IAC7B,iBAAiB,EAAE,QAAQ,CAAC;IAC5B,mBAAmB,EAAE,QAAQ,CAAC;CAC/B,CAAC"}

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

@@ -0,0 +1,5 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export {};
+//# sourceMappingURL=shadow-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-types.js","sourceRoot":"","sources":["../../../../src/modules/lighting/shadow/shadow-types.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D"}