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

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/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/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

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

@@ -0,0 +1 @@
+{"version":3,"file":"river-water-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/water-material/river-water-material.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAItE,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,sFAAsF;IACtF,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,qFAAqF;IACrF,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,sFAAsF;IACtF,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,qFAAqF;IACrF,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C,CAAC;AAEF,2FAA2F;AAC3F,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,uBAAuB,EAAE,0BAA0B,CA6B9F,CAAC"}

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

@@ -0,0 +1,36 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { waterMaterial } from "./water-material.js";
+import { RIVER_WATER_GLSL, RIVER_WATER_WGSL } from "./river-water-shaders.js";
+/** A layered, animated river surface variant built on top of the shared water uniforms. */
+export const riverWaterMaterial = {
+    name: 'riverWaterMaterial',
+    firstBindingSlot: 1,
+    bindingLayout: [{ name: 'riverWaterMaterial', group: 3 }],
+    dependencies: [waterMaterial],
+    source: RIVER_WATER_WGSL,
+    fs: 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]
+        };
+    }
+};
+//# sourceMappingURL=river-water-material.js.map

package/dist/modules/lighting/water-material/river-water-material.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"river-water-material.js","sourceRoot":"","sources":["../../../../src/modules/lighting/water-material/river-water-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAG5D,OAAO,EAAC,aAAa,EAAC,4BAAyB;AAC/C,OAAO,EAAC,gBAAgB,EAAE,gBAAgB,EAAC,iCAA8B;AAqBzE,2FAA2F;AAC3F,MAAM,CAAC,MAAM,kBAAkB,GAC7B;IACE,IAAI,EAAE,oBAAoB;IAC1B,gBAAgB,EAAE,CAAC;IACnB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IACvD,YAAY,EAAE,CAAC,aAAa,CAAC;IAC7B,MAAM,EAAE,gBAAgB;IACxB,EAAE,EAAE,gBAAgB;IACpB,YAAY,EAAE;QACZ,OAAO,EAAE,KAAK;QACd,aAAa,EAAE,WAAW;QAC1B,cAAc,EAAE,WAAW;QAC3B,cAAc,EAAE,WAAW;KAC5B;IACD,eAAe,EAAE;QACf,OAAO,EAAE,CAAC;QACV,aAAa,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QACrB,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;QAClC,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;KAC1B;IACD,WAAW,CAAC,KAAK,GAAG,EAAE,EAAE,gBAAgB,GAAG,EAAE;QAC3C,OAAO;YACL,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,gBAAgB,CAAC,OAAO,IAAI,CAAC;YACvD,aAAa,EAAE,KAAK,CAAC,aAAa,IAAI,gBAAgB,CAAC,aAAa,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;YAC9E,cAAc,EAAE,KAAK,CAAC,cAAc;gBAClC,gBAAgB,CAAC,cAAc,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;YACvD,cAAc,EAAE,KAAK,CAAC,cAAc,IAAI,gBAAgB,CAAC,cAAc,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;SACrF,CAAC;IACJ,CAAC;CACF,CAAC"}