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

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.js

@@ -0,0 +1,129 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export const PHONG_WGSL = /* wgsl */ `\
+struct phongMaterialUniforms {
+  unlit: u32,
+  ambient: f32,
+  diffuse: f32,
+  shininess: f32,
+  specularColor: vec3<f32>,
+};
+
+@group(3) @binding(auto) var<uniform> phongMaterial : phongMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
+  var lambertian: f32 = dot(light_direction, normal_worldspace);
+  var specular: f32 = 0.0;
+  if (lambertian > 0.0) {
+    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, phongMaterial.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (
+    lambertian * phongMaterial.diffuse * surfaceColor +
+    specular * floatColors_normalize(phongMaterial.specularColor)
+  ) * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (phongMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
+  lightColor = phongMaterial.ambient * surfaceColor * lighting.ambientColor;
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight: PointLight = lighting_getPointLight(i);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(light_position_worldspace, position_worldspace)
+    );
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      view_direction,
+      normal_worldspace,
+      pointLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight: SpotLight = lighting_getSpotLight(i);
+    let light_position_worldspace: vec3<f32> = spotLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      view_direction,
+      normal_worldspace,
+      spotLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }  
+  
+  return lightColor;
+}
+
+fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{
+  var lightColor = vec3<f32>(0, 0, 0);
+  let surfaceColor = vec3<f32>(0, 0, 0);
+
+  if (lighting.enabled != 0) {
+    let view_direction = normalize(cameraPosition - position_worldspace);
+
+    for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+      let pointLight: PointLight = lighting_getPointLight(i);
+      let light_position_worldspace: vec3<f32> = pointLight.position;
+      let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+      let light_attenuation = getPointLightAttenuation(
+        pointLight,
+        distance(light_position_worldspace, position_worldspace)
+      );
+      lightColor += lighting_getLightColor(
+        surfaceColor,
+        light_direction,
+        view_direction,
+        normal_worldspace,
+        pointLight.color / light_attenuation
+      );
+    }
+
+    for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+      let spotLight: SpotLight = lighting_getSpotLight(i);
+      let light_position_worldspace: vec3<f32> = spotLight.position;
+      let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+      let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+      lightColor += lighting_getLightColor(
+        surfaceColor,
+        light_direction,
+        view_direction,
+        normal_worldspace,
+        spotLight.color / light_attenuation
+      );
+    }
+
+    for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+        let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
+        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+  return lightColor;
+}
+`;
+//# sourceMappingURL=phong-shaders-wgsl.js.map

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.js.map

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

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
+});

package/dist/modules/lighting/surface-weather/surface-weather.d.ts

