initial shit

addons/ninetailsrabbit.terrainy/shaders/water/lake.gdshader

@@ -0,0 +1,96 @@
+shader_type spatial;
+
+render_mode depth_draw_always, cull_disabled;
+
+uniform sampler2D DEPTH_TEXTURE : hint_depth_texture, repeat_disable, filter_nearest;
+
+group_uniforms Surface_Details;
+uniform float uv_scale: hint_range(0.0, 100.0, 0.1) = 1.0;
+uniform bool uv_triplanar = false;
+uniform float roughness : hint_range(0.0, 1.0) = 0.2;
+uniform float metallic: hint_range(0.0, 1.0) = 0.6;
+uniform float specular : hint_range(0.0, 1.0, 0.01);
+
+group_uniforms Water_Colors;
+uniform vec3 shallow_color : source_color = vec3(0.22, 0.66, 1.0);
+uniform vec3 deep_color : source_color = vec3(0.0, 0.25, 0.45);
+uniform float depth_fade_distance : hint_range(0.0, 10.0) = 1.0;
+uniform float absorbance : hint_range(0.0, 10.0) = 2.0;
+
+group_uniforms Normals;
+uniform sampler2D water_normal_noise: hint_default_white;
+uniform float normal_strength: hint_range(0.0, 1.0, 0.01) = 0.5;
+
+group_uniforms Foam;
+uniform float foam_amount : hint_range(0.0, 2.0) = 0.2;
+uniform vec3 foam_color : source_color = vec3(1);
+
+group_uniforms Waves;
+uniform float wave_time_scale: hint_range(0.0, 10.0, 0.1) = 1.0;
+
+varying vec3 uv_world_pos;
+
+vec3 screen(vec3 base, vec3 blend){
+	return 1.0 - (1.0 - base) * (1.0 - blend);
+}
+
+void vertex() {
+	uv_world_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
+}
+
+void fragment() {
+	vec2 base_uv = UV;
+	vec2 screen_uv = SCREEN_UV;
+
+	if (uv_triplanar) {
+		base_uv = uv_world_pos.xz;
+	}
+
+	base_uv.x += sin(TIME * wave_time_scale + (base_uv.x + base_uv.y) * 25.0) * 0.01;
+	base_uv.y += cos(TIME * wave_time_scale + (base_uv.x - base_uv.y) * 25.0) * 0.01;
+	screen_uv.x += sin(TIME * wave_time_scale + (screen_uv.x + screen_uv.y) * 25.0) * 0.01;
+	screen_uv.y += cos(TIME * wave_time_scale + (screen_uv.x - screen_uv.y) * 25.0) * 0.01;
+
+	/// DEPTH TEXTURE MANIPULATION ///
+	float depth = texture(DEPTH_TEXTURE, SCREEN_UV, 0.0).r;
+
+  	vec3 ndc = vec3(screen_uv * 2.0 - 1.0, depth);
+	vec4 world = INV_VIEW_MATRIX * INV_PROJECTION_MATRIX * vec4(ndc, 1.0);
+
+	float depth_texture_y = world.y / world.w;
+	float vertex_y = (INV_VIEW_MATRIX * vec4(VERTEX, 1.0)).y;
+	float vertical_depth = vertex_y - depth_texture_y;
+
+	// CHANGES THE COLOR OF GEOMETRY BEHIND IT AS THE WATER GETS DEEPER
+	float depth_fade_blend = exp(-vertical_depth / depth_fade_distance);
+	depth_fade_blend = clamp(depth_fade_blend, 0.0, 1.0);
+	/// END DEPTH TEXTURE MANIPULATION ///
+
+	// WHEN THE WATER GETS MORE SHALLOW, MORE TRANSPARENT
+	float alpha_blend = -vertical_depth * absorbance;
+	alpha_blend = clamp(1.0 - exp(alpha_blend), 0.0, 1.0);
+
+	float foam_blend = clamp(1.0 - (vertical_depth / foam_amount), 0.0, 1.0);
+	vec3 foam = foam_blend * foam_color;
+
+	vec3 final_albedo = mix(deep_color, shallow_color, depth_fade_blend);
+	final_albedo = screen(final_albedo, foam);
+
+	ALBEDO = final_albedo;
+	NORMAL_MAP = texture(water_normal_noise, base_uv * uv_scale).rgb;
+	NORMAL *= normal_strength;
+	METALLIC = metallic;
+	ROUGHNESS = roughness;
+	SPECULAR = specular;
+
+	if (FRONT_FACING) {
+		ALPHA = alpha_blend;
+	} else {
+		ALPHA = 1.0;
+	}
+}
+
+//void light() {
+//	// Called for every pixel for every light affecting the material.
+//	// Uncomment to replace the default light processing function with this one.
+//}

