@luma.gl/shadertools 9.3.6 → 9.4.0-alpha.1

package/src/modules/geospatial/dggs/dggs.ts

@@ -0,0 +1,12 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {dggsWGSL} from './dggs-wgsl';
+
+/** WGSL helpers for 64-bit DGGS cell IDs encoded as two u32 words. */
+export const dggs = {
+  name: 'dggs',
+  source: dggsWGSL
+} as const satisfies ShaderModule<{}, {}>;

package/src/modules/lighting/water-material/water-material.ts

@@ -0,0 +1,234 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {NumberArray2, NumberArray3, Vector2, Vector3} from '@math.gl/core';
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {lighting} from '../lights/lighting';
+import {WATER_FS, WATER_VS} from './water-shaders-glsl';
+import {WATER_WGSL} from './water-shaders-wgsl';
+
+export type WaterMaterialUniforms = {
+  time?: number;
+  baseColor?: Readonly<Vector3 | NumberArray3>;
+  opacity?: number;
+  fresnelColor?: Readonly<Vector3 | NumberArray3>;
+  fresnelPower?: number;
+  specularIntensity?: number;
+  normalStrength?: number;
+  mappingMode?: number;
+  coordinateScale?: Readonly<Vector2 | NumberArray2>;
+  coordinateOffset?: Readonly<Vector2 | NumberArray2>;
+  waveADirection?: Readonly<Vector2 | NumberArray2>;
+  waveASpeed?: number;
+  waveAFrequency?: number;
+  waveAAmplitude?: number;
+  waveBDirection?: Readonly<Vector2 | NumberArray2>;
+  waveBSpeed?: number;
+  waveBFrequency?: number;
+  waveBAmplitude?: number;
+};
+
+export type WaterMaterialProps = Omit<WaterMaterialUniforms, 'mappingMode'> & {
+  mapping?: 'uv' | 'world' | 'object';
+};
+
+const DEFAULT_WATER_MATERIAL_UNIFORMS: Required<WaterMaterialUniforms> = {
+  time: 0,
+  baseColor: [0.04, 0.18, 0.31],
+  opacity: 0.82,
+  fresnelColor: [0.86, 0.95, 1],
+  fresnelPower: 5,
+  specularIntensity: 1.4,
+  normalStrength: 0.35,
+  mappingMode: 0,
+  coordinateScale: [1, 1],
+  coordinateOffset: [0, 0],
+  waveADirection: [0.9805806756909201, 0.19611613513818402],
+  waveASpeed: 0.6,
+  waveAFrequency: 4,
+  waveAAmplitude: 0.08,
+  waveBDirection: [0.09950371902099893, 0.9950371902099893],
+  waveBSpeed: -0.45,
+  waveBFrequency: 7,
+  waveBAmplitude: 0.04
+};
+
+/** Animated water material with procedural waves and Fresnel/specular shading. */
+export const waterMaterial: ShaderModule<WaterMaterialProps, WaterMaterialUniforms> = {
+  name: 'waterMaterial',
+  firstBindingSlot: 0,
+  bindingLayout: [{name: 'waterMaterial', group: 3}],
+  dependencies: [lighting],
+  source: WATER_WGSL,
+  vs: WATER_VS,
+  fs: WATER_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    time: 'f32',
+    baseColor: 'vec3<f32>',
+    opacity: 'f32',
+    fresnelColor: 'vec3<f32>',
+    fresnelPower: 'f32',
+    specularIntensity: 'f32',
+    normalStrength: 'f32',
+    mappingMode: 'i32',
+    coordinateScale: 'vec2<f32>',
+    coordinateOffset: 'vec2<f32>',
+    waveADirection: 'vec2<f32>',
+    waveASpeed: 'f32',
+    waveAFrequency: 'f32',
+    waveAAmplitude: 'f32',
+    waveBDirection: 'vec2<f32>',
+    waveBSpeed: 'f32',
+    waveBFrequency: 'f32',
+    waveBAmplitude: 'f32'
+  },
+  defaultUniforms: DEFAULT_WATER_MATERIAL_UNIFORMS,
+  getUniforms(
+    props?: WaterMaterialProps,
+    previousUniforms: Partial<WaterMaterialUniforms> = DEFAULT_WATER_MATERIAL_UNIFORMS
+  ) {
+    const {mapping, ...uniformProps} = props || {};
+    const uniforms = mergeWaterMaterialUniforms(previousUniforms);
+
+    if (uniformProps.time !== undefined) {
+      uniforms.time = uniformProps.time;
+    }
+    if (uniformProps.opacity !== undefined) {
+      uniforms.opacity = uniformProps.opacity;
+    }
+    if (uniformProps.fresnelPower !== undefined) {
+      uniforms.fresnelPower = uniformProps.fresnelPower;
+    }
+    if (uniformProps.specularIntensity !== undefined) {
+      uniforms.specularIntensity = uniformProps.specularIntensity;
+    }
+    if (uniformProps.normalStrength !== undefined) {
+      uniforms.normalStrength = uniformProps.normalStrength;
+    }
+    if (uniformProps.coordinateScale !== undefined) {
+      uniforms.coordinateScale = [
+        Number(uniformProps.coordinateScale[0]),
+        Number(uniformProps.coordinateScale[1])
+      ];
+    }
+    if (uniformProps.coordinateOffset !== undefined) {
+      uniforms.coordinateOffset = [
+        Number(uniformProps.coordinateOffset[0]),
+        Number(uniformProps.coordinateOffset[1])
+      ];
+    }
+    if (uniformProps.waveASpeed !== undefined) {
+      uniforms.waveASpeed = uniformProps.waveASpeed;
+    }
+    if (uniformProps.waveAFrequency !== undefined) {
+      uniforms.waveAFrequency = uniformProps.waveAFrequency;
+    }
+    if (uniformProps.waveAAmplitude !== undefined) {
+      uniforms.waveAAmplitude = uniformProps.waveAAmplitude;
+    }
+    if (uniformProps.waveBSpeed !== undefined) {
+      uniforms.waveBSpeed = uniformProps.waveBSpeed;
+    }
+    if (uniformProps.waveBFrequency !== undefined) {
+      uniforms.waveBFrequency = uniformProps.waveBFrequency;
+    }
+    if (uniformProps.waveBAmplitude !== undefined) {
+      uniforms.waveBAmplitude = uniformProps.waveBAmplitude;
+    }
+
+    if (uniformProps.baseColor) {
+      uniforms.baseColor = normalizeColor3(uniformProps.baseColor);
+    }
+    if (uniformProps.fresnelColor) {
+      uniforms.fresnelColor = normalizeColor3(uniformProps.fresnelColor);
+    }
+    if (uniformProps.waveADirection) {
+      uniforms.waveADirection = normalizeDirection2(uniformProps.waveADirection);
+    }
+    if (uniformProps.waveBDirection) {
+      uniforms.waveBDirection = normalizeDirection2(uniformProps.waveBDirection);
+    }
+
+    if (mapping !== undefined) {
+      uniforms.mappingMode = mapping === 'world' ? 1 : mapping === 'object' ? 2 : 0;
+    }
+
+    return uniforms;
+  }
+};
+
+function mergeWaterMaterialUniforms(
+  previousUniforms: Partial<WaterMaterialUniforms>
+): Required<WaterMaterialUniforms> {
+  return {
+    time: previousUniforms.time ?? DEFAULT_WATER_MATERIAL_UNIFORMS.time,
+    baseColor: previousUniforms.baseColor
+      ? normalizeColor3(previousUniforms.baseColor)
+      : DEFAULT_WATER_MATERIAL_UNIFORMS.baseColor,
+    opacity: previousUniforms.opacity ?? DEFAULT_WATER_MATERIAL_UNIFORMS.opacity,
+    fresnelColor: previousUniforms.fresnelColor
+      ? normalizeColor3(previousUniforms.fresnelColor)
+      : DEFAULT_WATER_MATERIAL_UNIFORMS.fresnelColor,
+    fresnelPower: previousUniforms.fresnelPower ?? DEFAULT_WATER_MATERIAL_UNIFORMS.fresnelPower,
+    specularIntensity:
+      previousUniforms.specularIntensity ?? DEFAULT_WATER_MATERIAL_UNIFORMS.specularIntensity,
+    normalStrength:
+      previousUniforms.normalStrength ?? DEFAULT_WATER_MATERIAL_UNIFORMS.normalStrength,
+    mappingMode: previousUniforms.mappingMode ?? DEFAULT_WATER_MATERIAL_UNIFORMS.mappingMode,
+    coordinateScale: previousUniforms.coordinateScale
+      ? [Number(previousUniforms.coordinateScale[0]), Number(previousUniforms.coordinateScale[1])]
+      : DEFAULT_WATER_MATERIAL_UNIFORMS.coordinateScale,
+    coordinateOffset: previousUniforms.coordinateOffset
+      ? [Number(previousUniforms.coordinateOffset[0]), Number(previousUniforms.coordinateOffset[1])]
+      : DEFAULT_WATER_MATERIAL_UNIFORMS.coordinateOffset,
+    waveADirection: previousUniforms.waveADirection
+      ? normalizeDirection2(previousUniforms.waveADirection)
+      : DEFAULT_WATER_MATERIAL_UNIFORMS.waveADirection,
+    waveASpeed: previousUniforms.waveASpeed ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveASpeed,
+    waveAFrequency:
+      previousUniforms.waveAFrequency ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveAFrequency,
+    waveAAmplitude:
+      previousUniforms.waveAAmplitude ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveAAmplitude,
+    waveBDirection: previousUniforms.waveBDirection
+      ? normalizeDirection2(previousUniforms.waveBDirection)
+      : DEFAULT_WATER_MATERIAL_UNIFORMS.waveBDirection,
+    waveBSpeed: previousUniforms.waveBSpeed ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveBSpeed,
+    waveBFrequency:
+      previousUniforms.waveBFrequency ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveBFrequency,
+    waveBAmplitude:
+      previousUniforms.waveBAmplitude ?? DEFAULT_WATER_MATERIAL_UNIFORMS.waveBAmplitude
+  };
+}
+
+function normalizeColor3(color: Readonly<Vector3 | NumberArray3>): [number, number, number] {
+  const normalizedColor = [Number(color[0]), Number(color[1]), Number(color[2])] as [
+    number,
+    number,
+    number
+  ];
+  const maxChannel = Math.max(...normalizedColor.map(channel => Math.abs(channel)));
+
+  if (maxChannel > 1) {
+    normalizedColor[0] /= 255;
+    normalizedColor[1] /= 255;
+    normalizedColor[2] /= 255;
+  }
+
+  return normalizedColor;
+}
+
+function normalizeDirection2(direction: Readonly<Vector2 | NumberArray2>): [number, number] {
+  const x = Number(direction[0]);
+  const y = Number(direction[1]);
+  const length = Math.hypot(x, y);
+
+  if (length === 0) {
+    return [1, 0];
+  }
+
+  return [x / length, y / length];
+}

