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

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

@@ -0,0 +1,261 @@
+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_shaders_exports = {};
+__export(river_water_shaders_exports, {
+  RIVER_WATER_GLSL: () => RIVER_WATER_GLSL,
+  RIVER_WATER_WGSL: () => RIVER_WATER_WGSL
+});
+module.exports = __toCommonJS(river_water_shaders_exports);
+const RIVER_WATER_WGSL = (
+  /* wgsl */
+  `struct riverWaterMaterialUniforms {
+  enabled: i32,
+  flowDirection: vec2<f32>,
+  skyZenithColor: vec3<f32>,
+  skyUpDirection: vec3<f32>,
+};
+
+@group(3) @binding(auto) var<uniform> riverWaterMaterial : riverWaterMaterialUniforms;
+
+fn riverWater_getFlowCoordinates(coordinates: vec2<f32>) -> vec2<f32> {
+  let flowDirection = normalize(riverWaterMaterial.flowDirection);
+  let crossDirection = vec2<f32>(-flowDirection.y, flowDirection.x);
+  return vec2<f32>(dot(coordinates, crossDirection), dot(coordinates, flowDirection));
+}
+
+// Smooth spatial variation travels with the surface; it does not flicker per frame.
+fn riverWater_noise(coordinates: vec2<f32>) -> f32 {
+  let cell = floor(coordinates);
+  let fraction = fract(coordinates);
+  let blend = fraction * fraction * (vec2<f32>(3.0) - 2.0 * fraction);
+  let corners = vec4<f32>(
+    dot(cell, vec2<f32>(127.1, 311.7)),
+    dot(cell + vec2<f32>(1.0, 0.0), vec2<f32>(127.1, 311.7)),
+    dot(cell + vec2<f32>(0.0, 1.0), vec2<f32>(127.1, 311.7)),
+    dot(cell + vec2<f32>(1.0, 1.0), vec2<f32>(127.1, 311.7))
+  );
+  let values = fract(sin(corners) * 43758.5453);
+  return mix(mix(values.x, values.y, blend.x), mix(values.z, values.w, blend.x), blend.y);
+}
+
+fn riverWater_waveGradient(
+  coordinates: vec2<f32>,
+  direction: vec2<f32>,
+  frequency: f32,
+  amplitude: f32,
+  speed: f32,
+  phaseOffset: f32
+) -> vec2<f32> {
+  // Advect the irregular wave packets together with their carrier waves.
+  let movingCoordinates = coordinates + direction * (waterMaterial.time * speed / frequency);
+  let crossDirection = vec2<f32>(-direction.y, direction.x);
+  let variationCoordinates = vec2<f32>(dot(movingCoordinates, crossDirection), dot(movingCoordinates, direction)) * frequency * vec2<f32>(0.38, 0.16) + vec2<f32>(phaseOffset * 3.7);
+  let variation = riverWater_noise(variationCoordinates);
+  let detail = riverWater_noise(variationCoordinates * 2.13 + vec2<f32>(11.3, 7.9));
+  let envelope = smoothstep(0.12, 0.88, riverWater_noise(variationCoordinates * 0.71 + vec2<f32>(23.6, 5.2)));
+  let phase = dot(movingCoordinates, direction) * frequency + phaseOffset + (variation - 0.5) * 7.0 + (detail - 0.5) * 2.5;
+  let attenuation = 1.0 - smoothstep(0.8, 3.0, fwidth(phase));
+  return direction * (cos(phase) * frequency * amplitude * attenuation * (0.15 + envelope * 1.2));
+}
+
+fn riverWater_getNormal(
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec3<f32> {
+  let coordinates = riverWater_getFlowCoordinates(
+    water_getCoordinates(position_worldspace, position_objectspace, uv)
+  );
+  let driftCoordinates = coordinates * 0.7 + vec2<f32>(0.0, waterMaterial.time * 0.22);
+  let warp = (vec2<f32>(
+    riverWater_noise(driftCoordinates),
+    riverWater_noise(driftCoordinates + vec2<f32>(17.2, 9.4))
+  ) - vec2<f32>(0.5)) * 0.65;
+  let warpedCoordinates = coordinates + warp;
+  let gradient =
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(0.08, 1.0)), 2.1, 0.018, 1.25, 0.0) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(-0.28, 1.0)), 3.7, 0.018, 0.95, 1.7) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(0.47, 1.0)), 5.3, 0.012, 1.7, 3.2) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(-0.68, 1.0)), 7.9, 0.008, 0.76, 0.8) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(0.92, 1.0)), 11.6, 0.004, 2.2, 2.1) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(-1.22, 1.0)), 16.3, 0.002, 1.45, 2.8);
+  let tangent = water_getTangent(normalize(normal_worldspace));
+  let bitangent = normalize(cross(normalize(normal_worldspace), tangent));
+  return normalize(normal_worldspace + waterMaterial.normalStrength * 3.2 *
+    (gradient.x * tangent + gradient.y * bitangent));
+}
+
+// Camera-independent sky approximation; missing scene reflections retain this material color.
+fn riverWater_getSkyColor(reflectionDirection: vec3<f32>) -> vec3<f32> {
+  let elevation = clamp(dot(normalize(reflectionDirection), normalize(riverWaterMaterial.skyUpDirection)), 0.0, 1.0);
+  let horizonColor = mix(waterMaterial.fresnelColor, riverWaterMaterial.skyZenithColor, 0.32);
+  return mix(horizonColor, riverWaterMaterial.skyZenithColor, smoothstep(0.0, 1.0, elevation));
+}
+
+fn riverWater_getColorMapped(
+  cameraPosition: vec3<f32>,
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec4<f32> {
+  let waterNormal = riverWater_getNormal(
+    position_worldspace, position_objectspace, normal_worldspace, uv
+  );
+  let viewDirection = normalize(cameraPosition - position_worldspace);
+  let fresnel = pow(1.0 - max(dot(viewDirection, waterNormal), 0.0), 3.2);
+  let deepColor = waterMaterial.baseColor * vec3<f32>(0.52, 0.74, 0.9);
+  let reflectedColor = riverWater_getSkyColor(reflect(-viewDirection, waterNormal));
+  let surfaceColor = mix(deepColor, reflectedColor, clamp(fresnel * 0.78, 0.0, 0.78));
+  var color = surfaceColor * (0.32 + 0.68 * lighting.ambientColor);
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight = lighting_getDirectionalLight(i);
+    let lightDirection = normalize(-directionalLight.direction);
+    let halfwayDirection = normalize(lightDirection + viewDirection);
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+    let specular = pow(max(dot(waterNormal, halfwayDirection), 0.0), 64.0);
+    let brokenSpecular = specular * (0.25 + 0.75 * fresnel);
+    color += surfaceColor * directionalLight.color * diffuse * 0.38;
+    color += vec3<f32>(0.72, 0.88, 0.94) * directionalLight.color * brokenSpecular * 2.1;
+  }
+
+  color = mix(color, reflectedColor, clamp(fresnel * 0.3, 0.0, 0.3));
+  return vec4<f32>(color, waterMaterial.opacity);
+}
+`
+);
+const RIVER_WATER_GLSL = (
+  /* glsl */
+  `layout(std140) uniform riverWaterMaterialUniforms {
+  uniform int enabled;
+  uniform vec2 flowDirection;
+  uniform vec3 skyZenithColor;
+  uniform vec3 skyUpDirection;
+} riverWaterMaterial;
+
+vec2 riverWater_getFlowCoordinates(vec2 coordinates) {
+  vec2 flowDirection = normalize(riverWaterMaterial.flowDirection);
+  vec2 crossDirection = vec2(-flowDirection.y, flowDirection.x);
+  return vec2(dot(coordinates, crossDirection), dot(coordinates, flowDirection));
+}
+
+// Smooth spatial variation travels with the surface; it does not flicker per frame.
+float riverWater_noise(vec2 coordinates) {
+  vec2 cell = floor(coordinates);
+  vec2 fraction = fract(coordinates);
+  vec2 blend = fraction * fraction * (vec2(3.0) - 2.0 * fraction);
+  vec4 corners = vec4(
+    dot(cell, vec2(127.1, 311.7)),
+    dot(cell + vec2(1.0, 0.0), vec2(127.1, 311.7)),
+    dot(cell + vec2(0.0, 1.0), vec2(127.1, 311.7)),
+    dot(cell + vec2(1.0, 1.0), vec2(127.1, 311.7))
+  );
+  vec4 values = fract(sin(corners) * 43758.5453);
+  return mix(mix(values.x, values.y, blend.x), mix(values.z, values.w, blend.x), blend.y);
+}
+
+vec2 riverWater_waveGradient(
+  vec2 coordinates, vec2 direction, float frequency, float amplitude, float speed, float phaseOffset
+) {
+  // Advect the irregular wave packets together with their carrier waves.
+  vec2 movingCoordinates = coordinates + direction * (waterMaterial.time * speed / frequency);
+  vec2 crossDirection = vec2(-direction.y, direction.x);
+  vec2 variationCoordinates = vec2(dot(movingCoordinates, crossDirection), dot(movingCoordinates, direction)) * frequency * vec2(0.38, 0.16) + vec2(phaseOffset * 3.7);
+  float variation = riverWater_noise(variationCoordinates);
+  float detail = riverWater_noise(variationCoordinates * 2.13 + vec2(11.3, 7.9));
+  float envelope = smoothstep(0.12, 0.88, riverWater_noise(variationCoordinates * 0.71 + vec2(23.6, 5.2)));
+  float phase = dot(movingCoordinates, direction) * frequency + phaseOffset + (variation - 0.5) * 7.0 + (detail - 0.5) * 2.5;
+  float attenuation = 1.0 - smoothstep(0.8, 3.0, fwidth(phase));
+  return direction * (cos(phase) * frequency * amplitude * attenuation * (0.15 + envelope * 1.2));
+}
+
+vec3 riverWater_getNormal(
+  vec3 position_worldspace,
+  vec3 position_objectspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  vec2 coordinates = riverWater_getFlowCoordinates(
+    water_getCoordinates(position_worldspace, position_objectspace, uv)
+  );
+  vec2 driftCoordinates = coordinates * 0.7 + vec2(0.0, waterMaterial.time * 0.22);
+  vec2 warp = (vec2(
+    riverWater_noise(driftCoordinates),
+    riverWater_noise(driftCoordinates + vec2(17.2, 9.4))
+  ) - vec2(0.5)) * 0.65;
+  vec2 warpedCoordinates = coordinates + warp;
+  vec2 gradient =
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(0.08, 1.0)), 2.1, 0.018, 1.25, 0.0) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(-0.28, 1.0)), 3.7, 0.018, 0.95, 1.7) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(0.47, 1.0)), 5.3, 0.012, 1.7, 3.2) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(-0.68, 1.0)), 7.9, 0.008, 0.76, 0.8) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(0.92, 1.0)), 11.6, 0.004, 2.2, 2.1) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(-1.22, 1.0)), 16.3, 0.002, 1.45, 2.8);
+  vec3 tangent = water_getTangent(normalize(normal_worldspace));
+  vec3 bitangent = normalize(cross(normalize(normal_worldspace), tangent));
+  return normalize(normal_worldspace + waterMaterial.normalStrength * 3.2 *
+    (gradient.x * tangent + gradient.y * bitangent));
+}
+
+// Camera-independent sky approximation; missing scene reflections retain this material color.
+vec3 riverWater_getSkyColor(vec3 reflectionDirection) {
+  float elevation = clamp(dot(normalize(reflectionDirection), normalize(riverWaterMaterial.skyUpDirection)), 0.0, 1.0);
+  vec3 horizonColor = mix(waterMaterial.fresnelColor, riverWaterMaterial.skyZenithColor, 0.32);
+  return mix(horizonColor, riverWaterMaterial.skyZenithColor, smoothstep(0.0, 1.0, elevation));
+}
+
+vec4 riverWater_getColorMapped(
+  vec3 cameraPosition,
+  vec3 position_worldspace,
+  vec3 position_objectspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  vec3 waterNormal = riverWater_getNormal(
+    position_worldspace, position_objectspace, normal_worldspace, uv
+  );
+  vec3 viewDirection = normalize(cameraPosition - position_worldspace);
+  float fresnel = pow(1.0 - max(dot(viewDirection, waterNormal), 0.0), 3.2);
+  vec3 deepColor = waterMaterial.baseColor * vec3(0.52, 0.74, 0.9);
+  vec3 reflectedColor = riverWater_getSkyColor(reflect(-viewDirection, waterNormal));
+  vec3 surfaceColor = mix(deepColor, reflectedColor, clamp(fresnel * 0.78, 0.0, 0.78));
+  vec3 color = surfaceColor * (0.32 + 0.68 * lighting.ambientColor);
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    vec3 lightDirection = normalize(-directionalLight.direction);
+    vec3 halfwayDirection = normalize(lightDirection + viewDirection);
+    float diffuse = max(dot(waterNormal, lightDirection), 0.0);
+    float specular = pow(max(dot(waterNormal, halfwayDirection), 0.0), 64.0);
+    float brokenSpecular = specular * (0.25 + 0.75 * fresnel);
+    color += surfaceColor * directionalLight.color * diffuse * 0.38;
+    color += vec3(0.72, 0.88, 0.94) * directionalLight.color * brokenSpecular * 2.1;
+  }
+
+  color = mix(color, reflectedColor, clamp(fresnel * 0.3, 0.0, 0.3));
+  return vec4(color, waterMaterial.opacity);
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RIVER_WATER_GLSL,
+  RIVER_WATER_WGSL
+});

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

@@ -0,0 +1,3 @@
+export declare const RIVER_WATER_WGSL = "struct riverWaterMaterialUniforms {\n  enabled: i32,\n  flowDirection: vec2<f32>,\n  skyZenithColor: vec3<f32>,\n  skyUpDirection: vec3<f32>,\n};\n\n@group(3) @binding(auto) var<uniform> riverWaterMaterial : riverWaterMaterialUniforms;\n\nfn riverWater_getFlowCoordinates(coordinates: vec2<f32>) -> vec2<f32> {\n  let flowDirection = normalize(riverWaterMaterial.flowDirection);\n  let crossDirection = vec2<f32>(-flowDirection.y, flowDirection.x);\n  return vec2<f32>(dot(coordinates, crossDirection), dot(coordinates, flowDirection));\n}\n\n// Smooth spatial variation travels with the surface; it does not flicker per frame.\nfn riverWater_noise(coordinates: vec2<f32>) -> f32 {\n  let cell = floor(coordinates);\n  let fraction = fract(coordinates);\n  let blend = fraction * fraction * (vec2<f32>(3.0) - 2.0 * fraction);\n  let corners = vec4<f32>(\n    dot(cell, vec2<f32>(127.1, 311.7)),\n    dot(cell + vec2<f32>(1.0, 0.0), vec2<f32>(127.1, 311.7)),\n    dot(cell + vec2<f32>(0.0, 1.0), vec2<f32>(127.1, 311.7)),\n    dot(cell + vec2<f32>(1.0, 1.0), vec2<f32>(127.1, 311.7))\n  );\n  let values = fract(sin(corners) * 43758.5453);\n  return mix(mix(values.x, values.y, blend.x), mix(values.z, values.w, blend.x), blend.y);\n}\n\nfn riverWater_waveGradient(\n  coordinates: vec2<f32>,\n  direction: vec2<f32>,\n  frequency: f32,\n  amplitude: f32,\n  speed: f32,\n  phaseOffset: f32\n) -> vec2<f32> {\n  // Advect the irregular wave packets together with their carrier waves.\n  let movingCoordinates = coordinates + direction * (waterMaterial.time * speed / frequency);\n  let crossDirection = vec2<f32>(-direction.y, direction.x);\n  let variationCoordinates = vec2<f32>(dot(movingCoordinates, crossDirection), dot(movingCoordinates, direction)) * frequency * vec2<f32>(0.38, 0.16) + vec2<f32>(phaseOffset * 3.7);\n  let variation = riverWater_noise(variationCoordinates);\n  let detail = riverWater_noise(variationCoordinates * 2.13 + vec2<f32>(11.3, 7.9));\n  let envelope = smoothstep(0.12, 0.88, riverWater_noise(variationCoordinates * 0.71 + vec2<f32>(23.6, 5.2)));\n  let phase = dot(movingCoordinates, direction) * frequency + phaseOffset + (variation - 0.5) * 7.0 + (detail - 0.5) * 2.5;\n  let attenuation = 1.0 - smoothstep(0.8, 3.0, fwidth(phase));\n  return direction * (cos(phase) * frequency * amplitude * attenuation * (0.15 + envelope * 1.2));\n}\n\nfn riverWater_getNormal(\n  position_worldspace: vec3<f32>,\n  position_objectspace: vec3<f32>,\n  normal_worldspace: vec3<f32>,\n  uv: vec2<f32>\n) -> vec3<f32> {\n  let coordinates = riverWater_getFlowCoordinates(\n    water_getCoordinates(position_worldspace, position_objectspace, uv)\n  );\n  let driftCoordinates = coordinates * 0.7 + vec2<f32>(0.0, waterMaterial.time * 0.22);\n  let warp = (vec2<f32>(\n    riverWater_noise(driftCoordinates),\n    riverWater_noise(driftCoordinates + vec2<f32>(17.2, 9.4))\n  ) - vec2<f32>(0.5)) * 0.65;\n  let warpedCoordinates = coordinates + warp;\n  let gradient =\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(0.08, 1.0)), 2.1, 0.018, 1.25, 0.0) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(-0.28, 1.0)), 3.7, 0.018, 0.95, 1.7) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(0.47, 1.0)), 5.3, 0.012, 1.7, 3.2) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(-0.68, 1.0)), 7.9, 0.008, 0.76, 0.8) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(0.92, 1.0)), 11.6, 0.004, 2.2, 2.1) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(-1.22, 1.0)), 16.3, 0.002, 1.45, 2.8);\n  let tangent = water_getTangent(normalize(normal_worldspace));\n  let bitangent = normalize(cross(normalize(normal_worldspace), tangent));\n  return normalize(normal_worldspace + waterMaterial.normalStrength * 3.2 *\n    (gradient.x * tangent + gradient.y * bitangent));\n}\n\n// Camera-independent sky approximation; missing scene reflections retain this material color.\nfn riverWater_getSkyColor(reflectionDirection: vec3<f32>) -> vec3<f32> {\n  let elevation = clamp(dot(normalize(reflectionDirection), normalize(riverWaterMaterial.skyUpDirection)), 0.0, 1.0);\n  let horizonColor = mix(waterMaterial.fresnelColor, riverWaterMaterial.skyZenithColor, 0.32);\n  return mix(horizonColor, riverWaterMaterial.skyZenithColor, smoothstep(0.0, 1.0, elevation));\n}\n\nfn riverWater_getColorMapped(\n  cameraPosition: vec3<f32>,\n  position_worldspace: vec3<f32>,\n  position_objectspace: vec3<f32>,\n  normal_worldspace: vec3<f32>,\n  uv: vec2<f32>\n) -> vec4<f32> {\n  let waterNormal = riverWater_getNormal(\n    position_worldspace, position_objectspace, normal_worldspace, uv\n  );\n  let viewDirection = normalize(cameraPosition - position_worldspace);\n  let fresnel = pow(1.0 - max(dot(viewDirection, waterNormal), 0.0), 3.2);\n  let deepColor = waterMaterial.baseColor * vec3<f32>(0.52, 0.74, 0.9);\n  let reflectedColor = riverWater_getSkyColor(reflect(-viewDirection, waterNormal));\n  let surfaceColor = mix(deepColor, reflectedColor, clamp(fresnel * 0.78, 0.0, 0.78));\n  var color = surfaceColor * (0.32 + 0.68 * lighting.ambientColor);\n\n  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {\n    let directionalLight = lighting_getDirectionalLight(i);\n    let lightDirection = normalize(-directionalLight.direction);\n    let halfwayDirection = normalize(lightDirection + viewDirection);\n    let diffuse = max(dot(waterNormal, lightDirection), 0.0);\n    let specular = pow(max(dot(waterNormal, halfwayDirection), 0.0), 64.0);\n    let brokenSpecular = specular * (0.25 + 0.75 * fresnel);\n    color += surfaceColor * directionalLight.color * diffuse * 0.38;\n    color += vec3<f32>(0.72, 0.88, 0.94) * directionalLight.color * brokenSpecular * 2.1;\n  }\n\n  color = mix(color, reflectedColor, clamp(fresnel * 0.3, 0.0, 0.3));\n  return vec4<f32>(color, waterMaterial.opacity);\n}\n";
+export declare const RIVER_WATER_GLSL = "layout(std140) uniform riverWaterMaterialUniforms {\n  uniform int enabled;\n  uniform vec2 flowDirection;\n  uniform vec3 skyZenithColor;\n  uniform vec3 skyUpDirection;\n} riverWaterMaterial;\n\nvec2 riverWater_getFlowCoordinates(vec2 coordinates) {\n  vec2 flowDirection = normalize(riverWaterMaterial.flowDirection);\n  vec2 crossDirection = vec2(-flowDirection.y, flowDirection.x);\n  return vec2(dot(coordinates, crossDirection), dot(coordinates, flowDirection));\n}\n\n// Smooth spatial variation travels with the surface; it does not flicker per frame.\nfloat riverWater_noise(vec2 coordinates) {\n  vec2 cell = floor(coordinates);\n  vec2 fraction = fract(coordinates);\n  vec2 blend = fraction * fraction * (vec2(3.0) - 2.0 * fraction);\n  vec4 corners = vec4(\n    dot(cell, vec2(127.1, 311.7)),\n    dot(cell + vec2(1.0, 0.0), vec2(127.1, 311.7)),\n    dot(cell + vec2(0.0, 1.0), vec2(127.1, 311.7)),\n    dot(cell + vec2(1.0, 1.0), vec2(127.1, 311.7))\n  );\n  vec4 values = fract(sin(corners) * 43758.5453);\n  return mix(mix(values.x, values.y, blend.x), mix(values.z, values.w, blend.x), blend.y);\n}\n\nvec2 riverWater_waveGradient(\n  vec2 coordinates, vec2 direction, float frequency, float amplitude, float speed, float phaseOffset\n) {\n  // Advect the irregular wave packets together with their carrier waves.\n  vec2 movingCoordinates = coordinates + direction * (waterMaterial.time * speed / frequency);\n  vec2 crossDirection = vec2(-direction.y, direction.x);\n  vec2 variationCoordinates = vec2(dot(movingCoordinates, crossDirection), dot(movingCoordinates, direction)) * frequency * vec2(0.38, 0.16) + vec2(phaseOffset * 3.7);\n  float variation = riverWater_noise(variationCoordinates);\n  float detail = riverWater_noise(variationCoordinates * 2.13 + vec2(11.3, 7.9));\n  float envelope = smoothstep(0.12, 0.88, riverWater_noise(variationCoordinates * 0.71 + vec2(23.6, 5.2)));\n  float phase = dot(movingCoordinates, direction) * frequency + phaseOffset + (variation - 0.5) * 7.0 + (detail - 0.5) * 2.5;\n  float attenuation = 1.0 - smoothstep(0.8, 3.0, fwidth(phase));\n  return direction * (cos(phase) * frequency * amplitude * attenuation * (0.15 + envelope * 1.2));\n}\n\nvec3 riverWater_getNormal(\n  vec3 position_worldspace,\n  vec3 position_objectspace,\n  vec3 normal_worldspace,\n  vec2 uv\n) {\n  vec2 coordinates = riverWater_getFlowCoordinates(\n    water_getCoordinates(position_worldspace, position_objectspace, uv)\n  );\n  vec2 driftCoordinates = coordinates * 0.7 + vec2(0.0, waterMaterial.time * 0.22);\n  vec2 warp = (vec2(\n    riverWater_noise(driftCoordinates),\n    riverWater_noise(driftCoordinates + vec2(17.2, 9.4))\n  ) - vec2(0.5)) * 0.65;\n  vec2 warpedCoordinates = coordinates + warp;\n  vec2 gradient =\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2(0.08, 1.0)), 2.1, 0.018, 1.25, 0.0) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2(-0.28, 1.0)), 3.7, 0.018, 0.95, 1.7) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2(0.47, 1.0)), 5.3, 0.012, 1.7, 3.2) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2(-0.68, 1.0)), 7.9, 0.008, 0.76, 0.8) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2(0.92, 1.0)), 11.6, 0.004, 2.2, 2.1) +\n    riverWater_waveGradient(warpedCoordinates, normalize(vec2(-1.22, 1.0)), 16.3, 0.002, 1.45, 2.8);\n  vec3 tangent = water_getTangent(normalize(normal_worldspace));\n  vec3 bitangent = normalize(cross(normalize(normal_worldspace), tangent));\n  return normalize(normal_worldspace + waterMaterial.normalStrength * 3.2 *\n    (gradient.x * tangent + gradient.y * bitangent));\n}\n\n// Camera-independent sky approximation; missing scene reflections retain this material color.\nvec3 riverWater_getSkyColor(vec3 reflectionDirection) {\n  float elevation = clamp(dot(normalize(reflectionDirection), normalize(riverWaterMaterial.skyUpDirection)), 0.0, 1.0);\n  vec3 horizonColor = mix(waterMaterial.fresnelColor, riverWaterMaterial.skyZenithColor, 0.32);\n  return mix(horizonColor, riverWaterMaterial.skyZenithColor, smoothstep(0.0, 1.0, elevation));\n}\n\nvec4 riverWater_getColorMapped(\n  vec3 cameraPosition,\n  vec3 position_worldspace,\n  vec3 position_objectspace,\n  vec3 normal_worldspace,\n  vec2 uv\n) {\n  vec3 waterNormal = riverWater_getNormal(\n    position_worldspace, position_objectspace, normal_worldspace, uv\n  );\n  vec3 viewDirection = normalize(cameraPosition - position_worldspace);\n  float fresnel = pow(1.0 - max(dot(viewDirection, waterNormal), 0.0), 3.2);\n  vec3 deepColor = waterMaterial.baseColor * vec3(0.52, 0.74, 0.9);\n  vec3 reflectedColor = riverWater_getSkyColor(reflect(-viewDirection, waterNormal));\n  vec3 surfaceColor = mix(deepColor, reflectedColor, clamp(fresnel * 0.78, 0.0, 0.78));\n  vec3 color = surfaceColor * (0.32 + 0.68 * lighting.ambientColor);\n\n  for (int i = 0; i < lighting.directionalLightCount; i++) {\n    DirectionalLight directionalLight = lighting_getDirectionalLight(i);\n    vec3 lightDirection = normalize(-directionalLight.direction);\n    vec3 halfwayDirection = normalize(lightDirection + viewDirection);\n    float diffuse = max(dot(waterNormal, lightDirection), 0.0);\n    float specular = pow(max(dot(waterNormal, halfwayDirection), 0.0), 64.0);\n    float brokenSpecular = specular * (0.25 + 0.75 * fresnel);\n    color += surfaceColor * directionalLight.color * diffuse * 0.38;\n    color += vec3(0.72, 0.88, 0.94) * directionalLight.color * brokenSpecular * 2.1;\n  }\n\n  color = mix(color, reflectedColor, clamp(fresnel * 0.3, 0.0, 0.3));\n  return vec4(color, waterMaterial.opacity);\n}\n";
+//# sourceMappingURL=river-water-shaders.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"river-water-shaders.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/water-material/river-water-shaders.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB,mzLAqH5B,CAAC;AAEF,eAAO,MAAM,gBAAgB,+gLA8G5B,CAAC"}

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

@@ -0,0 +1,233 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export const RIVER_WATER_WGSL = /* wgsl */ `\
+struct riverWaterMaterialUniforms {
+  enabled: i32,
+  flowDirection: vec2<f32>,
+  skyZenithColor: vec3<f32>,
+  skyUpDirection: vec3<f32>,
+};
+
+@group(3) @binding(auto) var<uniform> riverWaterMaterial : riverWaterMaterialUniforms;
+
+fn riverWater_getFlowCoordinates(coordinates: vec2<f32>) -> vec2<f32> {
+  let flowDirection = normalize(riverWaterMaterial.flowDirection);
+  let crossDirection = vec2<f32>(-flowDirection.y, flowDirection.x);
+  return vec2<f32>(dot(coordinates, crossDirection), dot(coordinates, flowDirection));
+}
+
+// Smooth spatial variation travels with the surface; it does not flicker per frame.
+fn riverWater_noise(coordinates: vec2<f32>) -> f32 {
+  let cell = floor(coordinates);
+  let fraction = fract(coordinates);
+  let blend = fraction * fraction * (vec2<f32>(3.0) - 2.0 * fraction);
+  let corners = vec4<f32>(
+    dot(cell, vec2<f32>(127.1, 311.7)),
+    dot(cell + vec2<f32>(1.0, 0.0), vec2<f32>(127.1, 311.7)),
+    dot(cell + vec2<f32>(0.0, 1.0), vec2<f32>(127.1, 311.7)),
+    dot(cell + vec2<f32>(1.0, 1.0), vec2<f32>(127.1, 311.7))
+  );
+  let values = fract(sin(corners) * 43758.5453);
+  return mix(mix(values.x, values.y, blend.x), mix(values.z, values.w, blend.x), blend.y);
+}
+
+fn riverWater_waveGradient(
+  coordinates: vec2<f32>,
+  direction: vec2<f32>,
+  frequency: f32,
+  amplitude: f32,
+  speed: f32,
+  phaseOffset: f32
+) -> vec2<f32> {
+  // Advect the irregular wave packets together with their carrier waves.
+  let movingCoordinates = coordinates + direction * (waterMaterial.time * speed / frequency);
+  let crossDirection = vec2<f32>(-direction.y, direction.x);
+  let variationCoordinates = vec2<f32>(dot(movingCoordinates, crossDirection), dot(movingCoordinates, direction)) * frequency * vec2<f32>(0.38, 0.16) + vec2<f32>(phaseOffset * 3.7);
+  let variation = riverWater_noise(variationCoordinates);
+  let detail = riverWater_noise(variationCoordinates * 2.13 + vec2<f32>(11.3, 7.9));
+  let envelope = smoothstep(0.12, 0.88, riverWater_noise(variationCoordinates * 0.71 + vec2<f32>(23.6, 5.2)));
+  let phase = dot(movingCoordinates, direction) * frequency + phaseOffset + (variation - 0.5) * 7.0 + (detail - 0.5) * 2.5;
+  let attenuation = 1.0 - smoothstep(0.8, 3.0, fwidth(phase));
+  return direction * (cos(phase) * frequency * amplitude * attenuation * (0.15 + envelope * 1.2));
+}
+
+fn riverWater_getNormal(
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec3<f32> {
+  let coordinates = riverWater_getFlowCoordinates(
+    water_getCoordinates(position_worldspace, position_objectspace, uv)
+  );
+  let driftCoordinates = coordinates * 0.7 + vec2<f32>(0.0, waterMaterial.time * 0.22);
+  let warp = (vec2<f32>(
+    riverWater_noise(driftCoordinates),
+    riverWater_noise(driftCoordinates + vec2<f32>(17.2, 9.4))
+  ) - vec2<f32>(0.5)) * 0.65;
+  let warpedCoordinates = coordinates + warp;
+  let gradient =
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(0.08, 1.0)), 2.1, 0.018, 1.25, 0.0) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(-0.28, 1.0)), 3.7, 0.018, 0.95, 1.7) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(0.47, 1.0)), 5.3, 0.012, 1.7, 3.2) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(-0.68, 1.0)), 7.9, 0.008, 0.76, 0.8) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(0.92, 1.0)), 11.6, 0.004, 2.2, 2.1) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2<f32>(-1.22, 1.0)), 16.3, 0.002, 1.45, 2.8);
+  let tangent = water_getTangent(normalize(normal_worldspace));
+  let bitangent = normalize(cross(normalize(normal_worldspace), tangent));
+  return normalize(normal_worldspace + waterMaterial.normalStrength * 3.2 *
+    (gradient.x * tangent + gradient.y * bitangent));
+}
+
+// Camera-independent sky approximation; missing scene reflections retain this material color.
+fn riverWater_getSkyColor(reflectionDirection: vec3<f32>) -> vec3<f32> {
+  let elevation = clamp(dot(normalize(reflectionDirection), normalize(riverWaterMaterial.skyUpDirection)), 0.0, 1.0);
+  let horizonColor = mix(waterMaterial.fresnelColor, riverWaterMaterial.skyZenithColor, 0.32);
+  return mix(horizonColor, riverWaterMaterial.skyZenithColor, smoothstep(0.0, 1.0, elevation));
+}
+
+fn riverWater_getColorMapped(
+  cameraPosition: vec3<f32>,
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec4<f32> {
+  let waterNormal = riverWater_getNormal(
+    position_worldspace, position_objectspace, normal_worldspace, uv
+  );
+  let viewDirection = normalize(cameraPosition - position_worldspace);
+  let fresnel = pow(1.0 - max(dot(viewDirection, waterNormal), 0.0), 3.2);
+  let deepColor = waterMaterial.baseColor * vec3<f32>(0.52, 0.74, 0.9);
+  let reflectedColor = riverWater_getSkyColor(reflect(-viewDirection, waterNormal));
+  let surfaceColor = mix(deepColor, reflectedColor, clamp(fresnel * 0.78, 0.0, 0.78));
+  var color = surfaceColor * (0.32 + 0.68 * lighting.ambientColor);
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight = lighting_getDirectionalLight(i);
+    let lightDirection = normalize(-directionalLight.direction);
+    let halfwayDirection = normalize(lightDirection + viewDirection);
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+    let specular = pow(max(dot(waterNormal, halfwayDirection), 0.0), 64.0);
+    let brokenSpecular = specular * (0.25 + 0.75 * fresnel);
+    color += surfaceColor * directionalLight.color * diffuse * 0.38;
+    color += vec3<f32>(0.72, 0.88, 0.94) * directionalLight.color * brokenSpecular * 2.1;
+  }
+
+  color = mix(color, reflectedColor, clamp(fresnel * 0.3, 0.0, 0.3));
+  return vec4<f32>(color, waterMaterial.opacity);
+}
+`;
+export const RIVER_WATER_GLSL = /* glsl */ `\
+layout(std140) uniform riverWaterMaterialUniforms {
+  uniform int enabled;
+  uniform vec2 flowDirection;
+  uniform vec3 skyZenithColor;
+  uniform vec3 skyUpDirection;
+} riverWaterMaterial;
+
+vec2 riverWater_getFlowCoordinates(vec2 coordinates) {
+  vec2 flowDirection = normalize(riverWaterMaterial.flowDirection);
+  vec2 crossDirection = vec2(-flowDirection.y, flowDirection.x);
+  return vec2(dot(coordinates, crossDirection), dot(coordinates, flowDirection));
+}
+
+// Smooth spatial variation travels with the surface; it does not flicker per frame.
+float riverWater_noise(vec2 coordinates) {
+  vec2 cell = floor(coordinates);
+  vec2 fraction = fract(coordinates);
+  vec2 blend = fraction * fraction * (vec2(3.0) - 2.0 * fraction);
+  vec4 corners = vec4(
+    dot(cell, vec2(127.1, 311.7)),
+    dot(cell + vec2(1.0, 0.0), vec2(127.1, 311.7)),
+    dot(cell + vec2(0.0, 1.0), vec2(127.1, 311.7)),
+    dot(cell + vec2(1.0, 1.0), vec2(127.1, 311.7))
+  );
+  vec4 values = fract(sin(corners) * 43758.5453);
+  return mix(mix(values.x, values.y, blend.x), mix(values.z, values.w, blend.x), blend.y);
+}
+
+vec2 riverWater_waveGradient(
+  vec2 coordinates, vec2 direction, float frequency, float amplitude, float speed, float phaseOffset
+) {
+  // Advect the irregular wave packets together with their carrier waves.
+  vec2 movingCoordinates = coordinates + direction * (waterMaterial.time * speed / frequency);
+  vec2 crossDirection = vec2(-direction.y, direction.x);
+  vec2 variationCoordinates = vec2(dot(movingCoordinates, crossDirection), dot(movingCoordinates, direction)) * frequency * vec2(0.38, 0.16) + vec2(phaseOffset * 3.7);
+  float variation = riverWater_noise(variationCoordinates);
+  float detail = riverWater_noise(variationCoordinates * 2.13 + vec2(11.3, 7.9));
+  float envelope = smoothstep(0.12, 0.88, riverWater_noise(variationCoordinates * 0.71 + vec2(23.6, 5.2)));
+  float phase = dot(movingCoordinates, direction) * frequency + phaseOffset + (variation - 0.5) * 7.0 + (detail - 0.5) * 2.5;
+  float attenuation = 1.0 - smoothstep(0.8, 3.0, fwidth(phase));
+  return direction * (cos(phase) * frequency * amplitude * attenuation * (0.15 + envelope * 1.2));
+}
+
+vec3 riverWater_getNormal(
+  vec3 position_worldspace,
+  vec3 position_objectspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  vec2 coordinates = riverWater_getFlowCoordinates(
+    water_getCoordinates(position_worldspace, position_objectspace, uv)
+  );
+  vec2 driftCoordinates = coordinates * 0.7 + vec2(0.0, waterMaterial.time * 0.22);
+  vec2 warp = (vec2(
+    riverWater_noise(driftCoordinates),
+    riverWater_noise(driftCoordinates + vec2(17.2, 9.4))
+  ) - vec2(0.5)) * 0.65;
+  vec2 warpedCoordinates = coordinates + warp;
+  vec2 gradient =
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(0.08, 1.0)), 2.1, 0.018, 1.25, 0.0) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(-0.28, 1.0)), 3.7, 0.018, 0.95, 1.7) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(0.47, 1.0)), 5.3, 0.012, 1.7, 3.2) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(-0.68, 1.0)), 7.9, 0.008, 0.76, 0.8) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(0.92, 1.0)), 11.6, 0.004, 2.2, 2.1) +
+    riverWater_waveGradient(warpedCoordinates, normalize(vec2(-1.22, 1.0)), 16.3, 0.002, 1.45, 2.8);
+  vec3 tangent = water_getTangent(normalize(normal_worldspace));
+  vec3 bitangent = normalize(cross(normalize(normal_worldspace), tangent));
+  return normalize(normal_worldspace + waterMaterial.normalStrength * 3.2 *
+    (gradient.x * tangent + gradient.y * bitangent));
+}
+
+// Camera-independent sky approximation; missing scene reflections retain this material color.
+vec3 riverWater_getSkyColor(vec3 reflectionDirection) {
+  float elevation = clamp(dot(normalize(reflectionDirection), normalize(riverWaterMaterial.skyUpDirection)), 0.0, 1.0);
+  vec3 horizonColor = mix(waterMaterial.fresnelColor, riverWaterMaterial.skyZenithColor, 0.32);
+  return mix(horizonColor, riverWaterMaterial.skyZenithColor, smoothstep(0.0, 1.0, elevation));
+}
+
+vec4 riverWater_getColorMapped(
+  vec3 cameraPosition,
+  vec3 position_worldspace,
+  vec3 position_objectspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  vec3 waterNormal = riverWater_getNormal(
+    position_worldspace, position_objectspace, normal_worldspace, uv
+  );
+  vec3 viewDirection = normalize(cameraPosition - position_worldspace);
+  float fresnel = pow(1.0 - max(dot(viewDirection, waterNormal), 0.0), 3.2);
+  vec3 deepColor = waterMaterial.baseColor * vec3(0.52, 0.74, 0.9);
+  vec3 reflectedColor = riverWater_getSkyColor(reflect(-viewDirection, waterNormal));
+  vec3 surfaceColor = mix(deepColor, reflectedColor, clamp(fresnel * 0.78, 0.0, 0.78));
+  vec3 color = surfaceColor * (0.32 + 0.68 * lighting.ambientColor);
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    vec3 lightDirection = normalize(-directionalLight.direction);
+    vec3 halfwayDirection = normalize(lightDirection + viewDirection);
+    float diffuse = max(dot(waterNormal, lightDirection), 0.0);
+    float specular = pow(max(dot(waterNormal, halfwayDirection), 0.0), 64.0);
+    float brokenSpecular = specular * (0.25 + 0.75 * fresnel);
+    color += surfaceColor * directionalLight.color * diffuse * 0.38;
+    color += vec3(0.72, 0.88, 0.94) * directionalLight.color * brokenSpecular * 2.1;
+  }
+
+  color = mix(color, reflectedColor, clamp(fresnel * 0.3, 0.0, 0.3));
+  return vec4(color, waterMaterial.opacity);
+}
+`;
+//# sourceMappingURL=river-water-shaders.js.map

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

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