@3driseai/3drise-core 1.0.1

package/dist/shaders/VolumetricCloudsMaterial.js

@@ -0,0 +1,93 @@
+import { Vector2, Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { commonNoiseFunctions } from "./CommonNoiseFunctions.js";
+const volumetricCloudsVertex = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPosition;
+  
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const volumetricCloudsFragment = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  uniform vec3 u_cameraPos;
+  uniform vec3 u_cloudColor;
+  uniform vec3 u_lightDirection;
+  uniform float u_cloudDensity;
+  uniform float u_cloudCoverage;
+  uniform float u_cloudScale;
+  uniform vec3 u_lightColor;
+  uniform vec3 u_shadowColor;
+  uniform float u_absorption;
+  uniform float u_scattering;
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPosition;
+  
+  ${commonNoiseFunctions}
+  
+  float cloudDensity(vec3 pos) {
+    vec3 p = pos * u_cloudScale + vec3(u_time * 0.1, 0.0, u_time * 0.05);
+    float density = fbm(p) - u_cloudCoverage;
+    return max(0.0, density) * u_cloudDensity;
+  }
+  
+  vec3 rayMarch(vec3 rayOrigin, vec3 rayDir, float maxDist) {
+    vec3 color = vec3(0.0);
+    float transmittance = 1.0;
+    float stepSize = maxDist / 32.0;
+    
+    for (int i = 0; i < 32; i++) {
+      vec3 pos = rayOrigin + rayDir * float(i) * stepSize;
+      float density = cloudDensity(pos);
+      
+      if (density > 0.01) {
+        // Light scattering calculation
+        float lightDensity = cloudDensity(pos + u_lightDirection * stepSize);
+        float scattering = exp(-lightDensity * u_scattering);
+        
+        vec3 lightContrib = u_lightColor * scattering * density * transmittance;
+        color += lightContrib * stepSize;
+        
+        transmittance *= exp(-density * u_absorption * stepSize);
+        
+        if (transmittance < 0.01) break;
+      }
+    }
+    
+    return color + u_shadowColor * (1.0 - transmittance);
+  }
+  
+  void main() {
+    vec3 rayDir = normalize(vWorldPosition - u_cameraPos);
+    vec3 color = rayMarch(vWorldPosition, rayDir, 10.0);
+    
+    // Mix with cloud color
+    color = mix(color, u_cloudColor, 0.3);
+    
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+export const VolumetricCloudsMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(800, 600),
+    u_cameraPos: new Vector3(0, 0, 0),
+    u_cloudColor: new Vector3(1.0, 1.0, 1.0),
+    u_lightDirection: new Vector3(0.5, 1.0, 0.5),
+    u_cloudDensity: 0.8,
+    u_cloudCoverage: 0.4,
+    u_cloudScale: 0.5,
+    u_lightColor: new Vector3(1.0, 0.95, 0.8),
+    u_shadowColor: new Vector3(0.3, 0.4, 0.6),
+    u_absorption: 1.0,
+    u_scattering: 0.5
+}, volumetricCloudsVertex, volumetricCloudsFragment);
+extend({ VolumetricCloudsMaterial });

package/dist/shaders/VolumetricCloudsPointsMaterial.d.ts