@@ -0,0 +1,54 @@
+export type SurfaceWeatherState = {
+    wetness: number;
+    snow: number;
+};
+export type SurfaceWeatherUniforms = SurfaceWeatherState & {
+    puddles: number;
+    /** World-anchored patch size in metres. */
+    scale: number;
+    snowColor: [number, number, number];
+    skyColor: [number, number, number];
+};
+export type SurfaceWeatherProps = Partial<SurfaceWeatherUniforms>;
+export type SurfaceWeatherRates = {
+    /** Per-second rates; precipitation fills the remaining capacity. */
+    rainfall: number;
+    snowfall: number;
+    evaporation: number;
+    snowmelt: number;
+};
+/** Exact integration of bounded accumulation/decay for a constant-rate interval.
+ * Caller owns the state, clock, rates and any spatial exposure map. Pausing requires no GPU state.
+ */
+export declare function integrateSurfaceWeather(state: Readonly<SurfaceWeatherState>, rates: Readonly<SurfaceWeatherRates>, elapsedSeconds: number): SurfaceWeatherState;
+/** Material helpers for persistent wetness, puddles and upward-facing snow.
+ * Every helper accepts a caller-provided exposure mask, so water and sheltered surfaces can opt out.
+ */
+export declare const surfaceWeather: {
+    readonly name: "surfaceWeather";
+    readonly dependencies: [{
+        readonly name: "valueNoise";
+        readonly fs: "\nfloat valueNoise_hash(vec2 cell) {\n  vec3 value = fract(vec3(cell.x, cell.y, cell.x) * 0.1031);\n  value += dot(value, value.yzx + 33.33);\n  return fract((value.x + value.y) * value.z);\n}\nfloat valueNoise_noise(vec2 position) {\n  vec2 cell = floor(position);\n  vec2 fraction = fract(position);\n  vec2 blend = fraction * fraction * (3.0 - 2.0 * fraction);\n  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2(1.0, 0.0)), blend.x),\n    mix(valueNoise_hash(cell + vec2(0.0, 1.0)), valueNoise_hash(cell + vec2(1.0)), blend.x), blend.y);\n}\n\nfloat valueNoise_hash3(vec3 cell) {\n  vec3 value = fract(cell * 0.1031);\n  value += dot(value, value.yzx + 33.33);\n  return fract((value.x + value.y) * value.z);\n}\nfloat valueNoise_noise3(vec3 position) {\n  vec3 cell = floor(position);\n  vec3 fraction = fract(position);\n  vec3 blend = fraction * fraction * (3.0 - 2.0 * fraction);\n  float bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3(1.0, 0.0, 0.0)), blend.x),\n    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3(1.0, 1.0, 0.0)), blend.x), blend.y);\n  float top = mix(mix(valueNoise_hash3(cell + vec3(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3(1.0, 0.0, 1.0)), blend.x),\n    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3(1.0)), blend.x), blend.y);\n  return mix(bottom, top, blend.z);\n}\n";
+        readonly source: "\nfn valueNoise_hash(cell: vec2f) -> f32 {\n  var value = fract(vec3f(cell.x, cell.y, cell.x) * 0.1031);\n  value += vec3f(dot(value, value.yzx + vec3f(33.33)));\n  return fract((value.x + value.y) * value.z);\n}\nfn valueNoise_noise(position: vec2f) -> f32 {\n  let cell = floor(position);\n  let fraction = fract(position);\n  let blend = fraction * fraction * (vec2f(3.0) - 2.0 * fraction);\n  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2f(1.0, 0.0)), blend.x),\n    mix(valueNoise_hash(cell + vec2f(0.0, 1.0)), valueNoise_hash(cell + vec2f(1.0)), blend.x), blend.y);\n}\n\nfn valueNoise_hash3(cell: vec3f) -> f32 {\n  var value = fract(cell * 0.1031);\n  value += vec3f(dot(value, value.yzx + vec3f(33.33)));\n  return fract((value.x + value.y) * value.z);\n}\nfn valueNoise_noise3(position: vec3f) -> f32 {\n  let cell = floor(position);\n  let fraction = fract(position);\n  let blend = fraction * fraction * (vec3f(3.0) - 2.0 * fraction);\n  let bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3f(1.0, 0.0, 0.0)), blend.x),\n    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3f(1.0, 1.0, 0.0)), blend.x), blend.y);\n  let top = mix(mix(valueNoise_hash3(cell + vec3f(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0, 0.0, 1.0)), blend.x),\n    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0)), blend.x), blend.y);\n  return mix(bottom, top, blend.z);\n}\n";
+    }];
+    readonly uniformTypes: {
+        readonly wetness: "f32";
+        readonly snow: "f32";
+        readonly puddles: "f32";
+        readonly scale: "f32";
+        readonly snowColor: "vec3<f32>";
+        readonly skyColor: "vec3<f32>";
+    };
+    readonly defaultUniforms: SurfaceWeatherUniforms;
+    readonly getUniforms: (props?: Partial<Partial<SurfaceWeatherUniforms>>, previousUniforms?: SurfaceWeatherUniforms | undefined) => {
+        wetness: number;
+        snow: number;
+        puddles: number;
+        scale: number;
+        snowColor: [number, number, number];
+        skyColor: [number, number, number];
+    };
+    readonly fs: "\nlayout(std140) uniform surfaceWeatherUniforms {\n  float wetness;\n  float snow;\n  float puddles;\n  float scale;\n  vec3 snowColor;\n  vec3 skyColor;\n} surfaceWeather;\n\nfloat surfaceWeather_getSnow(vec3 position, vec3 normal, float exposure) {\n  if (surfaceWeather.snow <= 0.0 || exposure <= 0.0) return 0.0;\n  float slope = smoothstep(0.4, 0.85, normalize(normal).z);\n  float variation = valueNoise_noise(position.xy / max(surfaceWeather.scale, 0.01));\n  float coverage = smoothstep(variation * 0.65, variation * 0.65 + 0.35, surfaceWeather.snow);\n  return coverage * slope * clamp(exposure, 0.0, 1.0);\n}\nfloat surfaceWeather_getWetness(vec3 position, vec3 normal, float exposure) {\n  if (surfaceWeather.wetness <= 0.0 || exposure <= 0.0) return 0.0;\n  return clamp(surfaceWeather.wetness, 0.0, 1.0) * clamp(exposure, 0.0, 1.0) * (1.0 - surfaceWeather_getSnow(position, normal, exposure));\n}\nfloat surfaceWeather_getPuddle(vec3 position, vec3 normal, float exposure) {\n  if (surfaceWeather.wetness <= 0.0 || surfaceWeather.puddles <= 0.0 || exposure <= 0.0) return 0.0;\n  float variation = valueNoise_noise(position.xy / max(surfaceWeather.scale, 0.01) + vec2(8.3, 2.7));\n  return surfaceWeather_getWetness(position, normal, exposure) * clamp(surfaceWeather.puddles, 0.0, 1.0) *\n    smoothstep(0.8, 0.98, normalize(normal).z) * smoothstep(0.38, 0.7, variation);\n}\nvec3 surfaceWeather_getAlbedo(vec3 albedo, vec3 position, vec3 normal, float exposure) {\n  if ((surfaceWeather.wetness <= 0.0 && surfaceWeather.snow <= 0.0) || exposure <= 0.0) return albedo;\n  float wetness = surfaceWeather_getWetness(position, normal, exposure);\n  float snow = surfaceWeather_getSnow(position, normal, exposure);\n  return mix(albedo * (1.0 - wetness * 0.38), surfaceWeather.snowColor, snow);\n}\nfloat surfaceWeather_getRoughness(float roughness, vec3 position, vec3 normal, float exposure) {\n  if ((surfaceWeather.wetness <= 0.0 && surfaceWeather.snow <= 0.0) || exposure <= 0.0) return roughness;\n  float wetness = surfaceWeather_getWetness(position, normal, exposure);\n  float puddle = surfaceWeather_getPuddle(position, normal, exposure);\n  float snow = surfaceWeather_getSnow(position, normal, exposure);\n  return mix(mix(roughness, 0.16, max(puddle, wetness * 0.6)), 0.95, snow);\n}\n// Approximate dielectric highlights and sky tint; callers may use the albedo/roughness helpers with PBR instead.\nvec3 surfaceWeather_getReflection(vec3 position, vec3 normal, vec3 camera, vec3 lightDirection, vec3 lightColor, float exposure) {\n  if (surfaceWeather.wetness <= 0.0 || exposure <= 0.0) return vec3(0.0);\n  vec3 surfaceNormal = normalize(normal);\n  vec3 view = normalize(camera - position);\n  vec3 halfway = normalize(view + normalize(lightDirection));\n  float wetness = surfaceWeather_getWetness(position, normal, exposure);\n  float puddle = surfaceWeather_getPuddle(position, normal, exposure);\n  float facing = max(dot(surfaceNormal, view), 0.0);\n  float fresnel = 0.02 + 0.98 * pow(1.0 - facing, 5.0);\n  float highlight = pow(max(dot(surfaceNormal, halfway), 0.0), mix(36.0, 160.0, puddle)) * max(dot(surfaceNormal, normalize(lightDirection)), 0.0);\n  return wetness * (surfaceWeather.skyColor * fresnel * (0.15 + puddle * 0.85) + lightColor * highlight * 0.6);\n}\n";
+    readonly source: "\nstruct surfaceWeatherUniforms {\n  wetness: f32,\n  snow: f32,\n  puddles: f32,\n  scale: f32,\n  snowColor: vec3f,\n  skyColor: vec3f,\n};\n@group(3) @binding(auto) var<uniform> surfaceWeather: surfaceWeatherUniforms;\n\nfn surfaceWeather_getSnow(position: vec3f,\n  normal: vec3f,\n  exposure: f32) -> f32 {\n  if (surfaceWeather.snow <= 0.0 || exposure <= 0.0) { return 0.0; }\n  var slope: f32 = smoothstep(0.4, 0.85, normalize(normal).z);\n  var variation: f32 = valueNoise_noise(position.xy / max(surfaceWeather.scale, 0.01));\n  var coverage: f32 = smoothstep(variation * 0.65, variation * 0.65 + 0.35, surfaceWeather.snow);\n  return coverage * slope * clamp(exposure, 0.0, 1.0);\n}\nfn surfaceWeather_getWetness(position: vec3f,\n  normal: vec3f,\n  exposure: f32) -> f32 {\n  if (surfaceWeather.wetness <= 0.0 || exposure <= 0.0) { return 0.0; }\n  return clamp(surfaceWeather.wetness, 0.0, 1.0) * clamp(exposure, 0.0, 1.0) * (1.0 - surfaceWeather_getSnow(position, normal, exposure));\n}\nfn surfaceWeather_getPuddle(position: vec3f,\n  normal: vec3f,\n  exposure: f32) -> f32 {\n  if (surfaceWeather.wetness <= 0.0 || surfaceWeather.puddles <= 0.0 || exposure <= 0.0) { return 0.0; }\n  var variation: f32 = valueNoise_noise(position.xy / max(surfaceWeather.scale, 0.01) + vec2f(8.3, 2.7));\n  return surfaceWeather_getWetness(position, normal, exposure) * clamp(surfaceWeather.puddles, 0.0, 1.0) *\n    smoothstep(0.8, 0.98, normalize(normal).z) * smoothstep(0.38, 0.7, variation);\n}\nfn surfaceWeather_getAlbedo(albedo: vec3f,\n  position: vec3f,\n  normal: vec3f,\n  exposure: f32) -> vec3f {\n  if ((surfaceWeather.wetness <= 0.0 && surfaceWeather.snow <= 0.0) || exposure <= 0.0) { return albedo; }\n  var wetness: f32 = surfaceWeather_getWetness(position, normal, exposure);\n  var snow: f32 = surfaceWeather_getSnow(position, normal, exposure);\n  return mix(albedo * (1.0 - wetness * 0.38), surfaceWeather.snowColor, snow);\n}\nfn surfaceWeather_getRoughness(roughness: f32,\n  position: vec3f,\n  normal: vec3f,\n  exposure: f32) -> f32 {\n  if ((surfaceWeather.wetness <= 0.0 && surfaceWeather.snow <= 0.0) || exposure <= 0.0) { return roughness; }\n  var wetness: f32 = surfaceWeather_getWetness(position, normal, exposure);\n  var puddle: f32 = surfaceWeather_getPuddle(position, normal, exposure);\n  var snow: f32 = surfaceWeather_getSnow(position, normal, exposure);\n  return mix(mix(roughness, 0.16, max(puddle, wetness * 0.6)), 0.95, snow);\n}\n// Approximate dielectric highlights and sky tint; callers may use the albedo/roughness helpers with PBR instead.\nfn surfaceWeather_getReflection(position: vec3f,\n  normal: vec3f,\n  camera: vec3f,\n  lightDirection: vec3f,\n  lightColor: vec3f,\n  exposure: f32) -> vec3f {\n  if (surfaceWeather.wetness <= 0.0 || exposure <= 0.0) { return vec3f(0.0); }\n  var surfaceNormal: vec3f = normalize(normal);\n  var view: vec3f = normalize(camera - position);\n  var halfway: vec3f = normalize(view + normalize(lightDirection));\n  var wetness: f32 = surfaceWeather_getWetness(position, normal, exposure);\n  var puddle: f32 = surfaceWeather_getPuddle(position, normal, exposure);\n  var facing: f32 = max(dot(surfaceNormal, view), 0.0);\n  var fresnel: f32 = 0.02 + 0.98 * pow(1.0 - facing, 5.0);\n  var highlight: f32 = pow(max(dot(surfaceNormal, halfway), 0.0), mix(36.0, 160.0, puddle)) * max(dot(surfaceNormal, normalize(lightDirection)), 0.0);\n  return wetness * (surfaceWeather.skyColor * fresnel * (0.15 + puddle * 0.85) + lightColor * highlight * 0.6);\n}\n";
+};
+//# sourceMappingURL=surface-weather.d.ts.map