addons/ninetailsrabbit.terrainy/shaders/water/lake.gdshader.uid

@@ -0,0 +1 @@
+uid://cjbhb3sukklvt

addons/ninetailsrabbit.terrainy/shaders/water/ocean/ocean.gdshader

@@ -0,0 +1,432 @@
+// Modified version from https://github.com/LesusX/YouTube/blob/main/WaterShader/water.gdshader
+// The following shader is used in order to simulate a simple ocean using Gerstner waves.
+// This shader can be added in a plane mesh. For a more detailed ocean, increase the width and depth subdivison.
+// Note: On larger planes ex. 500x500, increasing the subdivision above 1000 comes at great performance cost
+
+shader_type spatial;
+
+// Set render modes: always draw depth and disable backface culling
+render_mode depth_draw_always, cull_disabled;
+
+// Uniforms for screen and depth textures
+uniform sampler2D SCREEN_TEXTURE : hint_screen_texture, filter_linear_mipmap;
+uniform sampler2D DEPTH_TEXTURE : hint_depth_texture, filter_linear_mipmap;
+
+// Group uniforms for wave parameters
+group_uniforms Waves;
+// Each wave is defined by a vec4: direction (x,y), amplitude, frequency
+uniform vec4 wave_1 = vec4(0.3, 4.0, 0.2, 0.6);
+uniform vec4 wave_2 = vec4(-0.26, -0.19, 0.01, 0.47);
+uniform vec4 wave_3 = vec4(-7.67, 5.63, 0.1, 0.38);
+uniform vec4 wave_4 = vec4(-0.42, -1.63, 0.1, 0.28);
+uniform vec4 wave_5 = vec4(1.66, 0.07, 0.15, 1.81);
+uniform vec4 wave_6 = vec4(1.20, 1.14, 0.01, 0.33);
+uniform vec4 wave_7 = vec4(-1.6, 7.3, 0.11, 0.73);
+uniform vec4 wave_8 = vec4(-0.42, -1.63, 0.15, 1.52);
+
+// Uniforms for time factor, noise zoom, and noise amplitude
+uniform float time_factor = 2.5;
+uniform float noise_zoom = 2.0;
+uniform float noise_amp = 1.0;
+
+// Group uniforms for water colors
+group_uniforms Water_colours;
+uniform vec3 base_water_color:source_color;
+uniform vec3 fresnel_water_color:source_color;
+uniform vec4 deep_water_color : source_color;
+uniform vec4 shallow_water_color : source_color;
+
+// Group uniforms for depth-related parameters
+group_uniforms Depth;
+uniform float beers_law = 0.5;
+uniform float depth_offset = -1.2;
+uniform float near = 7.0;
+uniform float far = 10000.0;
+
+// Group uniforms for edge detection and foam effects
+group_uniforms Edge_Detection;
+uniform float edge_texture_scale = 3.5;
+uniform float edge_texture_offset = 1.0;
+uniform float edge_texture_speed = 0.1;
+uniform float edge_foam_intensity = 2.0;
+uniform float edge_fade_start = -3.0;
+uniform float edge_fade_end = 6.6;
+uniform sampler2D edge_foam_texture;
+
+// Group uniforms for wave peak effects
+group_uniforms WavePeakEffect;
+uniform float peak_height_threshold = 1.0;
+uniform vec3 peak_color = vec3(1.0, 1.0, 1.0);
+uniform float peak_intensity = 1.0;
+uniform sampler2D foam_texture;
+uniform float foam_intensity = 1.0;
+uniform float foam_scale = 1.0;
+
+// Group uniforms for surface details
+group_uniforms Surface_details;
+uniform float metallic = 0.6;
+uniform float roughness = 0.045;
+uniform float uv_scale_text_a = 0.1;
+uniform vec2 uv_speed_text_a = vec2(0.42, 0.3);
+uniform float uv_scale_text_b = 0.6;
+uniform vec2 uv_speed_text_b = vec2(0.15, 0.1);
+uniform float normal_strength = 1.0;
+uniform float uv_sampler_scale = 0.3;
+uniform float blend_factor = 0.28;
+uniform sampler2D normalmap_a;
+uniform sampler2D normalmap_b;
+uniform sampler2D uv_sampler;
+uniform sampler2DArray caustic_sampler : hint_default_black;
+uniform float caustic_distortion_strength: hint_range(0.0, 0.009) = 0.001; // New uniform for tweaking
+uniform float num_caustic_layers = 16.0; // <<< IMPORTANT: DOUBLE CHECK THIS against your Texture2DArray's actual slices!
+uniform float refraction_strength = 0.05; // How much the background is distorted
+uniform float refraction_fresnel_power = 2.0;
+uniform vec3 underwater_fog_color : source_color; // New uniform for fog color
+uniform float underwater_fog_density = 0.1; // New uniform for fog density
+uniform float underwater_fog_start = 0.0; // New uniform: distance from camera where fog starts (can be negative to make it start immediately)
+
+// Fresnel function to calculate the reflection/refraction effect
+float fresnel(float amount, vec3 normal, vec3 view) {
+    return pow((1.0 - clamp(dot(normalize(normal), normalize(view)), 0.0, 1.0)), amount);
+}
+
+// Function to calculate edge depth
+float edge(float depth) {
+    depth = 2.0 * depth - 1.0;
+    return near * far / (far - depth * (near - far));
+}
+
+// Function to calculate dynamic amplitude based on position and time
+float dynamic_amplitude(vec2 pos, float time) {
+    return 1.0 + 0.5 * sin(time + length(pos) * 0.1);
+}
+
+// Hash function for noise generation
+float hash(vec2 p) {
+    return fract(sin(dot(p * 17.17, vec2(14.91, 67.31))) * 4791.9511);
+}
+
+// 2D noise function
+float noise(vec2 x) {
+    vec2 p = floor(x);
+    vec2 f = fract(x);
+    f = f * f * (3.0 - 2.0 * f);
+    vec2 a = vec2(1.0, 0.0);
+    return mix(mix(hash(p + a.yy), hash(p + a.xy), f.x),
+               mix(hash(p + a.yx), hash(p + a.xx), f.x), f.y);
+}
+
+// Fractional Brownian Motion (fBM) function for generating complex noise
+float fbm(vec2 x) {
+    float height = 0.0;
+    float amplitude = 0.5;
+    float frequency = 3.0;
+    for (int i = 0; i < 6; i++) {
+        height += noise(x * frequency) * amplitude;
+        amplitude *= 0.5;
+        frequency *= 2.0;
+    }
+    return height;
+}
+
+// Structure to hold wave results: displacement, tangent, binormal, and normal
+struct WaveResult {
+    vec3 displacement;
+    vec3 tangent;
+    vec3 binormal;
+    vec3 normal;
+};
+
+// Gerstner wave function to calculate wave displacement and normals
+WaveResult gerstner_wave(vec4 params, vec2 pos, float time) {
+    float steepness = params.z * dynamic_amplitude(pos, time);
+    float wavelength = params.w;
+    float k = 2.0 * PI / wavelength;
+    float c = sqrt(9.81 / k);
+    vec2 d = normalize(params.xy);
+    float f = k * (dot(d, pos.xy) - c * time);
+    float a = steepness / k;
+
+    vec3 displacement = vec3(d.x * (a * cos(f)), a * sin(f), d.y * (a * cos(f)));
+
+    vec3 tangent = vec3(1.0 - d.x * d.x * steepness * sin(f), steepness * cos(f), -d.x * d.y * steepness * sin(f));
+    vec3 binormal = vec3(-d.x * d.y * steepness * sin(f), steepness * cos(f), 1.0 - d.y * d.y * steepness * sin(f));
+    vec3 normal = normalize(cross(tangent, binormal));
+
+    return WaveResult(displacement, tangent, binormal, normal);
+}
+
+// Function to combine multiple Gerstner waves
+WaveResult wave(vec2 pos, float time) {
+    WaveResult waveResult;
+    waveResult.displacement = vec3(0.0);
+    waveResult.tangent = vec3(1.0, 0.0, 0.0);
+    waveResult.binormal = vec3(0.0, 0.0, 1.0);
+    waveResult.normal = vec3(0.0, 1.0, 0.0);
+
+    WaveResult wr;
+    wr = gerstner_wave(wave_1, pos, time);
+    waveResult.displacement += wr.displacement;
+    waveResult.tangent += wr.tangent;
+    waveResult.binormal += wr.binormal;
+    waveResult.normal += wr.normal;
+
+    wr = gerstner_wave(wave_2, pos, time);
+    waveResult.displacement += wr.displacement;
+    waveResult.tangent += wr.tangent;
+    waveResult.binormal += wr.binormal;
+    waveResult.normal += wr.normal;
+
+    wr = gerstner_wave(wave_3, pos, time);
+    waveResult.displacement += wr.displacement;
+    waveResult.tangent += wr.tangent;
+    waveResult.binormal += wr.binormal;
+    waveResult.normal += wr.normal;
+
+    wr = gerstner_wave(wave_4, pos, time);
+    waveResult.displacement += wr.displacement;
+    waveResult.tangent += wr.tangent;
+    waveResult.binormal += wr.binormal;
+    waveResult.normal += wr.normal;
+
+    wr = gerstner_wave(wave_5, pos, time);
+    waveResult.displacement += wr.displacement;
+    waveResult.tangent += wr.tangent;
+    waveResult.binormal += wr.binormal;
+    waveResult.normal += wr.normal;
+
+    wr = gerstner_wave(wave_6, pos, time);
+    waveResult.displacement += wr.displacement;
+    waveResult.tangent += wr.tangent;
+    waveResult.binormal += wr.binormal;
+    waveResult.normal += wr.normal;
+
+    wr = gerstner_wave(wave_7, pos, time);
+    waveResult.displacement += wr.displacement;
+    waveResult.tangent += wr.tangent;
+    waveResult.binormal += wr.binormal;
+    waveResult.normal += wr.normal;
+
+    wr = gerstner_wave(wave_8, pos, time);
+    waveResult.displacement += wr.displacement;
+    waveResult.tangent += wr.tangent;
+    waveResult.binormal += wr.binormal;
+    waveResult.normal += wr.normal;
+
+    // Add noise to the wave displacement for more natural look
+    waveResult.displacement.y += fbm(pos.xy * (noise_zoom / 50.0)) * noise_amp;
+
+    return waveResult;
+}
+
+// Varying variables to pass data from vertex to fragment shader
+varying float height;
+varying vec3 world_position;
+varying mat3 tbn_matrix;
+varying mat4 inv_mvp;
+
+// Vertex shader function
+void vertex() {
+    // Calculate time based on the global TIME variable and time_factor
+    float time = TIME / time_factor;
+    // Calculate wave displacement and normals
+    WaveResult waveResult = wave(VERTEX.xz, time);
+    // Apply wave displacement to the vertex position
+    VERTEX += waveResult.displacement;
+    // Store the height of the wave displacement
+    height = waveResult.displacement.y;
+
+    // Transform normals, tangents, and binormals to world space
+    vec3 n = normalize((MODELVIEW_MATRIX * vec4(waveResult.normal, 0.0)).xyz);
+    vec3 t = normalize((MODELVIEW_MATRIX * vec4(waveResult.tangent.xyz, 0.0)).xyz);
+    vec3 b = normalize((MODELVIEW_MATRIX * vec4((cross(waveResult.normal, waveResult.tangent.xyz)), 0.0)).xyz);
+    // Calculate world position of the vertex
+    world_position = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
+    // Create TBN matrix for normal mapping
+    tbn_matrix = mat3(t, b, n);
+    // Calculate inverse MVP matrix for screen space transformations
+    inv_mvp = inverse(PROJECTION_MATRIX * MODELVIEW_MATRIX);
+}
+
+// Fragment shader function
+void fragment() {
+    // Calculate UV coordinates based on world position
+    vec2 uv = world_position.xz;
+    // Sample UV offset texture
+    vec2 uv_offset = texture(uv_sampler, uv * uv_sampler_scale).rg;
+
+    // Calculate animated UV coordinates for normal maps
+    vec2 animated_uv_a = (uv + uv_speed_text_a * TIME + uv_offset) * uv_scale_text_a;
+    vec2 animated_uv_b = (uv + uv_speed_text_b * TIME + uv_offset) * uv_scale_text_b;
+    // Sample normal maps
+    vec3 normal_sample_a = texture(normalmap_a, animated_uv_a).rgb;
+    vec3 normal_sample_b = texture(normalmap_b, animated_uv_b).rgb;
+
+    // Normalize normal samples and combine them
+    normal_sample_a = normalize(normal_sample_a * 2.0 - 1.0);
+    normal_sample_b = normalize(normal_sample_b * 2.0 - 1.0);
+    vec3 combined_normal = normalize(mix(normal_sample_a, normal_sample_b, blend_factor));
+
+    // Perturb the normal using the TBN matrix
+    vec3 perturbed_normal = normalize(tbn_matrix * (combined_normal * normal_strength));
+    // Sample depth texture
+    float depth_raw = texture(DEPTH_TEXTURE, SCREEN_UV).r;
+    float depth = PROJECTION_MATRIX[3][2] / (depth_raw + PROJECTION_MATRIX[2][2]);
+
+    // Calculate the distance from the camera to the water surface
+    float camera_depth = INV_VIEW_MATRIX[3].y - world_position.y;
+    if (camera_depth < 0.0) { // Camera is underwater
+        // Map the depth to a range where deeper = positive beers_law, closer = negative beers_law
+        float depth_factor = smoothstep(-10.0, 0.0, camera_depth); // Adjust -10.0 for the depth range
+        ALPHA -= depth_factor * 0.3;
+        }
+    // Calculate depth blend factor using Beer's law
+    float depth_blend = exp((depth + VERTEX.z + depth_offset) * -beers_law);
+    depth_blend = clamp(1.0 - depth_blend, 0.0, 1.0);
+    float depth_blend_power = clamp(pow(depth_blend, 2.5), 0.0, 1.0);
+
+	// --- Refraction Distortion Implementation ---
+	vec2 refraction_uv_offset = perturbed_normal.xy * refraction_strength; // Use XY of normal for 2D screen UV distortion
+	// Add some noise to the offset for more organic look (optional, can be subtle)
+	refraction_uv_offset += texture(uv_sampler, SCREEN_UV * 0.1 + TIME * 0.05).rg * 0.01;
+
+	// The final UV for sampling the screen texture
+	vec2 refracted_screen_uv = SCREEN_UV + refraction_uv_offset;
+
+	// Blend between refracted and original screen UV based on fresnel (less refraction at grazing angles)
+	// This makes reflections stronger than refraction at high angles, which is physically correct.
+	float refraction_fresnel = fresnel(refraction_fresnel_power, NORMAL, VIEW); // Use original NORMAL for camera view
+	refracted_screen_uv = mix(SCREEN_UV, refracted_screen_uv, 1.0 - refraction_fresnel);
+
+    // Sample screen color using the new refracted UVand blend it with depth color
+	vec3 screen_color = textureLod(SCREEN_TEXTURE, refracted_screen_uv, depth_blend_power * 2.5).rgb;
+    vec3 depth_color = mix(shallow_water_color.rgb, deep_water_color.rgb, depth_blend_power);
+    vec3 color = mix(screen_color * depth_color, depth_color * 0.25, depth_blend_power * 0.5);
+
+    // Calculate depth difference for edge detection
+    float z_depth = edge(texture(DEPTH_TEXTURE, SCREEN_UV).x);
+    float z_pos = edge(FRAGCOORD.z);
+    float z_dif = z_depth - z_pos;
+
+	// Calculate caustic effect
+	vec4 caustic_screenPos = vec4(SCREEN_UV * 2.0 - 1.0, depth_raw, 1.0);
+	vec4 caustic_localPos = inv_mvp * caustic_screenPos;
+	caustic_localPos = vec4(caustic_localPos.xyz / caustic_localPos.w, caustic_localPos.w);
+
+	vec2 caustic_Uv = caustic_localPos.xz / vec2(1024.0) + 0.5;
+	caustic_Uv += perturbed_normal.xz * caustic_distortion_strength;
+
+	float caustic_layer_index = floor(mod(TIME * 26.0, num_caustic_layers)); // Use floor for integer index
+
+	vec4 caustic_color = texture(caustic_sampler, vec3(caustic_Uv * 660.0, caustic_layer_index));
+	float caustic_intensity_multiplier = (1.0 - depth_blend_power) * 6.0;
+
+	color *= 1.0 + pow(caustic_color.r, 1.50) * caustic_intensity_multiplier;
+
+ // Calculate fresnel effect
+    float fresnel = fresnel(5.0, NORMAL, VIEW);
+    vec3 surface_color = mix(base_water_color, fresnel_water_color, fresnel);
+
+    // Calculate edge foam effect
+    vec2 edge_uv = world_position.xz * edge_texture_scale + edge_texture_offset + TIME * edge_texture_speed;
+    float edge_fade = smoothstep(edge_fade_start, edge_fade_end, z_dif);
+    vec3 depth_color_adj = mix(texture(edge_foam_texture, edge_uv).rgb * edge_foam_intensity, color, edge_fade);
+
+    // Apply peak color effect based on height with noise
+   // --- Peak Foam Effect ---
+	// Foam should appear on higher peaks
+	// The height uniform comes from the vertex shader's displacement.y
+	float foam_threshold_start = peak_height_threshold;
+	float foam_threshold_end = peak_height_threshold + 0.2; // Adjust for fade range
+
+	// Smoothstep creates a gradient for foam appearance based on height
+	float height_foam_alpha = smoothstep(foam_threshold_start, foam_threshold_end, height);
+
+	// Add noise to make foam patchy and less uniform
+	// Use a faster moving noise for foam animation
+	float foam_noise = fbm(world_position.xz * 0.5 + TIME * 0.5); // Faster moving noise
+	height_foam_alpha *= foam_noise * 2.0; // Intensify and make patchier
+
+	// Clamp to ensure alpha is between 0 and 1
+	height_foam_alpha = clamp(height_foam_alpha, 0.0, 1.0);
+
+	// Sample foam texture for detail. Add some distortion based on normals for more realism.
+	// Perturb the foam UV slightly by the normal map for more organic look
+	vec2 foam_uv_distorted = world_position.xz * foam_scale + TIME * 0.1;
+	foam_uv_distorted += perturbed_normal.xz * 0.05; // Small distortion
+
+	float foam_texture_sample = texture(foam_texture, foam_uv_distorted).r;
+
+	// Combine height-based alpha with texture sample and overall intensity
+	float final_foam_alpha = height_foam_alpha * foam_texture_sample * foam_intensity;
+
+	// Apply peak color as a blend
+	vec3 final_color = mix(surface_color, peak_color * peak_intensity, final_foam_alpha);
+
+	// Optionally, make the foam whiter instead of just tinted
+	final_color = mix(final_color, vec3(1.0), final_foam_alpha);
+
+		// --- Underwater Fog/Color Implementation ---
+	// Check if the camera is underwater
+	float camera_water_height = INV_VIEW_MATRIX[3].y; // Camera's Y position in world space
+	float water_surface_height = world_position.y; // Water's Y position at this fragment (displaced)
+	vec3 final_albedo_color; // Declare a variable to hold the final ALBEDO before assignment
+
+// --- MODIFIED ALPHA & UNDERWATER FOG BLEND ---
+	if (camera_water_height < water_surface_height) { // Camera is underwater
+	    // Calculate the distance the camera is *below* the water surface
+	    float dist_below_surface = water_surface_height - camera_water_height;
+
+	    // Define a shallow zone where transparency and fog blend in
+	    float shallow_zone_start = 0.0;  // Camera is exactly at surface (or just below)
+	    float shallow_zone_end = 0.5;   // Camera is 0.5 units below surface (adjust this value!)
+
+	    // Calculate an alpha multiplier for the water surface itself based on depth
+	    // Smoothly transition water's alpha from 1.0 (fully opaque) to a lower value (more transparent)
+	    // as the camera goes deeper into the shallow zone.
+	    float surface_alpha_blend = smoothstep(shallow_zone_start, shallow_zone_end, dist_below_surface);
+
+	    // Apply a base transparency if desired, or fade it out completely
+	    // ALPHA = mix(1.0, 0.7, surface_alpha_blend); // Water stays somewhat opaque, becomes more transparent deeper
+	    ALPHA = mix(1.0, 0.2, surface_alpha_blend); // Water becomes quite transparent when fully submerged in shallow zone
+	    // If you want it to gradually become more transparent based on actual depth, like your old line:
+	    // float underwater_alpha_factor = smoothstep(water_surface_height - 10.0, water_surface_height, camera_water_height);
+	    // ALPHA = mix(ALPHA, 1.0 - (underwater_alpha_factor * 0.3), underwater_alpha_factor); // Combine with previous alpha
+	    // Let's stick with the simple shallow zone fade for now to fix the "holes"
+
+	    // --- Fog Amount Blending ---
+	    // The previous fog_amount is correct for fading distant objects.
+	    // We now use 'surface_alpha_blend' to mix how much of that fog is applied to what we see.
+	    // When dist_below_surface is small (camera near surface), surface_alpha_blend is low,
+	    // so we see LESS of the fog and more of the clear background.
+	    // As camera goes deeper, surface_alpha_blend increases, so we see MORE fog.
+
+	    float scene_depth_raw = texture(DEPTH_TEXTURE, SCREEN_UV).r;
+	    vec4 world_pos_from_depth_clip = INV_PROJECTION_MATRIX * vec4(SCREEN_UV * 2.0 - 1.0, scene_depth_raw, 1.0);
+	    vec3 world_pos_from_depth = world_pos_from_depth_clip.xyz / world_pos_from_depth_clip.w;
+
+	    float dist_to_scene_object = length(world_pos_from_depth - INV_VIEW_MATRIX[3].xyz);
+
+	    float fog_amount = 1.0 - exp(-(dist_to_scene_object - underwater_fog_start) * underwater_fog_density);
+	    fog_amount = clamp(fog_amount, 0.0, 1.0);
+
+	    // Adjust the fog blend based on how far below the surface the camera is
+	    // When camera is very close to surface, fog_amount is reduced (more clear)
+	    // As camera goes deeper, fog_amount is fully applied.
+	    float final_fog_blend_factor = mix(0.0, fog_amount, surface_alpha_blend); // Adjust 0.0 to a small value if you want slight fog even right at surface
+
+	    final_albedo_color = mix(color, underwater_fog_color, final_fog_blend_factor);
+	    // This mix for the water surface still holds:
+	    final_albedo_color = mix(final_albedo_color, final_color, 0.2);
+
+	} else { // Camera is above water (standard rendering)
+	    final_albedo_color = final_color + depth_color_adj;
+	}
+	// --- END MODIFIED ALPHA & UNDERWATER FOG BLEND ---
+
+    // Set the final color, metallic, roughness, and normal
+	ALBEDO = clamp(final_albedo_color, vec3(0.0), vec3(1.0)); // Assign the final albedo color
+    METALLIC = metallic;
+    ROUGHNESS = roughness;
+    NORMAL = perturbed_normal;
+}