@@ -0,0 +1,73 @@
+import { Vector3, Vector2, Color } from "three";
+export interface VolumetricCloudsPointsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_cloudDensity: {
+        value: number;
+    };
+    u_cloudCoverage: {
+        value: number;
+    };
+    u_lightColor: {
+        value: Vector3;
+    };
+    u_shadowColor: {
+        value: Vector3;
+    };
+    u_pointer: {
+        value: Vector2;
+    };
+    uPointSize: {
+        value: number;
+    };
+    uColor: {
+        value: Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+}
+export declare const VolumetricCloudsPointsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_cloudDensity: number;
+    u_cloudCoverage: number;
+    u_lightColor: Vector3;
+    u_shadowColor: Vector3;
+    uPointSize: number;
+    u_pointer: Vector2;
+    uColor: Color;
+    uOpacity: number;
+    uMorphProgress: number;
+    uPointerEffectRadius: number;
+    uRippleEnabled: false;
+    uRippleIntensity: number;
+    uRippleSpeed: number;
+    uDisplacementEnabled: false;
+    uDisplacementIntensity: number;
+    uScaleEnabled: false;
+    uScaleIntensity: number;
+    uMinScale: number;
+    uMaxScale: number;
+    uVortexEnabled: false;
+    uVortexIntensity: number;
+    uVortexSpeed: number;
+    uGeneralWaveEnabled: false;
+    uGeneralWaveIntensity: number;
+    uGeneralWaveFrequency: number;
+    uGeneralWaveSpeed: number;
+    uGeneralWaveDirection: number;
+    uGeneralVortexEnabled: false;
+    uGeneralVortexIntensity: number;
+    uGeneralVortexSpeed: number;
+    uGeneralVortexCenterX: number;
+    uGeneralVortexCenterY: number;
+    uGeneralRippleEnabled: false;
+    uGeneralRippleIntensity: number;
+    uGeneralRippleSpeed: number;
+    uGeneralRippleCenterX: number;
+    uGeneralRippleCenterY: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=VolumetricCloudsPointsMaterial.d.ts.map

package/dist/shaders/VolumetricCloudsPointsMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VolumetricCloudsPointsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/VolumetricCloudsPointsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAKhD,MAAM,WAAW,sCAAsC;IACnD,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,eAAe,EAAE;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,MAAM,EAAE;QACJ,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAmGD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCX,CAAC"}

package/dist/shaders/VolumetricCloudsPointsMaterial.js

