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

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

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

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

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

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

@@ -0,0 +1,232 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 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
+  );
+}
+`;
+//# sourceMappingURL=water-shaders-glsl.js.map

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

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

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

@@ -0,0 +1,254 @@
+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 water_shaders_wgsl_exports = {};
+__export(water_shaders_wgsl_exports, {
+  WATER_WGSL: () => WATER_WGSL
+});
+module.exports = __toCommonJS(water_shaders_wgsl_exports);
+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
+  );
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WATER_WGSL
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"water-shaders-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/water-material/water-shaders-wgsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,sjNAiOtB,CAAC"}