package/src/modules/lighting/water-material/water-shaders-glsl.ts

@@ -0,0 +1,233 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const WATER_VS = /* glsl */ `\
+layout(std140) uniform waterMaterialUniforms {
+  uniform float time;
+  uniform vec3 baseColor;
+  uniform float opacity;
+  uniform vec3 fresnelColor;
+  uniform float fresnelPower;
+  uniform float specularIntensity;
+  uniform float normalStrength;
+  uniform int mappingMode;
+  uniform vec2 coordinateScale;
+  uniform vec2 coordinateOffset;
+  uniform vec2 waveADirection;
+  uniform float waveASpeed;
+  uniform float waveAFrequency;
+  uniform float waveAAmplitude;
+  uniform vec2 waveBDirection;
+  uniform float waveBSpeed;
+  uniform float waveBFrequency;
+  uniform float waveBAmplitude;
+} waterMaterial;
+`;
+
+export const WATER_FS = /* glsl */ `\
+layout(std140) uniform waterMaterialUniforms {
+  uniform float time;
+  uniform vec3 baseColor;
+  uniform float opacity;
+  uniform vec3 fresnelColor;
+  uniform float fresnelPower;
+  uniform float specularIntensity;
+  uniform float normalStrength;
+  uniform int mappingMode;
+  uniform vec2 coordinateScale;
+  uniform vec2 coordinateOffset;
+  uniform vec2 waveADirection;
+  uniform float waveASpeed;
+  uniform float waveAFrequency;
+  uniform float waveAAmplitude;
+  uniform vec2 waveBDirection;
+  uniform float waveBSpeed;
+  uniform float waveBFrequency;
+  uniform float waveBAmplitude;
+} waterMaterial;
+
+vec2 water_getDirection(vec2 direction) {
+  float directionLength = length(direction);
+  return directionLength > 0.0 ? direction / directionLength : vec2(1.0, 0.0);
+}
+
+vec2 water_getCoordinates(vec3 position_worldspace, vec3 position_objectspace, vec2 uv) {
+  vec2 baseCoordinates = uv;
+  if (waterMaterial.mappingMode == 1) {
+    baseCoordinates = position_worldspace.xz;
+  } else if (waterMaterial.mappingMode == 2) {
+    vec3 globeDirection = normalize(position_objectspace);
+    float longitude = atan(globeDirection.x, globeDirection.z);
+    float latitude = asin(clamp(globeDirection.y, -1.0, 1.0));
+    baseCoordinates = vec2(longitude, latitude);
+  }
+  return baseCoordinates * waterMaterial.coordinateScale + waterMaterial.coordinateOffset;
+}
+
+vec2 water_getWaveGradient(
+  vec2 coordinates,
+  vec2 direction,
+  float speed,
+  float frequency,
+  float amplitude
+) {
+  vec2 normalizedDirection = water_getDirection(direction);
+  float phase = dot(coordinates * frequency, normalizedDirection) + waterMaterial.time * speed;
+  return cos(phase) * normalizedDirection * frequency * amplitude;
+}
+
+vec3 water_getTangent(vec3 normal_worldspace) {
+  vec3 referenceAxis = abs(normal_worldspace.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+  return normalize(cross(referenceAxis, normal_worldspace));
+}
+
+vec3 water_getNormal(
+  vec3 position_worldspace,
+  vec3 position_objectspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  vec2 coordinates = water_getCoordinates(position_worldspace, position_objectspace, uv);
+  vec2 gradient =
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveADirection,
+      waterMaterial.waveASpeed,
+      waterMaterial.waveAFrequency,
+      waterMaterial.waveAAmplitude
+    ) +
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveBDirection,
+      waterMaterial.waveBSpeed,
+      waterMaterial.waveBFrequency,
+      waterMaterial.waveBAmplitude
+    );
+
+  vec3 tangent = water_getTangent(normal_worldspace);
+  vec3 bitangent = normalize(cross(normal_worldspace, tangent));
+  vec3 perturbation =
+    waterMaterial.normalStrength * (gradient.x * tangent + gradient.y * bitangent);
+
+  return normalize(normal_worldspace + perturbation);
+}
+
+vec3 water_getSpecularContribution(
+  vec3 light_direction,
+  vec3 view_direction,
+  vec3 normal_worldspace,
+  vec3 light_color,
+  float fresnel
+) {
+  vec3 halfway_direction = normalize(light_direction + view_direction);
+  float specular =
+    pow(max(dot(normal_worldspace, halfway_direction), 0.0), 72.0) *
+    waterMaterial.specularIntensity *
+    (0.25 + 0.75 * fresnel);
+
+  return waterMaterial.fresnelColor * light_color * specular;
+}
+
+vec4 water_getColorMapped(
+  vec3 cameraPosition,
+  vec3 position_worldspace,
+  vec3 position_objectspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  vec3 waterNormal = water_getNormal(
+    position_worldspace,
+    position_objectspace,
+    normalize(normal_worldspace),
+    uv
+  );
+  vec3 viewDirection = normalize(cameraPosition - position_worldspace);
+  float fresnel =
+    pow(
+      1.0 - max(dot(viewDirection, waterNormal), 0.0),
+      max(waterMaterial.fresnelPower, 0.0001)
+    );
+  vec3 surfaceColor = mix(
+    waterMaterial.baseColor,
+    waterMaterial.fresnelColor,
+    clamp(fresnel * 0.6, 0.0, 1.0)
+  );
+
+  if (lighting.enabled == 0) {
+    return vec4(surfaceColor, waterMaterial.opacity);
+  }
+
+  vec3 lightColor = surfaceColor * (0.15 + 0.85 * lighting.ambientColor);
+
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 lightPosition = pointLight.position;
+    vec3 lightDirection = normalize(lightPosition - position_worldspace);
+    float attenuation =
+      getPointLightAttenuation(pointLight, distance(lightPosition, position_worldspace));
+    vec3 incidentLight = pointLight.color / attenuation;
+    float diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 lightPosition = spotLight.position;
+    vec3 lightDirection = normalize(lightPosition - position_worldspace);
+    float attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    vec3 incidentLight = spotLight.color / attenuation;
+    float diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    vec3 lightDirection = normalize(-directionalLight.direction);
+    float diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * directionalLight.color * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      directionalLight.color,
+      fresnel
+    );
+  }
+
+  lightColor = mix(lightColor, waterMaterial.fresnelColor, clamp(fresnel, 0.0, 1.0) * 0.35);
+  return vec4(lightColor, waterMaterial.opacity);
+}
+
+vec4 water_getColor(
+  vec3 cameraPosition,
+  vec3 position_worldspace,
+  vec3 normal_worldspace,
+  vec2 uv
+) {
+  return water_getColorMapped(
+    cameraPosition,
+    position_worldspace,
+    position_worldspace,
+    normal_worldspace,
+    uv
+  );
+}
+`;