@@ -0,0 +1,143 @@
+import { Vector3, Vector2, Color } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { commonNoiseFunctions } from "./CommonNoiseFunctions.js";
+import { effectsVertexGLSL } from "./effects/EffectsVertexFunctions.glsl.js";
+const vertexShader = /*glsl*/ `
+${effectsVertexGLSL}
+
+uniform float uPointSize;
+varying vec2 vTexCoords;
+uniform float uMorphProgress;
+attribute vec3 targetPosition;
+uniform bool uScaleEnabled;
+uniform float uScaleIntensity;
+uniform float uMinScale;
+uniform float uMaxScale;
+attribute vec2 aUV;
+varying vec2 vUV;
+varying vec3 vPosition;
+
+void main() {
+  vUV = aUV;
+  vPosition = position;
+  
+  vec3 morphedPos = mix(position, targetPosition, uMorphProgress);
+  
+  if (uGeneralWaveEnabled) {
+    float waveInput = uGeneralWaveDirection < 0.5 ? morphedPos.x : 
+                      uGeneralWaveDirection < 1.5 ? morphedPos.y : 
+                      morphedPos.x + morphedPos.y;
+    morphedPos.z += sin(waveInput * uGeneralWaveFrequency + u_time * uGeneralWaveSpeed) * uGeneralWaveIntensity;
+  }
+  
+  if (uGeneralVortexEnabled) {
+    vec2 generalCenter = vec2(uGeneralVortexCenterX, uGeneralVortexCenterY);
+    vec2 toCenter = morphedPos.xy - generalCenter;
+    float angle = uGeneralVortexIntensity * u_time * uGeneralVortexSpeed;
+    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+    morphedPos.xy = generalCenter + rotation * toCenter;
+  }
+  
+  if (uGeneralRippleEnabled) {
+    morphedPos = applyGeneralRipple(morphedPos);
+  }
+  
+  vec2 scaledPointer = u_pointer * 5.0;
+  float dist = distance(morphedPos.xy, scaledPointer);
+  float falloff = smoothstep(uPointerEffectRadius, 0.0, dist);
+  
+  if (uRippleEnabled && falloff > 0.0) {
+    morphedPos.z += sin(dist * 5.0 - u_time * uRippleSpeed) * uRippleIntensity * falloff * 0.5;
+  }
+  
+  if (uDisplacementEnabled && falloff > 0.0) {
+    vec2 dir = normalize(morphedPos.xy - scaledPointer);
+    morphedPos.xy += dir * uDisplacementIntensity * falloff * 2.0;
+  }
+  
+  if (uVortexEnabled && falloff > 0.0) {
+    vec2 toPointer = morphedPos.xy - scaledPointer;
+    float angle = uVortexIntensity * falloff * u_time * uVortexSpeed;
+    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+    morphedPos.xy = scaledPointer + rotation * toPointer;
+  }
+  
+  vTexCoords = morphedPos.xy;
+  
+  vec4 mvPosition = modelViewMatrix * vec4(morphedPos, 1.0);
+  gl_Position = projectionMatrix * mvPosition;
+  
+  float sizeMultiplier = 1.0;
+  if (uScaleEnabled && falloff > 0.0) {
+    sizeMultiplier = mix(uMinScale, uMaxScale, falloff * uScaleIntensity);
+  }
+  gl_PointSize = uPointSize * sizeMultiplier;
+}
+`;
+const fragmentShader = /*glsl*/ `
+uniform float u_time;
+uniform float u_cloudDensity;
+uniform float u_cloudCoverage;
+uniform vec3 u_lightColor;
+uniform vec3 u_shadowColor;
+uniform vec3 uColor;
+uniform float uOpacity;
+varying vec3 vPosition;
+
+${commonNoiseFunctions}
+
+float circle(vec2 uv, float border) {
+  return smoothstep(0.0, border, 0.5 - distance(uv, vec2(0.5)));
+}
+
+void main() {
+  vec3 spherePos = normalize(vPosition);
+  float density = fbm(spherePos * 2.0 + vec3(u_time * 0.1)) - u_cloudCoverage;
+  density = max(0.0, density) * u_cloudDensity;
+  
+  vec3 cloudColor = mix(u_shadowColor, u_lightColor, density);
+  gl_FragColor = vec4(cloudColor * uColor, density * uOpacity * circle(gl_PointCoord, 0.2));
+}
+`;
+export const VolumetricCloudsPointsMaterial = shaderMaterial({
+    u_time: 0,
+    u_cloudDensity: 1.5,
+    u_cloudCoverage: 0.5,
+    u_lightColor: new Vector3(1.0, 1.0, 1.0),
+    u_shadowColor: new Vector3(0.3, 0.3, 0.4),
+    uPointSize: 5.0,
+    u_pointer: new Vector2(),
+    uColor: new Color(1.0, 1.0, 1.0),
+    uOpacity: 1.0,
+    uMorphProgress: 0.0,
+    uPointerEffectRadius: 2.5,
+    uRippleEnabled: false,
+    uRippleIntensity: 0.5,
+    uRippleSpeed: 2.0,
+    uDisplacementEnabled: false,
+    uDisplacementIntensity: 0.5,
+    uScaleEnabled: false,
+    uScaleIntensity: 0.5,
+    uMinScale: 0.5,
+    uMaxScale: 2.0,
+    uVortexEnabled: false,
+    uVortexIntensity: 0.5,
+    uVortexSpeed: 1.0,
+    uGeneralWaveEnabled: false,
+    uGeneralWaveIntensity: 0.3,
+    uGeneralWaveFrequency: 3.0,
+    uGeneralWaveSpeed: 1.0,
+    uGeneralWaveDirection: 0.0,
+    uGeneralVortexEnabled: false,
+    uGeneralVortexIntensity: 0.5,
+    uGeneralVortexSpeed: 0.5,
+    uGeneralVortexCenterX: 0.0,
+    uGeneralVortexCenterY: 0.0,
+    uGeneralRippleEnabled: false,
+    uGeneralRippleIntensity: 0.3,
+    uGeneralRippleSpeed: 2.0,
+    uGeneralRippleCenterX: 0.0,
+    uGeneralRippleCenterY: 0.0,
+}, vertexShader, fragmentShader);
+extend({ VolumetricCloudsPointsMaterial });

package/dist/shaders/WaterMaterial.d.ts

