@luma.gl/shaders 0.0.0-stage → 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/surface-weather/surface-weather.cjs

@@ -0,0 +1,199 @@
+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 surface_weather_exports = {};
+__export(surface_weather_exports, {
+  integrateSurfaceWeather: () => integrateSurfaceWeather,
+  surfaceWeather: () => surfaceWeather
+});
+module.exports = __toCommonJS(surface_weather_exports);
+var import_value_noise = require("../../math/value-noise/value-noise.cjs");
+function integrateSurfaceWeather(state, rates, elapsedSeconds) {
+  function integrate(value, incoming, outgoing) {
+    const total = Math.max(incoming, 0) + Math.max(outgoing, 0);
+    const bounded = Math.min(1, Math.max(0, value));
+    if (total === 0 || elapsedSeconds <= 0)
+      return bounded;
+    const target = Math.max(incoming, 0) / total;
+    return target + (bounded - target) * Math.exp(-total * Math.max(elapsedSeconds, 0));
+  }
+  return {
+    wetness: integrate(state.wetness, rates.rainfall, rates.evaporation),
+    snow: integrate(state.snow, rates.snowfall, rates.snowmelt)
+  };
+}
+const DEFAULT_UNIFORMS = {
+  wetness: 0,
+  snow: 0,
+  puddles: 0.8,
+  scale: 20,
+  snowColor: [0.9, 0.94, 0.98],
+  skyColor: [0.48, 0.6, 0.72]
+};
+const surfaceWeather = {
+  name: "surfaceWeather",
+  dependencies: [import_value_noise.valueNoise],
+  uniformTypes: {
+    wetness: "f32",
+    snow: "f32",
+    puddles: "f32",
+    scale: "f32",
+    snowColor: "vec3<f32>",
+    skyColor: "vec3<f32>"
+  },
+  defaultUniforms: DEFAULT_UNIFORMS,
+  getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+    return { ...DEFAULT_UNIFORMS, ...previousUniforms, ...props };
+  },
+  fs: (
+    /* glsl */
+    `
+layout(std140) uniform surfaceWeatherUniforms {
+  float wetness;
+  float snow;
+  float puddles;
+  float scale;
+  vec3 snowColor;
+  vec3 skyColor;
+} surfaceWeather;
+
+float surfaceWeather_getSnow(vec3 position, vec3 normal, float exposure) {
+  if (surfaceWeather.snow <= 0.0 || exposure <= 0.0) return 0.0;
+  float slope = smoothstep(0.4, 0.85, normalize(normal).z);
+  float variation = valueNoise_noise(position.xy / max(surfaceWeather.scale, 0.01));
+  float coverage = smoothstep(variation * 0.65, variation * 0.65 + 0.35, surfaceWeather.snow);
+  return coverage * slope * clamp(exposure, 0.0, 1.0);
+}
+float surfaceWeather_getWetness(vec3 position, vec3 normal, float exposure) {
+  if (surfaceWeather.wetness <= 0.0 || exposure <= 0.0) return 0.0;
+  return clamp(surfaceWeather.wetness, 0.0, 1.0) * clamp(exposure, 0.0, 1.0) * (1.0 - surfaceWeather_getSnow(position, normal, exposure));
+}
+float surfaceWeather_getPuddle(vec3 position, vec3 normal, float exposure) {
+  if (surfaceWeather.wetness <= 0.0 || surfaceWeather.puddles <= 0.0 || exposure <= 0.0) return 0.0;
+  float variation = valueNoise_noise(position.xy / max(surfaceWeather.scale, 0.01) + vec2(8.3, 2.7));
+  return surfaceWeather_getWetness(position, normal, exposure) * clamp(surfaceWeather.puddles, 0.0, 1.0) *
+    smoothstep(0.8, 0.98, normalize(normal).z) * smoothstep(0.38, 0.7, variation);
+}
+vec3 surfaceWeather_getAlbedo(vec3 albedo, vec3 position, vec3 normal, float exposure) {
+  if ((surfaceWeather.wetness <= 0.0 && surfaceWeather.snow <= 0.0) || exposure <= 0.0) return albedo;
+  float wetness = surfaceWeather_getWetness(position, normal, exposure);
+  float snow = surfaceWeather_getSnow(position, normal, exposure);
+  return mix(albedo * (1.0 - wetness * 0.38), surfaceWeather.snowColor, snow);
+}
+float surfaceWeather_getRoughness(float roughness, vec3 position, vec3 normal, float exposure) {
+  if ((surfaceWeather.wetness <= 0.0 && surfaceWeather.snow <= 0.0) || exposure <= 0.0) return roughness;
+  float wetness = surfaceWeather_getWetness(position, normal, exposure);
+  float puddle = surfaceWeather_getPuddle(position, normal, exposure);
+  float snow = surfaceWeather_getSnow(position, normal, exposure);
+  return mix(mix(roughness, 0.16, max(puddle, wetness * 0.6)), 0.95, snow);
+}
+// Approximate dielectric highlights and sky tint; callers may use the albedo/roughness helpers with PBR instead.
+vec3 surfaceWeather_getReflection(vec3 position, vec3 normal, vec3 camera, vec3 lightDirection, vec3 lightColor, float exposure) {
+  if (surfaceWeather.wetness <= 0.0 || exposure <= 0.0) return vec3(0.0);
+  vec3 surfaceNormal = normalize(normal);
+  vec3 view = normalize(camera - position);
+  vec3 halfway = normalize(view + normalize(lightDirection));
+  float wetness = surfaceWeather_getWetness(position, normal, exposure);
+  float puddle = surfaceWeather_getPuddle(position, normal, exposure);
+  float facing = max(dot(surfaceNormal, view), 0.0);
+  float fresnel = 0.02 + 0.98 * pow(1.0 - facing, 5.0);
+  float highlight = pow(max(dot(surfaceNormal, halfway), 0.0), mix(36.0, 160.0, puddle)) * max(dot(surfaceNormal, normalize(lightDirection)), 0.0);
+  return wetness * (surfaceWeather.skyColor * fresnel * (0.15 + puddle * 0.85) + lightColor * highlight * 0.6);
+}
+`
+  ),
+  source: (
+    /* wgsl */
+    `
+struct surfaceWeatherUniforms {
+  wetness: f32,
+  snow: f32,
+  puddles: f32,
+  scale: f32,
+  snowColor: vec3f,
+  skyColor: vec3f,
+};
+@group(3) @binding(auto) var<uniform> surfaceWeather: surfaceWeatherUniforms;
+
+fn surfaceWeather_getSnow(position: vec3f,
+  normal: vec3f,
+  exposure: f32) -> f32 {
+  if (surfaceWeather.snow <= 0.0 || exposure <= 0.0) { return 0.0; }
+  var slope: f32 = smoothstep(0.4, 0.85, normalize(normal).z);
+  var variation: f32 = valueNoise_noise(position.xy / max(surfaceWeather.scale, 0.01));
+  var coverage: f32 = smoothstep(variation * 0.65, variation * 0.65 + 0.35, surfaceWeather.snow);
+  return coverage * slope * clamp(exposure, 0.0, 1.0);
+}
+fn surfaceWeather_getWetness(position: vec3f,
+  normal: vec3f,
+  exposure: f32) -> f32 {
+  if (surfaceWeather.wetness <= 0.0 || exposure <= 0.0) { return 0.0; }
+  return clamp(surfaceWeather.wetness, 0.0, 1.0) * clamp(exposure, 0.0, 1.0) * (1.0 - surfaceWeather_getSnow(position, normal, exposure));
+}
+fn surfaceWeather_getPuddle(position: vec3f,
+  normal: vec3f,
+  exposure: f32) -> f32 {
+  if (surfaceWeather.wetness <= 0.0 || surfaceWeather.puddles <= 0.0 || exposure <= 0.0) { return 0.0; }
+  var variation: f32 = valueNoise_noise(position.xy / max(surfaceWeather.scale, 0.01) + vec2f(8.3, 2.7));
+  return surfaceWeather_getWetness(position, normal, exposure) * clamp(surfaceWeather.puddles, 0.0, 1.0) *
+    smoothstep(0.8, 0.98, normalize(normal).z) * smoothstep(0.38, 0.7, variation);
+}
+fn surfaceWeather_getAlbedo(albedo: vec3f,
+  position: vec3f,
+  normal: vec3f,
+  exposure: f32) -> vec3f {
+  if ((surfaceWeather.wetness <= 0.0 && surfaceWeather.snow <= 0.0) || exposure <= 0.0) { return albedo; }
+  var wetness: f32 = surfaceWeather_getWetness(position, normal, exposure);
+  var snow: f32 = surfaceWeather_getSnow(position, normal, exposure);
+  return mix(albedo * (1.0 - wetness * 0.38), surfaceWeather.snowColor, snow);
+}
+fn surfaceWeather_getRoughness(roughness: f32,
+  position: vec3f,
+  normal: vec3f,
+  exposure: f32) -> f32 {
+  if ((surfaceWeather.wetness <= 0.0 && surfaceWeather.snow <= 0.0) || exposure <= 0.0) { return roughness; }
+  var wetness: f32 = surfaceWeather_getWetness(position, normal, exposure);
+  var puddle: f32 = surfaceWeather_getPuddle(position, normal, exposure);
+  var snow: f32 = surfaceWeather_getSnow(position, normal, exposure);
+  return mix(mix(roughness, 0.16, max(puddle, wetness * 0.6)), 0.95, snow);
+}
+// Approximate dielectric highlights and sky tint; callers may use the albedo/roughness helpers with PBR instead.
+fn surfaceWeather_getReflection(position: vec3f,
+  normal: vec3f,
+  camera: vec3f,
+  lightDirection: vec3f,
+  lightColor: vec3f,
+  exposure: f32) -> vec3f {
+  if (surfaceWeather.wetness <= 0.0 || exposure <= 0.0) { return vec3f(0.0); }
+  var surfaceNormal: vec3f = normalize(normal);
+  var view: vec3f = normalize(camera - position);
+  var halfway: vec3f = normalize(view + normalize(lightDirection));
+  var wetness: f32 = surfaceWeather_getWetness(position, normal, exposure);
+  var puddle: f32 = surfaceWeather_getPuddle(position, normal, exposure);
+  var facing: f32 = max(dot(surfaceNormal, view), 0.0);
+  var fresnel: f32 = 0.02 + 0.98 * pow(1.0 - facing, 5.0);
+  var highlight: f32 = pow(max(dot(surfaceNormal, halfway), 0.0), mix(36.0, 160.0, puddle)) * max(dot(surfaceNormal, normalize(lightDirection)), 0.0);
+  return wetness * (surfaceWeather.skyColor * fresnel * (0.15 + puddle * 0.85) + lightColor * highlight * 0.6);
+}
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  integrateSurfaceWeather,
+  surfaceWeather
+});