@mrigx/core 0.1.0

package/src/shaders.ts

@@ -0,0 +1,772 @@
+/**
+ * @file shaders.ts
+ * @description WGSL shaders for the Mrig optical engine.
+ */
+
+const sharedStructs = `
+struct InteractionSource {
+  position: vec2<f32>,
+  velocity: vec2<f32>,
+  radius: f32,
+  strength: f32,
+  isActive: f32,
+  padding: f32,
+};
+
+struct SurfaceData {
+  bounds: vec4<f32>,
+  style: vec4<f32>,
+  atlasUV: vec4<f32>,
+};
+
+struct Uniforms {
+  time: f32,
+  scrollY: f32,
+  resolution: vec2<f32>,
+  sourceCount: u32,
+  surfaceCount: u32,
+  scrollHeight: f32,
+  scrollDelta: f32,
+  domWidth: f32,
+  reducedMotion: f32,
+  transitionState: f32,
+  transitionY: f32,
+    fluidViscosity: f32,
+    refractionScale: f32,
+    tearLimit: f32,
+    rippleHeight: f32,
+    abyssIntensity: f32,
+    parallaxIntensity: f32,
+    pad2: f32,
+    pad3: f32,
+    cursorData: vec4<f32>,
+    @align(16) sources: array<InteractionSource, 32>,
+  @align(16) surfaces: array<SurfaceData, 128>,
+};
+
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
+`;
+
+export const simulationWGSL = sharedStructs + `
+@group(0) @binding(1) var prevTexture: texture_2d<f32>;
+@group(0) @binding(2) var textureSampler: sampler;
+@group(0) @binding(3) var maskTexture: texture_2d<f32>;
+
+struct VertexOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  var pos = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -1.0),
+    vec2<f32>( 3.0, -1.0),
+    vec2<f32>(-1.0,  3.0)
+  );
+  var output: VertexOutput;
+  output.position = vec4<f32>(pos[vertexIndex], 0.0, 1.0);
+  output.uv = pos[vertexIndex] * 0.5 + 0.5;
+  output.uv.y = 1.0 - output.uv.y;
+  return output;
+}
+
+@fragment
+  fn fs_main(@location(0) uv: vec2<f32>, @builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
+    
+    // Exactly shift the read coordinates by the accumulated integer pixel scroll delta
+    let shiftY = i32(uniforms.scrollDelta);
+    let coord = vec2<i32>(pos.xy) + vec2<i32>(0, shiftY);
+    let res = vec2<i32>(uniforms.resolution);
+    
+    // Helper to safely load pixels without bilinear filtering (prevents diffusion/smearing completely)
+    // We can't define a function inside a function in WGSL that captures outer scope cleanly, 
+    // but doing clamp inline is easy.
+    let c = clamp(coord, vec2<i32>(0), res - vec2<i32>(1));
+    let state = textureLoad(prevTexture, c, 0);
+    
+    let c_up = clamp(coord + vec2<i32>(0, 1), vec2<i32>(0), res - vec2<i32>(1));
+    let c_down = clamp(coord + vec2<i32>(0, -1), vec2<i32>(0), res - vec2<i32>(1));
+    let c_left = clamp(coord + vec2<i32>(-1, 0), vec2<i32>(0), res - vec2<i32>(1));
+    let c_right = clamp(coord + vec2<i32>(1, 0), vec2<i32>(0), res - vec2<i32>(1));
+    
+    let h_cur = state.r;
+    let h_prev = state.g;
+    var ice = state.b;
+    var iceType = state.a;
+    
+    let h_up = textureLoad(prevTexture, c_up, 0).r;
+    let h_down = textureLoad(prevTexture, c_down, 0).r;
+    let h_left = textureLoad(prevTexture, c_left, 0).r;
+    let h_right = textureLoad(prevTexture, c_right, 0).r;
+        
+      let laplacian = h_up + h_down + h_left + h_right - 4.0 * h_cur;
+      
+      let mask = textureSampleLevel(maskTexture, textureSampler, uv, 0.0);
+      let surfaceAlpha = mask.a;
+      
+      // --- PHASE 5: Z-AXIS SUBMERSION (PHYSICS) ---
+      let maxScroll = max(1.0, uniforms.scrollHeight - uniforms.resolution.y);
+      let depth = clamp(uniforms.scrollY / maxScroll, 0.0, 1.0) * uniforms.abyssIntensity;
+      
+      // Deeper water is denser. Waves travel slower but decay slower (heavier ripples).
+      let basePropagation = mix(0.48, 0.20, depth);
+      let baseDamping = mix(0.96, 0.99, depth);
+      
+      let propagation = mix(basePropagation, 0.15, surfaceAlpha); 
+      var damping = mix(baseDamping, 0.94, surfaceAlpha);
+      
+      // Ice rapidly freezes the wave energy (damping drops to 0.1)
+      damping = mix(damping, 0.1, clamp(ice * 2.0, 0.0, 1.0));
+      
+      var h_new = 2.0 * h_cur - h_prev + propagation * laplacian;
+      h_new *= damping;
+    
+      let aspect = uniforms.resolution.x / uniforms.resolution.y;
+      var uvAspect = uv;
+      uvAspect.x *= aspect;
+      
+      // --- FREEZER PLATE LOGIC (TEXT HIGHLIGHTS) ---
+      var highlightTargetIce = 0.0;
+      for (var j = 0u; j < uniforms.surfaceCount; j++) {
+          let s = uniforms.surfaces[j];
+          if (s.style.w > 0.5) { // isHighlight
+              let s_min = vec2<f32>(s.bounds.x, s.bounds.y);
+              let s_max = vec2<f32>(s.bounds.x + s.bounds.z, s.bounds.y + s.bounds.w);
+              
+              let aspect_vec = vec2<f32>(aspect, 1.0);
+              let halfSizeAspect = (s_max - s_min) * 0.5 * aspect_vec;
+              let boxCenter = (s_min + s_max) * 0.5;
+              let p_uv = (uv - boxCenter) * aspect_vec;
+              let r = 0.008; // Soft rounded corners
+              let d_vec_sdf = abs(p_uv) - halfSizeAspect + vec2<f32>(r);
+              let d = length(max(d_vec_sdf, vec2<f32>(0.0))) + min(max(d_vec_sdf.x, d_vec_sdf.y), 0.0) - r;
+              
+              let edge = 1.0 - smoothstep(-0.008, 0.008, d);
+              highlightTargetIce = max(highlightTargetIce, edge);
+          }
+      }
+      
+      if (highlightTargetIce > 0.0) {
+          ice = min(highlightTargetIce, ice + 0.08); // Refreezes fast up to the SDF mask
+          iceType = 1.0;
+      }
+    
+      // --- INTERACTION & ICE BREAKING ---
+      let wasIce = state.b; 
+      
+      for(var i = 0u; i < uniforms.sourceCount; i++) {
+        let src = uniforms.sources[i];
+        if (src.isActive > 0.0 && src.padding < 1500.0) { // Normal water disturbance (Cursor or Boat)
+          var ptrAspect = src.position;
+          ptrAspect.x *= aspect;
+          let isBoat = (src.padding > 500.0);
+          
+          let localOffset = uvAspect - ptrAspect;
+          let dist = length(localOffset);
+          let r = max(0.01, src.radius);
+          
+          if (wasIce > 0.05 || highlightTargetIce > 0.0) {
+              // We are breaking ice, or inside a freezer plate. No water ripple!
+              let breakForce = (1.0 - smoothstep(0.0, r, dist)) * src.strength;
+              ice = max(0.0, ice - breakForce * 1.5); // Soft shattered wake
+          } else {
+              // Normal water disturbance (only if no ice)
+              if (isBoat && dist < r * 2.0) {
+                  let bAngle = src.padding - 1000.0;
+                  let s = sin(-bAngle);
+                  let c = cos(-bAngle);
+                  // Rotate local space so boat points along +x
+                  let lx = localOffset.x * c - localOffset.y * s;
+                  let ly = localOffset.x * s + localOffset.y * c;
+                  
+                  // Majestic, sweeping Kelvin V-wake
+                  var wakeForce = 0.0;
+                  if (lx < -0.01) { // Only behind the boat
+                      let distBehind = -lx;
+                      let wakeArmDist = abs(abs(ly) - distBehind * 0.35); // 19.5 degree Kelvin angle
+                      // The wake gets wider and softer the further back it goes
+                      let wakeThickness = r * 0.2 + distBehind * 0.3; // Scaled down spread
+                      let armStrength = smoothstep(wakeThickness, 0.0, wakeArmDist);
+                      // Fade out over a medium distance (not too short, not too massive)
+                      let fade = smoothstep(0.15, 0.0, distBehind); // Reduced trail length
+                      wakeForce = armStrength * fade * src.strength * 0.08; // Reduced overall force
+                      
+                      // Also add the deep central propeller wash (negative displacement)
+                      let centerWash = smoothstep(wakeThickness * 0.8, 0.0, abs(ly)) * fade * src.strength * -0.04;
+                      wakeForce += centerWash;
+                  }
+                  
+                  // Bow wave (pushing water up)
+                  let bowDist = distance(vec2<f32>(lx, ly), vec2<f32>(0.02, 0.0));
+                  let bowForce = (1.0 - smoothstep(0.0, r * 0.5, bowDist)) * src.strength * 0.15; // Scaled down bow wave
+                  
+                  h_new += bowForce + wakeForce;
+                  
+              } else if (!isBoat && dist < r) {
+                  let force = (1.0 - smoothstep(0.0, r, dist)) * src.strength;
+                  h_new += force * 0.15;
+              }
+          }
+        }
+      }
+    
+      // --- MELT LOGIC ---
+      if (iceType > 0.5) {
+          // This is text highlight ice!
+          // If the text scrolled away or was deselected, instantly vanish to prevent trails!
+          if (highlightTargetIce == 0.0) {
+              ice = 0.0;
+              iceType = 0.0;
+          }
+      } else {
+          // Manual cursor ice slowly melts
+          ice = max(0.0, ice - 0.002);
+      }
+      
+      h_new = clamp(h_new, -2.0, 2.0);
+      ice = clamp(ice, 0.0, 1.0);
+      return vec4<f32>(h_new, h_cur, ice, iceType);
+    }
+`;
+
+export const surfaceMaskWGSL = sharedStructs + `
+struct VertexOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+  @location(1) @interpolate(flat) instanceIdx: u32,
+};
+
+@vertex
+fn vs_main(
+  @builtin(vertex_index) vertexIndex: u32,
+  @builtin(instance_index) instanceIndex: u32
+) -> VertexOutput {
+  let surf = uniforms.surfaces[instanceIndex];
+  
+  var pos = array<vec2<f32>, 6>(
+    vec2<f32>(0.0, 0.0), vec2<f32>(1.0, 0.0), vec2<f32>(0.0, 1.0),
+    vec2<f32>(1.0, 0.0), vec2<f32>(1.0, 1.0), vec2<f32>(0.0, 1.0)
+  );
+  
+  let p = pos[vertexIndex];
+  let bounds = surf.bounds;
+  
+  var screenPos = vec2<f32>(bounds.x + p.x * bounds.z, bounds.y + p.y * bounds.w);
+  var clipPos = screenPos * 2.0 - 1.0;
+  clipPos.y = -clipPos.y; 
+
+  var output: VertexOutput;
+  output.position = vec4<f32>(clipPos, 0.0, 1.0);
+  output.uv = p; 
+  output.instanceIdx = instanceIndex;
+  return output;
+}
+
+fn sdRoundRect(p: vec2<f32>, b: vec2<f32>, r: f32) -> f32 {
+  let q = abs(p) - b + vec2<f32>(r);
+  return min(max(q.x, q.y), 0.0) + length(max(q, vec2<f32>(0.0))) - r;
+}
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+  let surf = uniforms.surfaces[in.instanceIdx];
+  let aspect = uniforms.resolution.x / uniforms.resolution.y;
+  
+  var p = in.uv - 0.5; 
+  let widthAspect = surf.bounds.z * aspect;
+  let height = surf.bounds.w;
+  
+  p.x *= widthAspect;
+  p.y *= height;
+  
+  let halfSize = vec2<f32>(widthAspect * 0.5, height * 0.5);
+  let r = surf.style.x; 
+  
+  let d = sdRoundRect(p, halfSize, r);
+  let pixelSize = 1.0 / uniforms.resolution.y;
+  let alpha = 1.0 - smoothstep(-pixelSize, pixelSize, d);
+  
+  if (alpha < 0.01) {
+    discard;
+  }
+  
+  let edgeRim = smoothstep(0.0, pixelSize * 40.0, -d);
+  let materialId = surf.style.y;
+  let strength = surf.style.z;
+  
+    return vec4<f32>(materialId, strength, edgeRim, alpha);
+}
+`;
+
+export const opticalWGSL = sharedStructs + `
+@group(0) @binding(1) var simTexture: texture_2d<f32>;
+@group(0) @binding(2) var textureSampler: sampler;
+@group(0) @binding(3) var maskTexture: texture_2d<f32>;
+@group(0) @binding(4) var domTexture: texture_2d<f32>;
+@group(0) @binding(5) var atlasTexture: texture_2d<f32>;
+
+struct VertexOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  var pos = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -1.0), vec2<f32>( 3.0, -1.0), vec2<f32>(-1.0,  3.0)
+  );
+  var output: VertexOutput;
+  output.position = vec4<f32>(pos[vertexIndex], 0.0, 1.0);
+  output.uv = pos[vertexIndex] * 0.5 + 0.5;
+  output.uv.y = 1.0 - output.uv.y;
+  return output;
+}
+
+fn mrigSpectral(t: f32) -> vec3<f32> {
+  var c = vec3<f32>(0.05, 0.09, 0.34); // Base: Deep Navy (#0D1757)
+  
+  // Cobalt (#2C4FAB)
+  c = mix(c, vec3<f32>(0.17, 0.31, 0.67), smoothstep(0.00, 0.15, t));
+  // Electric Blue (#405FD2)
+  c = mix(c, vec3<f32>(0.25, 0.37, 0.82), smoothstep(0.10, 0.25, t));
+  // Cyan (soft)
+  c = mix(c, vec3<f32>(0.00, 0.80, 1.00), smoothstep(0.20, 0.35, t));
+  // Ice Blue / White (#DDEFF3) - Peak specular flash
+  c = mix(c, vec3<f32>(0.87, 0.94, 0.95), smoothstep(0.30, 0.45, t));
+  // Violet (#514A9A)
+  c = mix(c, vec3<f32>(0.32, 0.29, 0.60), smoothstep(0.40, 0.60, t));
+  // Magenta (#8A4D9A)
+  c = mix(c, vec3<f32>(0.54, 0.30, 0.60), smoothstep(0.55, 0.70, t));
+  // Coral / Red (#C25D53)
+  c = mix(c, vec3<f32>(0.76, 0.36, 0.33), smoothstep(0.65, 0.80, t));
+  // Iridescent Green (#5FAF7A)
+  c = mix(c, vec3<f32>(0.37, 0.69, 0.48), smoothstep(0.75, 0.90, t));
+  // Blue (#1A2F85)
+  c = mix(c, vec3<f32>(0.10, 0.18, 0.52), smoothstep(0.85, 1.00, t));
+  
+  return c;
+}
+
+@fragment
+fn fs_main(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  let state = textureSample(simTexture, textureSampler, uv);
+    let waveHeight = state.r;
+    
+    let texel = 1.0 / uniforms.resolution;
+  let h_up = textureSample(simTexture, textureSampler, uv + vec2<f32>(0.0, texel.y)).r;
+  let h_down = textureSample(simTexture, textureSampler, uv + vec2<f32>(0.0, -texel.y)).r;
+  let h_left = textureSample(simTexture, textureSampler, uv + vec2<f32>(-texel.x, 0.0)).r;
+  let h_right = textureSample(simTexture, textureSampler, uv + vec2<f32>(texel.x, 0.0)).r;
+  
+  // ==========================================
+  // LIGHTHOUSE POSITION & EXCLUSION ZONE
+  // ==========================================
+  let aspect = uniforms.resolution.x / uniforms.resolution.y;
+  
+  // 1 & 2. MOVE THE LIGHTHOUSE (slightly further left and down)
+  let startLightX = aspect - 0.35; 
+  let startLightY = 0.40; 
+  let scrollOffset = uniforms.scrollY / uniforms.resolution.y;
+  let currentLightY = startLightY - (scrollOffset * uniforms.parallaxIntensity);
+  
+  let lightPos = vec3<f32>(startLightX, currentLightY, 0.15); 
+  let pixelPos = vec3<f32>(uv.x * aspect, uv.y, 0.0);
+  let distToLight = length(lightPos.xy - pixelPos.xy);
+  
+  // REMOVE HOVER/CURSOR EFFECT FROM THE LIGHTHOUSE (Kept exactly as it is)
+  let exclusionMask = smoothstep(0.03, 0.16, distToLight); // Doubled exclusion radius
+  
+  let gradRaw = vec2<f32>(h_right - h_left, h_up - h_down) * 5.0; 
+  let waveCurvatureRaw = (h_up + h_down + h_left + h_right - 4.0 * waveHeight) * 20.0;
+  
+  let grad = gradRaw * exclusionMask;
+  let waveCurvature = waveCurvatureRaw * exclusionMask;
+  
+  // --- PHASE 5: Z-AXIS SUBMERSION ---
+    let maxScroll = max(1.0, uniforms.scrollHeight - uniforms.resolution.y);
+    let depth = clamp(uniforms.scrollY / maxScroll, 0.0, 1.0) * uniforms.abyssIntensity;
+    // ----------------------------------
+    
+    // Deeper = higher refractive index, more liquid distortion
+      var fluidDistortion = grad * mix(0.02, 0.05 + (uniforms.transitionState * 1.5), depth);
+      let tDistort = uniforms.transitionState;
+      let tearLimit = uniforms.tearLimit + (tDistort * 0.4); // Allow MASSIVE tearing during splash!
+      fluidDistortion = clamp(fluidDistortion, vec2<f32>(-tearLimit), vec2<f32>(tearLimit));
+  var maskUv = uv + fluidDistortion;
+  maskUv = clamp(maskUv, vec2<f32>(0.0), vec2<f32>(1.0));
+  let mask = textureSample(maskTexture, textureSampler, maskUv);
+  
+    let maskAlpha = mask.a;
+    let activeRefractionMult = mask.r / max(maskAlpha, 0.001);
+    let activeHighlight = mask.g / max(maskAlpha, 0.001);
+    // --- Phase 1: Buoyant Liquid Layouts (Rigid Body Warp Field) ---
+    var buoyantOffset = vec2<f32>(0.0);
+        var buoyantWeight = 0.001;
+      let ice = state.b;
+      var highlightIce = ice; // Use physical ice from simulation!
+      
+      for (var i = 0u; i < uniforms.surfaceCount; i++) {
+          let s = uniforms.surfaces[i];
+          let s_min = vec2<f32>(s.bounds.x, s.bounds.y);
+          let s_max = vec2<f32>(s.bounds.x + s.bounds.z, s.bounds.y + s.bounds.w);
+          let center = (s_min + s_max) * 0.5;
+          let isHighlight = s.style.w;
+          
+          let d_vec = max(s_min - uv, uv - s_max);
+          let dist = length(max(d_vec, vec2<f32>(0.0)));
+          
+          if (isHighlight < 0.5) { // Only buoyant for actual UI elements
+                let weight = exp(-dist * 35.0);
+              if (weight > 0.005) {
+                  let hCenter = textureSampleLevel(simTexture, textureSampler, center, 0.0).r;
+                  let hRight  = textureSampleLevel(simTexture, textureSampler, center + vec2<f32>(0.02, 0.0), 0.0).r;
+                  let hTop    = textureSampleLevel(simTexture, textureSampler, center + vec2<f32>(0.0, 0.02), 0.0).r;
+                  
+                  let tilt = vec2<f32>(hRight - hCenter, hTop - hCenter) * 15.0; 
+                  let localUv = uv - center;
+                    let scaleOffset = localUv * (hCenter * -0.003); // Reduced bulge for UI stability
+                    let transOffset = tilt * 0.0001; // Drastically reduced rigid-body translation to stop UI elements from running away from the cursor
+                  
+                  buoyantOffset += (scaleOffset + transOffset) * weight;
+                  buoyantWeight += weight;
+              }
+          }
+      }
+        if (buoyantWeight > 1.0) { buoyantOffset /= buoyantWeight; }
+    
+    // Micro-refraction (local glass distortion)
+      let defaultRefraction = fluidDistortion * 1.0;
+      let surfaceRefraction = fluidDistortion * activeRefractionMult;
+      var domRefraction = mix(defaultRefraction, surfaceRefraction, maskAlpha);
+    let iceWarpX = sin(uv.y * 150.0 + uniforms.time * 0.2) * 0.002;
+    let iceWarpY = cos(uv.x * 150.0 + uniforms.time * 0.2) * 0.002;
+    
+    // Completely disable water refraction inside highlight ice!
+    let activeRefraction = domRefraction * (1.0 - highlightIce);
+    let finalRefraction = activeRefraction + vec2<f32>(iceWarpX, iceWarpY) * highlightIce;
+
+    // Combine buoyant rigid warp + active refraction
+    var finalUv = uv + buoyantOffset + finalRefraction;
+      finalUv.x = (finalUv.x * uniforms.resolution.x) / uniforms.domWidth;
+      finalUv.y = (finalUv.y * uniforms.resolution.y + uniforms.scrollY) / uniforms.scrollHeight;
+      finalUv = clamp(finalUv, vec2<f32>(0.0), vec2<f32>(1.0));
+      
+      // Smooth multi-sample frost blur for elegant glass look
+          // Increase base frost and add massive localized frost on the ripples during splash
+          let localFrost = 2.0 + abs(waveHeight) * 150.0;
+          let depthBlur = (pow(depth, 2.5) * 4.0) + (tDistort * localFrost);
+          let blurOffset = vec2<f32>(0.003, 0.003) * highlightIce;
+          
+          var domColor = vec4<f32>(0.0);
+          
+          // WARP-AWARE CULLING: Only do the heavy texture sampling if we are inside a UI element
+          if (maskAlpha > 0.0) {
+              // ATLAS CHECK: Is this pixel inside a dynamic surface?
+              var isDynamicPixel = false;
+              var dynAtlasUV = vec4<f32>(0.0);
+              var dynBounds = vec4<f32>(0.0);
+              
+              for (var i = 0u; i < uniforms.surfaceCount; i++) {
+                  let s = uniforms.surfaces[i];
+                  if (s.atlasUV.z > 0.0) { // Has atlas mapping
+                      let s_min = vec2<f32>(s.bounds.x, s.bounds.y);
+                      let s_max = vec2<f32>(s.bounds.x + s.bounds.z, s.bounds.y + s.bounds.w);
+                      if (finalUv.x >= s_min.x && finalUv.x <= s_max.x && finalUv.y >= s_min.y && finalUv.y <= s_max.y) {
+                          isDynamicPixel = true;
+                          dynAtlasUV = s.atlasUV;
+                          dynBounds = s.bounds;
+                          break;
+                      }
+                  }
+              }
+              
+              var baseColor: vec4<f32>;
+              var blur1: vec4<f32>;
+              var blur2: vec4<f32>;
+              
+              if (isDynamicPixel) {
+                  let localNorm = (finalUv - dynBounds.xy) / dynBounds.zw;
+                  let sampleUV = mix(dynAtlasUV.xy, dynAtlasUV.zw, clamp(localNorm, vec2<f32>(0.0), vec2<f32>(1.0)));
+                  let scaleUV = (dynAtlasUV.zw - dynAtlasUV.xy);
+                  let atlasBlurOffset = blurOffset * scaleUV;
+                  
+                  baseColor = textureSampleLevel(atlasTexture, textureSampler, sampleUV, depthBlur);
+                  blur1 = textureSampleLevel(atlasTexture, textureSampler, clamp(sampleUV + atlasBlurOffset, dynAtlasUV.xy, dynAtlasUV.zw), depthBlur);
+                  blur2 = textureSampleLevel(atlasTexture, textureSampler, clamp(sampleUV - atlasBlurOffset, dynAtlasUV.xy, dynAtlasUV.zw), depthBlur);
+              } else {
+                  baseColor = textureSampleLevel(domTexture, textureSampler, finalUv, depthBlur);
+                  blur1 = textureSampleLevel(domTexture, textureSampler, clamp(finalUv + blurOffset, vec2<f32>(0.0), vec2<f32>(1.0)), depthBlur);
+                  blur2 = textureSampleLevel(domTexture, textureSampler, clamp(finalUv - blurOffset, vec2<f32>(0.0), vec2<f32>(1.0)), depthBlur);
+              }
+              
+              var domColorRaw = (baseColor.rgb + blur1.rgb + blur2.rgb) / 3.0;
+              let abyssTint = mix(vec3<f32>(1.0), vec3<f32>(0.08, 0.15, 0.25), depth * 0.9);
+              domColorRaw *= abyssTint;
+              domColor = vec4<f32>(domColorRaw, baseColor.a);
+            } else {
+                // We are in the abyss (background). 
+                let baseColor = textureSampleLevel(domTexture, textureSampler, finalUv, depthBlur);
+                let abyssTint = mix(vec3<f32>(1.0), vec3<f32>(0.08, 0.15, 0.25), depth * 0.9);
+                domColor = vec4<f32>(baseColor.rgb * abyssTint, baseColor.a);
+            }
+            
+            
+    
+    var color = vec3<f32>(0.0);
+  
+  // ==========================================
+  // LAYER 2: THE LIGHT SOURCE (Top-Down View + Cycling Color)
+  // ==========================================
+  let L = normalize(lightPos - pixelPos); 
+  let dirFromLight = -L.xy;               
+  let rayAngle = atan2(dirFromLight.y, dirFromLight.x);
+  
+  let sweepSpeed = uniforms.time * 0.5;
+  let beam1 = pow(max(0.0, cos(rayAngle - sweepSpeed)), 48.0);
+  let beam2 = pow(max(0.0, cos(rayAngle - sweepSpeed + 3.14159265)), 48.0);
+  let rayBase = beam1 + beam2;
+  
+  let rayDecay = mix(0.7, 4.5, depth); // Deep water scatters the light heavily
+    let rayIntensity = rayBase * exp(-distToLight * rayDecay); // Slower decay = longer throw of light
+  
+  // 3. CYCLING LIGHT COLOR (Smooth 20-second spectral loop)
+  let cycleT = fract(uniforms.time * 0.05);
+  let beaconRayColor = mrigSpectral(cycleT); 
+  
+  color += beaconRayColor * rayIntensity * 0.35 * (1.0 - domColor.a); // Higher multiplier = more intense
+  
+  // TOP-DOWN LIGHTHOUSE STRUCTURE (Doubled Size)
+  let core = exp(-distToLight * 45.0); // Doubled core
+  let housing = smoothstep(0.012, 0.00, abs(distToLight - 0.036)) * 0.15; // Doubled housing ring
+  let corona = exp(-distToLight * 8.0) * 0.25; // Doubled radiating corona
+  
+  color += vec3<f32>(0.867, 0.937, 0.953) * core; // Core remains ice-white
+  color += beaconRayColor * (housing + corona); // Structure uses cycling emission color
+  
+  // ==========================================
+  // LAYER 3: OPTICAL RESPONSE (Liquid reacting to Light)
+    // ==========================================
+    // VOLUMETRIC STAINED GLASS CAUSTICS
+    // Trace light rays from the DOM down to the simulation floor
+    let floorDepth = 0.08;
+    var floorUv = uv - grad * floorDepth; // Light bent by the surface gradient
+    floorUv.x = (floorUv.x * uniforms.resolution.x) / uniforms.domWidth;
+    floorUv.y = (floorUv.y * uniforms.resolution.y + uniforms.scrollY) / uniforms.scrollHeight;
+    floorUv = clamp(floorUv, vec2<f32>(0.0), vec2<f32>(1.0));
+    
+    // Sample a blurred version of the DOM for ambient light projection
+    let domLightColor = textureSampleLevel(domTexture, textureSampler, floorUv, 2.5);
+    
+    // Focus the light rays based on the curvature of the liquid surface (Laplacian)
+    let causticFocus = pow(max(0.0, waveCurvature * 2.5), 1.5) * 6.0;
+    
+    // Cast caustics where there is water (not ice)
+    let causticStrength = causticFocus * (1.0 - highlightIce);
+    let stainedGlassCaustics = domLightColor.rgb * domLightColor.a * causticStrength * mix(1.0, 0.2, depth); // Caustics fade in the abyss
+    
+    // Ambient caustic wash (unfocused light leaking through)
+    let ambientCaustics = domLightColor.rgb * domLightColor.a * clamp(waveCurvature * 0.5, -0.2, 0.5) * (1.0 - highlightIce);
+    
+    color += (stainedGlassCaustics * 2.5) + (ambientCaustics * 1.5);
+    
+    // ------------------------------------------
+  let N = normalize(vec3<f32>(-grad.x, -grad.y, 1.0));
+  let V = vec3<f32>(0.0, 0.0, 1.0); 
+  let R = reflect(-L, N);
+  
+  let specularHighlight = pow(max(dot(R, V), 0.0), 32.0) * (rayBase * 0.8 + 0.2);
+  let activity = clamp(length(grad) * 20.0, 0.0, 1.0);
+  
+  // 4. AFFECTING THE LIQUID: The specular liquid flash is heavily tinted by the cycling emitted light
+  let specColor = mix(vec3<f32>(0.867, 0.937, 0.953), beaconRayColor, 0.65); 
+  color += specColor * specularHighlight * activity * 1.8;
+  
+  let intensity = clamp(length(grad) * 15.0 + abs(waveCurvature) * 3.0, 0.0, 1.0);
+  let spectralColor = mrigSpectral(intensity);
+        color = mix(color, domColor.rgb, domColor.a);
+      
+      // Elegant bright icy tint, specifically mapping text highlights to glowing frost
+      let frostTint = vec3<f32>(0.92, 0.96, 1.0); // Restored the elegant ice white/blue
+      color = mix(color, frostTint, highlightIce * 0.35);
+      
+  if (maskAlpha > 0.0) {
+       // Minimalist glass aesthetic: No thick colored 3D borders. 
+       // Only subtly illuminate the edge if a physical wave passes through it.
+         let edgeRim = mask.b / max(maskAlpha, 0.001);
+         let edgeFresnel = (1.0 - edgeRim);
+         color += vec3<f32>(edgeFresnel * max(0.0, waveCurvature) * activeHighlight * maskAlpha);
+      }
+  
+  // ==========================================
+  // LAYER 4: AUTONOMOUS BOATS (Abstract Glowing Entities)
+    // ==========================================
+    for (var i = 0u; i < uniforms.sourceCount; i++) {
+      let src = uniforms.sources[i];
+      if (src.padding > 500.0 && src.padding < 1500.0) { 
+         let bAngle = src.padding - 1000.0;
+         let bPos = src.position;
+         let pixelAspect = vec2<f32>(bPos.x * aspect, bPos.y);
+         let bDist = distance(pixelPos.xy, pixelAspect);
+         
+         if (bDist < 0.15) { 
+              let localP = pixelPos.xy - pixelAspect;
+              let s = sin(-bAngle);
+              let c = cos(-bAngle);
+              let rotP = vec2<f32>(localP.x * c - localP.y * s, localP.x * s + localP.y * c);
+              
+              // Design a proper nautical hull shape
+            let boatHalfLen = 0.025; // Bigger length
+            let boatHalfWid = 0.007; // Bigger width
+            
+            // Normalized x from -1 (stern) to 1 (bow)
+            let nx = clamp(rotP.x / boatHalfLen, -1.0, 1.0);
+            
+            // Width factor: flat at stern, pointed at bow
+            var wFactor = 1.0;
+            if (nx > 0.0) {
+                wFactor = 1.0 - (nx * nx); // Parabolic taper to front point
+            } else {
+                wFactor = 0.8 + 0.2 * (nx + 1.0); // Slight taper to stern
+            }
+            
+            let localW = boatHalfWid * wFactor;
+            
+            let dX = abs(rotP.x) - boatHalfLen;
+            let dY = abs(rotP.y) - localW;
+            let boatSDF = length(max(vec2<f32>(dX, dY), vec2<f32>(0.0))) + min(max(dX, dY), 0.0);
+            let boatAlpha = smoothstep(0.002, 0.0, boatSDF);
+            
+            if (boatAlpha > 0.0) {
+               // Fake 3D rounded hull normal
+               let nz = sqrt(max(0.0, 1.0 - (nx*nx) - (rotP.y/(localW+0.0001))*(rotP.y/(localW+0.0001))));
+               let boatN = normalize(vec3<f32>(rotP.x / boatHalfLen, rotP.y / (localW+0.0001), nz + 0.2));
+               
+               // Cabin geometry (small rectangular block in the rear half)
+               let cx = rotP.x + 0.008; // offset back
+               let cy = rotP.y;
+               let cX = abs(cx) - 0.005; // half len
+               let cY = abs(cy) - 0.003; // half wid
+               let cabinSDF = length(max(vec2<f32>(cX, cY), vec2<f32>(0.0))) + min(max(cX, cY), 0.0);
+               let isCabin = smoothstep(0.001, 0.0, cabinSDF);
+               
+               // Base color
+               var boatCol = vec3<f32>(0.04, 0.05, 0.08); // Dark hull
+               if (isCabin > 0.0) {
+                   boatCol = vec3<f32>(0.5, 0.55, 0.6); // Lighter cabin
+               }
+               
+               // Catch lighthouse light
+               let bL = normalize(lightPos - vec3<f32>(pixelAspect, 0.0));
+               let diff = max(0.0, dot(boatN, bL));
+               let spec = pow(max(0.0, dot(reflect(-bL, boatN), V)), 32.0);
+               
+               let distToL = length(lightPos.xy - pixelAspect);
+               let lIntensity = exp(-distToL * 0.7);
+               
+               // Spectral hints on the hull edges (not the cabin)
+               let edge = 1.0 - max(0.0, boatN.z);
+               let hint = mrigSpectral(fract(uniforms.time * 0.03 + bPos.x)) * edge * 0.6 * (1.0 - isCabin);
+               
+               // Illumination
+               boatCol += beaconRayColor * (diff * 0.3 + spec * (1.5 + isCabin * 2.0)) * lIntensity;
+               boatCol += hint * lIntensity;
+               
+               // Boat reacts to the Stained Glass DOM light!
+               let bFloorUv = vec2<f32>((pixelAspect.x * uniforms.resolution.x) / uniforms.domWidth, (pixelAspect.y * uniforms.resolution.y + uniforms.scrollY) / uniforms.scrollHeight);
+               let bAmbient = textureSampleLevel(domTexture, textureSampler, clamp(bFloorUv, vec2(0.0), vec2(1.0)), 4.0);
+               boatCol += bAmbient.rgb * bAmbient.a * 1.2 * (1.0 - isCabin); // Hull picks up ambient DOM light
+                 
+               let bioluminescence = mix(0.0, 3.5, pow(depth, 2.0));
+               boatCol += vec3<f32>(0.1, 0.8, 1.0) * bioluminescence * (1.0 - isCabin);
+               
+               color = mix(color, boatCol, boatAlpha);
+            }
+            
+            // Clean directional headlamp pointing forward from the bow
+            let bowOffset = vec2<f32>(cos(bAngle), sin(bAngle)) * boatHalfLen;
+            let fromBow = localP - bowOffset;
+            let distFromBow = length(fromBow);
+            let fwd = vec2<f32>(cos(bAngle), sin(bAngle));
+            
+            if (dot(fwd, fromBow) > 0.0) {
+               let toPixel = normalize(fromBow);
+               let dotFwd = dot(fwd, toPixel);
+               if (dotFwd > 0.85) {
+                  let cone = pow(max(0.0, dotFwd), 32.0);
+                  let falloff = exp(-distFromBow * 30.0);
+                  // Deep abyss makes headlamps intensely visible like anglerfish
+                  let bLightCol = mix(vec3<f32>(0.8, 0.9, 1.0), vec3<f32>(0.5, 0.9, 1.0), depth);
+                  let intensity = mix(0.4, 1.5, depth);
+                  color += bLightCol * cone * falloff * intensity;
+               }
+            }
+         } } }
+
+  // Darken slightly during massive transition splash
+  color = mix(color, color * vec3<f32>(0.2, 0.4, 0.6), tDistort * 0.7);
+  
+  // ==========================================
+  // NATIVE WEBGPU OPTICAL CURSOR
+  // ==========================================
+  let cursorX = uniforms.cursorData.x * aspect;
+  let cursorY = uniforms.cursorData.y;
+  let isText = uniforms.cursorData.z > 0.5;
+  let isClick = uniforms.cursorData.w > 0.5;
+  
+  let cDist = abs(pixelPos.xy - vec2<f32>(cursorX, cursorY));
+  
+  if (isText) {
+     // Text hover state (tall pill)
+     // Size: width ~4px, height ~24px
+     let pw = 0.002;
+     let ph = 0.012;
+     let dX = max(cDist.x - pw, 0.0);
+     let dY = max(cDist.y - ph, 0.0);
+     let sdf = length(vec2<f32>(dX, dY));
+     
+     // Core pill
+     let pill = smoothstep(0.002, 0.001, sdf);
+     // Glow
+     let glow = exp(-sdf * 120.0) * 0.6;
+     
+     color = mix(color, vec3<f32>(1.0), pill + glow);
+  } else {
+     // Normal cursor (hollow ring + glow)
+     let rBase = select(0.015, 0.010, isClick);
+     let sdf = length(cDist);
+     
+     // The solid ring edge
+     let ring = smoothstep(0.001, 0.0, abs(sdf - rBase));
+     // Inner and outer glow
+     let glow = exp(-abs(sdf - rBase) * 80.0) * 0.5;
+     // Faint inset fill
+     let fill = select(0.0, 0.1, sdf < rBase);
+     
+     color = mix(color, vec3<f32>(1.0), ring + glow + fill);
+  }
+
+  return vec4<f32>(color, 1.0);
+}
+`;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+