addons/ninetailsrabbit.terrainy/shaders/water/ocean/ocean.gdshader.uid

@@ -0,0 +1 @@
+uid://bxwe0bkai5bn

addons/ninetailsrabbit.terrainy/shaders/water/ocean/ocean_water.tres

@@ -0,0 +1,74 @@
+[gd_resource type="ShaderMaterial" load_steps=8 format=3 uid="uid://dolvv80m4a8ym"]
+
+[ext_resource type="Shader" uid="uid://bxwe0bkai5bn" path="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/ocean.gdshader" id="1_dic1h"]
+[ext_resource type="CompressedTexture2DArray" uid="uid://dcvujep4v7k1b" path="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/caustic.png" id="2_103fq"]
+[ext_resource type="Texture2D" uid="uid://5dhudphm5c8o" path="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/foam_albedo.png" id="3_upbnb"]
+[ext_resource type="Texture2D" uid="uid://bfa4xeh5thwio" path="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/normal_A.png" id="4_vwqlf"]
+[ext_resource type="Texture2D" uid="uid://dpwv0qf6tb7we" path="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/normal_B.png" id="5_6jyj5"]
+
+[sub_resource type="FastNoiseLite" id="FastNoiseLite_ud4jo"]
+noise_type = 3
+domain_warp_enabled = true
+domain_warp_fractal_type = 0
+
+[sub_resource type="NoiseTexture2D" id="NoiseTexture2D_hugwt"]
+seamless = true
+seamless_blend_skirt = 0.6
+as_normal_map = true
+noise = SubResource("FastNoiseLite_ud4jo")
+
+[resource]
+render_priority = 0
+shader = ExtResource("1_dic1h")
+shader_parameter/wave_1 = Vector4(0.3, 4, 0.2, 0.6)
+shader_parameter/wave_2 = Vector4(-0.26, 0.265, 0.01, 0.47)
+shader_parameter/wave_3 = Vector4(-6.65, 5.63, 0.1, 0.38)
+shader_parameter/wave_4 = Vector4(-0.42, -1.63, 0.1, 0.28)
+shader_parameter/wave_5 = Vector4(1.66, 0.615, 0.15, 1.81)
+shader_parameter/wave_6 = Vector4(1.2, 1.14, 0.01, 0.33)
+shader_parameter/wave_7 = Vector4(-1.6, 7.3, 0.11, 0.73)
+shader_parameter/wave_8 = Vector4(-0.42, -1.63, 0.15, 1.52)
+shader_parameter/time_factor = 2.5
+shader_parameter/noise_zoom = 2.0
+shader_parameter/noise_amp = 1.0
+shader_parameter/base_water_color = Color(0.25098, 0.0941176, 0.635294, 1)
+shader_parameter/fresnel_water_color = Color(0.160784, 0.631373, 0.717647, 1)
+shader_parameter/deep_water_color = Color(0.0470588, 0.0392157, 0.266667, 1)
+shader_parameter/shallow_water_color = Color(0.134335, 0.413904, 0.539619, 1)
+shader_parameter/beers_law = 0.5
+shader_parameter/depth_offset = -1.2
+shader_parameter/near = 7.0
+shader_parameter/far = 10000.0
+shader_parameter/edge_texture_scale = 3.5
+shader_parameter/edge_texture_offset = 1.0
+shader_parameter/edge_texture_speed = 0.1
+shader_parameter/edge_foam_intensity = 2.0
+shader_parameter/edge_fade_start = -3.0
+shader_parameter/edge_fade_end = 6.6
+shader_parameter/edge_foam_texture = ExtResource("3_upbnb")
+shader_parameter/peak_height_threshold = 1.0
+shader_parameter/peak_color = Vector3(1, 1, 1)
+shader_parameter/peak_intensity = 1.0
+shader_parameter/foam_texture = ExtResource("3_upbnb")
+shader_parameter/foam_intensity = 1.0
+shader_parameter/foam_scale = 1.0
+shader_parameter/metallic = 0.6
+shader_parameter/roughness = 0.045
+shader_parameter/uv_scale_text_a = 0.1
+shader_parameter/uv_speed_text_a = Vector2(0.42, 0.3)
+shader_parameter/uv_scale_text_b = 0.6
+shader_parameter/uv_speed_text_b = Vector2(0.15, 0.1)
+shader_parameter/normal_strength = 1.0
+shader_parameter/uv_sampler_scale = 0.3
+shader_parameter/blend_factor = 0.28
+shader_parameter/normalmap_a = ExtResource("4_vwqlf")
+shader_parameter/normalmap_b = ExtResource("5_6jyj5")
+shader_parameter/uv_sampler = SubResource("NoiseTexture2D_hugwt")
+shader_parameter/caustic_sampler = ExtResource("2_103fq")
+shader_parameter/caustic_distortion_strength = 0.001
+shader_parameter/num_caustic_layers = 16.0
+shader_parameter/refraction_strength = 0.05
+shader_parameter/refraction_fresnel_power = 2.0
+shader_parameter/underwater_fog_color = Color(0.184314, 0.929412, 0.164706, 1)
+shader_parameter/underwater_fog_density = 0.1
+shader_parameter/underwater_fog_start = 0.0

addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/caustic.png.import

@@ -0,0 +1,30 @@
+[remap]
+
+importer="2d_array_texture"
+type="CompressedTexture2DArray"
+uid="uid://dcvujep4v7k1b"
+path.s3tc="res://.godot/imported/caustic.png-20d1447e252529e719bd2f6f50ad94f7.s3tc.ctexarray"
+path.etc2="res://.godot/imported/caustic.png-20d1447e252529e719bd2f6f50ad94f7.etc2.ctexarray"
+metadata={
+"imported_formats": ["s3tc_bptc", "etc2_astc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/caustic.png"
+dest_files=["res://.godot/imported/caustic.png-20d1447e252529e719bd2f6f50ad94f7.s3tc.ctexarray", "res://.godot/imported/caustic.png-20d1447e252529e719bd2f6f50ad94f7.etc2.ctexarray"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+slices/horizontal=4
+slices/vertical=4

addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/foam_albedo.png.import

@@ -0,0 +1,42 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://5dhudphm5c8o"
+path.s3tc="res://.godot/imported/foam_albedo.png-c07e7d548cc5fd08fcec046c95794295.s3tc.ctex"
+path.etc2="res://.godot/imported/foam_albedo.png-c07e7d548cc5fd08fcec046c95794295.etc2.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc", "etc2_astc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/foam_albedo.png"
+dest_files=["res://.godot/imported/foam_albedo.png-c07e7d548cc5fd08fcec046c95794295.s3tc.ctex", "res://.godot/imported/foam_albedo.png-c07e7d548cc5fd08fcec046c95794295.etc2.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/normal_A.png.import

@@ -0,0 +1,42 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://bfa4xeh5thwio"
+path.s3tc="res://.godot/imported/normal_A.png-9f9f97a1168bfef20e1747f569913069.s3tc.ctex"
+path.etc2="res://.godot/imported/normal_A.png-9f9f97a1168bfef20e1747f569913069.etc2.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc", "etc2_astc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/normal_A.png"
+dest_files=["res://.godot/imported/normal_A.png-9f9f97a1168bfef20e1747f569913069.s3tc.ctex", "res://.godot/imported/normal_A.png-9f9f97a1168bfef20e1747f569913069.etc2.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=1
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/normal_B.png.import

@@ -0,0 +1,42 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://dpwv0qf6tb7we"
+path.s3tc="res://.godot/imported/normal_B.png-befe3a6f8f5ad256b138cffb2ec1eef9.s3tc.ctex"
+path.etc2="res://.godot/imported/normal_B.png-befe3a6f8f5ad256b138cffb2ec1eef9.etc2.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc", "etc2_astc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/normal_B.png"
+dest_files=["res://.godot/imported/normal_B.png-befe3a6f8f5ad256b138cffb2ec1eef9.s3tc.ctex", "res://.godot/imported/normal_B.png-befe3a6f8f5ad256b138cffb2ec1eef9.etc2.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=1
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=false
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/uv_example.png.import

@@ -0,0 +1,42 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://ch1eb1v8e4utn"
+path.s3tc="res://.godot/imported/uv_example.png-b9c1281353524aa0eff2401e42e8614c.s3tc.ctex"
+path.etc2="res://.godot/imported/uv_example.png-b9c1281353524aa0eff2401e42e8614c.etc2.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc", "etc2_astc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://addons/ninetailsrabbit.terrainy/shaders/water/ocean/textures/uv_example.png"
+dest_files=["res://.godot/imported/uv_example.png-b9c1281353524aa0eff2401e42e8614c.s3tc.ctex", "res://.godot/imported/uv_example.png-b9c1281353524aa0eff2401e42e8614c.etc2.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0