package/dist/modules/lighting/surface-weather/surface-weather.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-weather.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/surface-weather/surface-weather.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,mBAAmB,GAAG;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC;AAClE,MAAM,MAAM,sBAAsB,GAAG,mBAAmB,GAAG;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG;IAChC,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,mBAAmB,CAAC,EACpC,KAAK,EAAE,QAAQ,CAAC,mBAAmB,CAAC,EACpC,cAAc,EAAE,MAAM,GACrB,mBAAmB,CAYrB;AAUD;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;iBAjDiB,MAAM;cAAQ,MAAM;iBAErD,MAAM;eAER,MAAM;mBACF,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;kBACzB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;;;;CAwL0C,CAAC"}

package/dist/modules/lighting/surface-weather/surface-weather.js

@@ -0,0 +1,175 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { valueNoise } from "../../math/value-noise/value-noise.js";
+/** Exact integration of bounded accumulation/decay for a constant-rate interval.
+ * Caller owns the state, clock, rates and any spatial exposure map. Pausing requires no GPU state.
+ */
+export 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]
+};
+/** Material helpers for persistent wetness, puddles and upward-facing snow.
+ * Every helper accepts a caller-provided exposure mask, so water and sheltered surfaces can opt out.
+ */
+export const surfaceWeather = {
+    name: 'surfaceWeather',
+    dependencies: [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);
+}
+`
+};
+//# sourceMappingURL=surface-weather.js.map

package/dist/modules/lighting/surface-weather/surface-weather.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-weather.js","sourceRoot":"","sources":["../../../../src/modules/lighting/surface-weather/surface-weather.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAG5D,OAAO,EAAC,UAAU,EAAC,8CAA2C;AAmB9D;;GAEG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAoC,EACpC,KAAoC,EACpC,cAAsB;IAEtB,SAAS,SAAS,CAAC,KAAa,EAAE,QAAgB,EAAE,QAAgB;QAClE,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QAC5D,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QAChD,IAAI,KAAK,KAAK,CAAC,IAAI,cAAc,IAAI,CAAC;YAAE,OAAO,OAAO,CAAC;QACvD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;QAC7C,OAAO,MAAM,GAAG,CAAC,OAAO,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC;IACtF,CAAC;IACD,OAAO;QACL,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,WAAW,CAAC;QACpE,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC;KAC5D,CAAC;AACJ,CAAC;AACD,MAAM,gBAAgB,GAA2B;IAC/C,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,GAAG;IACZ,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC;IAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,YAAY,EAAE,CAAC,UAAU,CAAC;IAC1B,YAAY,EAAE;QACZ,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,KAAK;QACX,OAAO,EAAE,KAAK;QACd,KAAK,EAAE,KAAK;QACZ,SAAS,EAAE,WAAW;QACtB,QAAQ,EAAE,WAAW;KACtB;IACD,eAAe,EAAE,gBAAgB;IACjC,WAAW,CAAC,KAAK,GAAG,EAAE,EAAE,gBAAgB,GAAG,gBAAgB;QACzD,OAAO,EAAC,GAAG,gBAAgB,EAAE,GAAG,gBAAgB,EAAE,GAAG,KAAK,EAAC,CAAC;IAC9D,CAAC;IACD,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEpB;CAC6E,CAAC"}

package/dist/modules/lighting/water-material/river-water-material.cjs

@@ -0,0 +1,56 @@
+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 river_water_material_exports = {};
+__export(river_water_material_exports, {
+  riverWaterMaterial: () => riverWaterMaterial
+});
+module.exports = __toCommonJS(river_water_material_exports);
+var import_water_material = require("./water-material.cjs");
+var import_river_water_shaders = require("./river-water-shaders.cjs");
+const riverWaterMaterial = {
+  name: "riverWaterMaterial",
+  firstBindingSlot: 1,
+  bindingLayout: [{ name: "riverWaterMaterial", group: 3 }],
+  dependencies: [import_water_material.waterMaterial],
+  source: import_river_water_shaders.RIVER_WATER_WGSL,
+  fs: import_river_water_shaders.RIVER_WATER_GLSL,
+  uniformTypes: {
+    enabled: "i32",
+    flowDirection: "vec2<f32>",
+    skyZenithColor: "vec3<f32>",
+    skyUpDirection: "vec3<f32>"
+  },
+  defaultUniforms: {
+    enabled: 0,
+    flowDirection: [0, 1],
+    skyZenithColor: [0.22, 0.48, 0.57],
+    skyUpDirection: [0, 0, 1]
+  },
+  getUniforms(props = {}, previousUniforms = {}) {
+    return {
+      enabled: props.enabled ?? previousUniforms.enabled ?? 0,
+      flowDirection: props.flowDirection ?? previousUniforms.flowDirection ?? [0, 1],
+      skyZenithColor: props.skyZenithColor ?? previousUniforms.skyZenithColor ?? [0.22, 0.48, 0.57],
+      skyUpDirection: props.skyUpDirection ?? previousUniforms.skyUpDirection ?? [0, 0, 1]
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  riverWaterMaterial
+});

package/dist/modules/lighting/water-material/river-water-material.d.ts

@@ -0,0 +1,21 @@
+import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type RiverWaterMaterialProps = {
+    enabled?: number;
+    /** Local east/north direction of river flow. */
+    flowDirection?: [number, number];
+    /** Linear sky tint above the horizon. The horizon uses waterMaterial.fresnelColor. */
+    skyZenithColor?: [number, number, number];
+    /** Unit up direction in the same coordinate frame as the supplied surface normal. */
+    skyUpDirection?: [number, number, number];
+};
+export type RiverWaterMaterialUniforms = {
+    enabled?: number;
+    flowDirection?: [number, number];
+    /** Linear sky tint above the horizon. The horizon uses waterMaterial.fresnelColor. */
+    skyZenithColor?: [number, number, number];
+    /** Unit up direction in the same coordinate frame as the supplied surface normal. */
+    skyUpDirection?: [number, number, number];
+};
+/** A layered, animated river surface variant built on top of the shared water uniforms. */
+export declare const riverWaterMaterial: ShaderModule<RiverWaterMaterialProps, RiverWaterMaterialUniforms>;
+//# sourceMappingURL=river-water-material.d.ts.map