package/src/modules/lighting/water-material/water-shaders-wgsl.ts

@@ -0,0 +1,230 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const WATER_WGSL = /* wgsl */ `\
+struct waterMaterialUniforms {
+  time: f32,
+  baseColor: vec3<f32>,
+  opacity: f32,
+  fresnelColor: vec3<f32>,
+  fresnelPower: f32,
+  specularIntensity: f32,
+  normalStrength: f32,
+  mappingMode: i32,
+  coordinateScale: vec2<f32>,
+  coordinateOffset: vec2<f32>,
+  waveADirection: vec2<f32>,
+  waveASpeed: f32,
+  waveAFrequency: f32,
+  waveAAmplitude: f32,
+  waveBDirection: vec2<f32>,
+  waveBSpeed: f32,
+  waveBFrequency: f32,
+  waveBAmplitude: f32,
+};
+
+@group(3) @binding(auto) var<uniform> waterMaterial : waterMaterialUniforms;
+
+fn water_getDirection(direction: vec2<f32>) -> vec2<f32> {
+  let directionLength = length(direction);
+  if (directionLength > 0.0) {
+    return direction / directionLength;
+  }
+
+  return vec2<f32>(1.0, 0.0);
+}
+
+fn water_getCoordinates(
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec2<f32> {
+  var baseCoordinates = uv;
+  if (waterMaterial.mappingMode == 1) {
+    baseCoordinates = position_worldspace.xz;
+  } else if (waterMaterial.mappingMode == 2) {
+    let globeDirection = normalize(position_objectspace);
+    let longitude = atan2(globeDirection.x, globeDirection.z);
+    let latitude = asin(clamp(globeDirection.y, -1.0, 1.0));
+    baseCoordinates = vec2<f32>(longitude, latitude);
+  }
+
+  return baseCoordinates * waterMaterial.coordinateScale + waterMaterial.coordinateOffset;
+}
+
+fn water_getWaveGradient(
+  coordinates: vec2<f32>,
+  direction: vec2<f32>,
+  speed: f32,
+  frequency: f32,
+  amplitude: f32
+) -> vec2<f32> {
+  let normalizedDirection = water_getDirection(direction);
+  let phase = dot(coordinates * frequency, normalizedDirection) + waterMaterial.time * speed;
+  return cos(phase) * normalizedDirection * frequency * amplitude;
+}
+
+fn water_getTangent(normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var referenceAxis = vec3<f32>(0.0, 0.0, 1.0);
+  if (abs(normal_worldspace.z) >= 0.999) {
+    referenceAxis = vec3<f32>(0.0, 1.0, 0.0);
+  }
+
+  return normalize(cross(referenceAxis, normal_worldspace));
+}
+
+fn water_getNormal(
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec3<f32> {
+  let coordinates = water_getCoordinates(position_worldspace, position_objectspace, uv);
+  let gradient =
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveADirection,
+      waterMaterial.waveASpeed,
+      waterMaterial.waveAFrequency,
+      waterMaterial.waveAAmplitude
+    ) +
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveBDirection,
+      waterMaterial.waveBSpeed,
+      waterMaterial.waveBFrequency,
+      waterMaterial.waveBAmplitude
+    );
+  let tangent = water_getTangent(normal_worldspace);
+  let bitangent = normalize(cross(normal_worldspace, tangent));
+  let perturbation =
+    waterMaterial.normalStrength * (gradient.x * tangent + gradient.y * bitangent);
+
+  return normalize(normal_worldspace + perturbation);
+}
+
+fn water_getSpecularContribution(
+  light_direction: vec3<f32>,
+  view_direction: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  light_color: vec3<f32>,
+  fresnel: f32
+) -> vec3<f32> {
+  let halfwayDirection = normalize(light_direction + view_direction);
+  let specular =
+    pow(max(dot(normal_worldspace, halfwayDirection), 0.0), 72.0) *
+    waterMaterial.specularIntensity *
+    (0.25 + 0.75 * fresnel);
+
+  return waterMaterial.fresnelColor * light_color * specular;
+}
+
+fn water_getColorMapped(
+  cameraPosition: vec3<f32>,
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec4<f32> {
+  let waterNormal = water_getNormal(
+    position_worldspace,
+    position_objectspace,
+    normalize(normal_worldspace),
+    uv
+  );
+  let viewDirection = normalize(cameraPosition - position_worldspace);
+  let fresnel =
+    pow(
+      1.0 - max(dot(viewDirection, waterNormal), 0.0),
+      max(waterMaterial.fresnelPower, 0.0001)
+    );
+  let surfaceColor = mix(
+    waterMaterial.baseColor,
+    waterMaterial.fresnelColor,
+    clamp(fresnel * 0.6, 0.0, 1.0)
+  );
+
+  if (lighting.enabled == 0) {
+    return vec4<f32>(surfaceColor, waterMaterial.opacity);
+  }
+
+  var lightColor = surfaceColor * (0.15 + 0.85 * lighting.ambientColor);
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight = lighting_getPointLight(i);
+    let lightPosition = pointLight.position;
+    let lightDirection = normalize(lightPosition - position_worldspace);
+    let attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(lightPosition, position_worldspace)
+    );
+    let incidentLight = pointLight.color / attenuation;
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight = lighting_getSpotLight(i);
+    let lightPosition = spotLight.position;
+    let lightDirection = normalize(lightPosition - position_worldspace);
+    let attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    let incidentLight = spotLight.color / attenuation;
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight = lighting_getDirectionalLight(i);
+    let lightDirection = normalize(-directionalLight.direction);
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * directionalLight.color * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      directionalLight.color,
+      fresnel
+    );
+  }
+
+  lightColor = mix(
+    lightColor,
+    waterMaterial.fresnelColor,
+    clamp(fresnel, 0.0, 1.0) * 0.35
+  );
+  return vec4<f32>(lightColor, waterMaterial.opacity);
+}
+
+fn water_getColor(
+  cameraPosition: vec3<f32>,
+  position_worldspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec4<f32> {
+  return water_getColorMapped(
+    cameraPosition,
+    position_worldspace,
+    position_worldspace,
+    normal_worldspace,
+    uv
+  );
+}
+`;