@@ -0,0 +1,110 @@
+import { Vector3 } from "three";
+import type { EffectsUniforms } from './effects/EffectsUniforms';
+export interface WaterMaterialUniforms extends EffectsUniforms {
+    u_time: {
+        value: number;
+    };
+    u_seaHeight: {
+        value: number;
+    };
+    u_seaChoppy: {
+        value: number;
+    };
+    u_seaSpeed: {
+        value: number;
+    };
+    u_seaFreq: {
+        value: number;
+    };
+    u_seaBaseColor: {
+        value: Vector3;
+    };
+    u_seaWaterColor: {
+        value: Vector3;
+    };
+    u_iterFragment: {
+        value: number;
+    };
+    u_reflectionColor: {
+        value: Vector3;
+    };
+    envMap: {
+        value: any;
+    };
+    envMapIntensity: {
+        value: number;
+    };
+}
+declare const WaterMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    uGeneralRippleEnabled: false;
+    u_time: number;
+    u_seaHeight: number;
+    u_seaChoppy: number;
+    u_seaSpeed: number;
+    u_seaFreq: number;
+    u_iterFragment: number;
+    u_seaBaseColor: Vector3;
+    u_seaWaterColor: Vector3;
+    u_reflectionColor: Vector3;
+    envMap: any;
+    envMapIntensity: number;
+    u_pointer: import("three").Vector2;
+    uPointerEffectRadius: number;
+    uGeneralWaveEnabled: boolean;
+    uGeneralWaveIntensity: number;
+    uGeneralWaveFrequency: number;
+    uGeneralWaveSpeed: number;
+    uGeneralWaveDirection: number;
+    uGeneralVortexEnabled: boolean;
+    uGeneralVortexIntensity: number;
+    uGeneralVortexSpeed: number;
+    uGeneralVortexCenterX: number;
+    uGeneralVortexCenterY: number;
+    uGeneralRippleIntensity: number;
+    uGeneralRippleSpeed: number;
+    uGeneralRippleFrequency: number;
+    uGeneralRippleCenterX: number;
+    uGeneralRippleCenterY: number;
+    uRippleEnabled: boolean;
+    uRippleIntensity: number;
+    uRippleSpeed: number;
+    uDisplacementEnabled: boolean;
+    uDisplacementIntensity: number;
+    uVortexEnabled: boolean;
+    uVortexIntensity: number;
+    uVortexSpeed: number;
+    uWaveEnabled: boolean;
+    uWaveIntensity: number;
+    uWaveFrequency: number;
+    uGeneralGrayscaleEnabled: boolean;
+    uGeneralGrayscaleMode: number;
+    uGeneralGrayscaleIntensity: number;
+    uGeneralGrayscaleContrast: number;
+    uGeneralGrayscaleBrightness: number;
+    uGeneralGrayscaleWaveFreq: number;
+    uGeneralGrayscaleWaveSpeed: number;
+    uGeneralGrayscaleWaveDir: number;
+    uGeneralGrayscalePulseSpeed: number;
+    uGeneralGrayscaleRippleSpeed: number;
+    uGeneralGrayscaleRippleCenterX: number;
+    uGeneralGrayscaleRippleCenterY: number;
+    uGlowEnabled: boolean;
+    uGlowIntensity: number;
+    uGlowColor: import("three").Color;
+    uColorShiftEnabled: boolean;
+    uColorShiftIntensity: number;
+    uColorShiftTarget: import("three").Color;
+    uBrightnessEnabled: boolean;
+    uBrightnessIntensity: number;
+    uPulseEnabled: boolean;
+    uPulseIntensity: number;
+    uPulseSpeed: number;
+    uPointerGrayscaleEnabled: boolean;
+    uPointerGrayscaleIntensity: number;
+    uPointerGrayscaleContrast: number;
+    uPointerGrayscaleBrightness: number;
+}> & {
+    key: string;
+};
+export { WaterMaterial };
+//# sourceMappingURL=WaterMaterial.d.ts.map

package/dist/shaders/WaterMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaterMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/WaterMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIhC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAGjE,MAAM,WAAW,qBAAsB,SAAQ,eAAe;IAC1D,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,eAAe,EAAE;QACb,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,iBAAiB,EAAE;QACf,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,MAAM,EAAE;QACJ,KAAK,EAAE,GAAG,CAAC;KACd,CAAC;IACF,eAAe,EAAE;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AA2MD,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBa,CAAC;AAGjC,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/shaders/WaterMaterial.js

@@ -0,0 +1,228 @@
+import { Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { effectsUniforms } from "./effects/EffectsUniforms.js";
+import { effectsVertexGLSL } from "./effects/EffectsVertexFunctions.glsl.js";
+import { effectsFragmentGLSL } from "./effects/EffectsFragmentFunctions.glsl.js";
+// Vertex shader - pass world position for mesh sync
+const vertexShader = /*glsl*/ `
+${effectsVertexGLSL}
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPosition;
+  
+  void main() {
+    vUv = uv;
+    
+    vec3 pos = position;
+    
+    // Apply general ripple effect to deform water surface
+    if (uGeneralRippleEnabled) {
+      pos = applyGeneralRipple(pos);
+    }
+    
+    vPosition = pos;
+    
+    // Calculate world position using the ripple-modified position
+    vec3 worldPos = (modelMatrix * vec4(pos, 1.0)).xyz;
+    
+    vWorldPosition = worldPos;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+// Fragment shader - high-quality mesh-based water that reacts to scene lighting
+const fragmentShader = /*glsl*/ `
+${effectsFragmentGLSL}
+
+  uniform float u_seaHeight;
+  uniform float u_seaChoppy;
+  uniform float u_seaSpeed;
+  uniform float u_seaFreq;
+  uniform vec3 u_seaBaseColor;
+  uniform vec3 u_seaWaterColor;
+  uniform float u_iterFragment;
+  uniform vec3 u_reflectionColor;
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPosition;
+  
+  // Include Three.js lighting and environment mapping
+  #include <common>
+  #include <lights_pars_begin>
+  
+  // Manual environment mapping uniforms
+  uniform samplerCube envMap;
+  uniform float envMapIntensity;
+
+  float hash(vec2 p) {
+    float h = dot(p, vec2(127.1, 311.7));	
+    return fract(sin(h) * 43758.5453123);
+  }
+  
+  float noise(in vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);	
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return -1.0 + 2.0 * mix(
+      mix(hash(i + vec2(0.0, 0.0)), hash(i + vec2(1.0, 0.0)), u.x),
+      mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), u.x), 
+      u.y
+    );
+  }
+
+  // High-quality sea wave function from OceanMaterial
+  float sea_octave(vec2 uv, float choppy) {
+    uv += noise(uv);        
+    vec2 wv = 1.0 - abs(sin(uv));
+    vec2 swv = abs(cos(uv));    
+    wv = mix(wv, swv, wv);
+    return pow(1.0 - pow(wv.x * wv.y, 0.65), choppy);
+  }
+
+  // Generate detailed water height using world position (5 iterations for quality)
+  float getWaterHeight(vec2 worldPos) {
+    float freq = u_seaFreq;
+    float amp = u_seaHeight;
+    float choppy = u_seaChoppy;
+    
+    vec2 uv = worldPos; 
+    uv.x *= 0.75;
+    
+    float SEA_TIME = 1.0 + u_time * u_seaSpeed;
+    mat2 octave_m = mat2(1.6, 1.2, -1.2, 1.6);
+    
+    float d, h = 0.0;    
+    for(int i = 0; i < 5; i++) {        
+      if(float(i) >= u_iterFragment) break;
+      d = sea_octave((uv + SEA_TIME) * freq, choppy);
+      d += sea_octave((uv - SEA_TIME) * freq, choppy);
+      h += d * amp;        
+      uv *= octave_m; 
+      freq *= 1.9; 
+      amp *= 0.22;
+      choppy = mix(choppy, 1.0, 0.2);
+    }
+    return h;
+  }
+
+  // Calculate water normal using world position
+  vec3 getWaterNormal(vec2 worldPos, float eps) {
+    float h = getWaterHeight(worldPos);
+    float hx = getWaterHeight(worldPos + vec2(eps, 0.0)) - h;
+    float hz = getWaterHeight(worldPos + vec2(0.0, eps)) - h;
+    return normalize(vec3(-hx, eps, -hz));
+  }
+
+  // Sky color calculation using environment mapping
+  vec3 getSkyColor(vec3 reflectedDir) {
+    // Use envMapIntensity to check if environment mapping is enabled
+    if (envMapIntensity > 0.0) {
+      vec4 envColor = textureCube(envMap, reflectedDir);
+      return envColor.rgb * envMapIntensity;
+    } else {
+      // Fallback sky color
+      vec3 e = normalize(reflectedDir);
+      e.y = (max(e.y, 0.0) * 0.8 + 0.2) * 0.8;
+      return vec3(pow(1.0 - e.y, 2.0), 1.0 - e.y, 0.6 + (1.0 - e.y) * 0.4) * 1.1;
+    }
+  }
+
+  // Lighting from OceanMaterial
+  float diffuse(vec3 n, vec3 l, float p) {
+    return pow(dot(n, l) * 0.4 + 0.6, p);
+  }
+  
+  float specular(vec3 n, vec3 l, vec3 e, float s) {    
+    float nrm = (s + 8.0) / (PI * 8.0);
+    return pow(max(dot(reflect(e, n), l), 0.0), s) * nrm;
+  }
+
+  void main() {
+    // Use world position for wave calculations (syncs with mesh)
+    vec2 waterPos = vWorldPosition.xz;
+    
+    // Calculate water height and normal with high detail
+    float waterHeight = getWaterHeight(waterPos);
+    vec3 normal = getWaterNormal(waterPos, 0.1);
+    
+    // Calculate view direction
+    vec3 viewDir = normalize(cameraPosition - vWorldPosition);
+    
+    // Fresnel effect
+    float fresnel = clamp(1.0 - dot(normal, viewDir), 0.0, 1.0);
+    fresnel = min(fresnel * fresnel * fresnel, 0.5);
+    
+    // Simple default lighting for now - will be enhanced with scene lights
+    vec3 lightDir = normalize(vec3(0.5, 1.0, 0.3));
+    float NdotL = max(dot(normal, lightDir), 0.0);
+    vec3 totalLight = vec3(0.3, 0.4, 0.5) + vec3(1.0, 0.95, 0.8) * NdotL * 0.7;
+    
+    // Add environment-based lighting if available
+    if (envMapIntensity > 0.0) {
+      vec3 envAmbient = textureCube(envMap, normal).rgb * 0.2 * envMapIntensity;
+      totalLight += envAmbient;
+    }
+    
+    // Calculate reflections using environment map or fallback to sky color
+    vec3 reflectedDir = reflect(-viewDir, normal);
+    vec3 reflected;
+    
+    if (envMapIntensity > 0.0) {
+      // Use environment map for reflections (captures scene objects)
+      // Transform reflection direction to world space for cube texture sampling
+      vec3 worldReflectedDir = normalize(reflectedDir);
+      reflected = textureCube(envMap, worldReflectedDir).rgb;
+      
+      // Apply intensity and ensure we see the reflection
+      reflected *= envMapIntensity;
+    } else {
+      // Fallback to sky color
+      reflected = getSkyColor(reflectedDir);
+    }
+    
+    // Base refracted color
+    vec3 refracted = u_seaBaseColor + u_seaWaterColor * 0.12;
+    
+    // Mix refracted and reflected based on fresnel
+    // Boost reflection visibility for testing
+    float reflectionStrength = envMapIntensity > 0.0 ? max(fresnel, 0.3) : fresnel;
+    vec3 color = mix(refracted, reflected, reflectionStrength);
+    
+    // Add depth variation based on wave height
+    color += u_seaWaterColor * waterHeight * 0.18;
+    
+    // Apply lighting
+    color *= totalLight;
+    
+    // Apply fragment effects ONLY (no vortex effects in this shader)
+    // Use world position directly - effects functions will handle pointer scaling
+    color = applyAllFragmentEffects(color, waterPos, u_pointer);
+    
+    // Post processing (gamma correction like OceanMaterial)
+    gl_FragColor = vec4(pow(color, vec3(0.65)), 1.0);
+  }
+`;
+// Create the shader material with uniforms
+const WaterMaterial = shaderMaterial({
+    // Spread effects uniforms
+    ...effectsUniforms,
+    uGeneralRippleEnabled: false,
+    // Water-specific uniforms
+    u_time: 0,
+    u_seaHeight: 0.6,
+    u_seaChoppy: 4.0,
+    u_seaSpeed: 0.8,
+    u_seaFreq: 0.16,
+    u_iterFragment: 5,
+    u_seaBaseColor: new Vector3(0.0, 0.09, 0.18),
+    u_seaWaterColor: new Vector3(0.8 * 0.6, 0.9 * 0.6, 0.6 * 0.6),
+    u_reflectionColor: new Vector3(0.5, 0.7, 1.0),
+    // Environment mapping uniforms
+    envMap: null,
+    envMapIntensity: 0.0
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ WaterMaterial });
+export { WaterMaterial };

package/dist/shaders/effects/EffectsFragmentFunctions.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const effectsFragmentGLSL = "\n  // ============================================================================\n  // UNIFORMS - All fragment effect uniforms\n  // ============================================================================\n  uniform float u_time;\n  uniform vec2 u_pointer;\n  uniform float uPointerEffectRadius;\n  \n  // General fragment effects - Grayscale\n  uniform bool uGeneralGrayscaleEnabled;\n  uniform float uGeneralGrayscaleMode;\n  uniform float uGeneralGrayscaleIntensity;\n  uniform float uGeneralGrayscaleContrast;\n  uniform float uGeneralGrayscaleBrightness;\n  uniform float uGeneralGrayscaleWaveFreq;\n  uniform float uGeneralGrayscaleWaveSpeed;\n  uniform float uGeneralGrayscaleWaveDir;\n  uniform float uGeneralGrayscalePulseSpeed;\n  uniform float uGeneralGrayscaleRippleSpeed;\n  uniform float uGeneralGrayscaleRippleCenterX;\n  uniform float uGeneralGrayscaleRippleCenterY;\n  \n  // Pointer fragment effects\n  uniform bool uGlowEnabled;\n  uniform float uGlowIntensity;\n  uniform vec3 uGlowColor;\n  uniform bool uColorShiftEnabled;\n  uniform float uColorShiftIntensity;\n  uniform vec3 uColorShiftTarget;\n  uniform bool uBrightnessEnabled;\n  uniform float uBrightnessIntensity;\n  uniform bool uPulseEnabled;\n  uniform float uPulseIntensity;\n  uniform float uPulseSpeed;\n  uniform bool uPointerGrayscaleEnabled;\n  uniform float uPointerGrayscaleIntensity;\n  uniform float uPointerGrayscaleContrast;\n  uniform float uPointerGrayscaleBrightness;\n  \n  // ============================================================================\n  // HELPER FUNCTIONS\n  // ============================================================================\n  \n  // Calculate smooth falloff from pointer position\n  float getFragmentPointerFalloff(vec2 fragPos, vec2 pointer) {\n    float dist = distance(fragPos, pointer);\n    return smoothstep(uPointerEffectRadius, 0.0, dist);\n  }\n  \n  // Convert RGB to grayscale\n  float rgbToGrayscale(vec3 color) {\n    return dot(color, vec3(0.299, 0.587, 0.114));\n  }\n  \n  // Apply contrast and brightness to grayscale value\n  float adjustGrayscale(float gray, float contrast, float brightness) {\n    return (gray - 0.5) * contrast + 0.5 + brightness;\n  }\n  \n  // ============================================================================\n  // GENERAL EFFECTS (Always active when enabled)\n  // ============================================================================\n  \n  vec3 applyGeneralGrayscale(vec3 color, vec2 fragPos) {\n    float grayscaleFactor = 0.0;\n    \n    if (uGeneralGrayscaleMode < 0.5) {\n      // Mode 0: Static\n      grayscaleFactor = uGeneralGrayscaleIntensity;\n    } else if (uGeneralGrayscaleMode < 1.5) {\n      // Mode 1: Wave\n      float wavePos = 0.0;\n      if (uGeneralGrayscaleWaveDir < 0.5) {\n        // Horizontal\n        wavePos = fragPos.x;\n      } else if (uGeneralGrayscaleWaveDir < 1.5) {\n        // Vertical\n        wavePos = fragPos.y;\n      } else {\n        // Diagonal\n        wavePos = fragPos.x + fragPos.y;\n      }\n      grayscaleFactor = (sin(wavePos * uGeneralGrayscaleWaveFreq + u_time * uGeneralGrayscaleWaveSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;\n    } else if (uGeneralGrayscaleMode < 2.5) {\n      // Mode 2: Pulse\n      grayscaleFactor = (sin(u_time * uGeneralGrayscalePulseSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;\n    } else {\n      // Mode 3: Ripple\n      vec2 rippleCenter = vec2(uGeneralGrayscaleRippleCenterX, uGeneralGrayscaleRippleCenterY);\n      float rippleDist = distance(fragPos, rippleCenter);\n      grayscaleFactor = (sin(rippleDist * 5.0 - u_time * uGeneralGrayscaleRippleSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;\n    }\n    \n    float gray = rgbToGrayscale(color);\n    gray = adjustGrayscale(gray, uGeneralGrayscaleContrast, uGeneralGrayscaleBrightness);\n    vec3 grayscaleColor = vec3(gray);\n    return mix(color, grayscaleColor, grayscaleFactor);\n  }\n  \n  // ============================================================================\n  // POINTER EFFECTS (Interactive, based on pointer position)\n  // ============================================================================\n  \n  vec3 applyPointerGlow(vec3 color, vec2 fragPos, vec2 pointer) {\n    float falloff = getFragmentPointerFalloff(fragPos, pointer);\n    if (falloff > 0.0) {\n      color += uGlowColor * uGlowIntensity * falloff;\n    }\n    return color;\n  }\n  \n  vec3 applyPointerColorShift(vec3 color, vec2 fragPos, vec2 pointer) {\n    float falloff = getFragmentPointerFalloff(fragPos, pointer);\n    if (falloff > 0.0) {\n      color = mix(color, uColorShiftTarget, uColorShiftIntensity * falloff);\n    }\n    return color;\n  }\n  \n  vec3 applyPointerBrightness(vec3 color, vec2 fragPos, vec2 pointer) {\n    float falloff = getFragmentPointerFalloff(fragPos, pointer);\n    if (falloff > 0.0) {\n      color *= (1.0 + uBrightnessIntensity * falloff);\n    }\n    return color;\n  }\n  \n  vec3 applyPointerPulse(vec3 color, vec2 fragPos, vec2 pointer) {\n    float falloff = getFragmentPointerFalloff(fragPos, pointer);\n    if (falloff > 0.0) {\n      float pulse = sin(u_time * uPulseSpeed) * 0.5 + 0.5;\n      color += vec3(pulse * uPulseIntensity * falloff);\n    }\n    return color;\n  }\n  \n  vec3 applyPointerGrayscale(vec3 color, vec2 fragPos, vec2 pointer) {\n    float falloff = getFragmentPointerFalloff(fragPos, pointer);\n    if (falloff > 0.0) {\n      float gray = rgbToGrayscale(color);\n      gray = adjustGrayscale(gray, uPointerGrayscaleContrast, uPointerGrayscaleBrightness);\n      vec3 grayscaleColor = vec3(gray);\n      color = mix(color, grayscaleColor, uPointerGrayscaleIntensity * falloff);\n    }\n    return color;\n  }\n  \n  // ============================================================================\n  // APPLY ALL FRAGMENT EFFECTS\n  // ============================================================================\n  \n  vec3 applyAllFragmentEffects(vec3 color, vec2 fragPos, vec2 pointer) {\n    // Apply pointer effects first (interactive)\n    if (uGlowEnabled) {\n      color = applyPointerGlow(color, fragPos, pointer);\n    }\n    \n    if (uBrightnessEnabled) {\n      color = applyPointerBrightness(color, fragPos, pointer);\n    }\n    \n    if (uPulseEnabled) {\n      color = applyPointerPulse(color, fragPos, pointer);\n    }\n    \n    if (uColorShiftEnabled) {\n      color = applyPointerColorShift(color, fragPos, pointer);\n    }\n    \n    if (uPointerGrayscaleEnabled) {\n      color = applyPointerGrayscale(color, fragPos, pointer);\n    }\n    \n    // Apply general effects last (global, always active)\n    if (uGeneralGrayscaleEnabled) {\n      color = applyGeneralGrayscale(color, fragPos);\n    }\n    \n    return color;\n  }\n";
+//# sourceMappingURL=EffectsFragmentFunctions.glsl.d.ts.map

package/dist/shaders/effects/EffectsFragmentFunctions.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectsFragmentFunctions.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/EffectsFragmentFunctions.glsl.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,mBAAmB,6nNAoL/B,CAAC"}