@vib3code/sdk 2.0.1

package/src/shaders/quantum/quantum.frag.glsl

@@ -0,0 +1,513 @@
+// VIB3+ Quantum System Fragment Shader (GLSL)
+// EXACT shader from QuantumVisualizer.js - Complex 3D lattice functions with holographic effects
+// Superior system with volumetric lighting, particles, and RGB glitch effects
+// Supports 24 geometry variants: 8 base + 8 Hypersphere Core + 8 Hypertetrahedron Core
+
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+    precision highp float;
+#else
+    precision mediump float;
+#endif
+
+uniform vec2 u_resolution;
+uniform float u_time;
+uniform vec2 u_mouse;
+uniform float u_geometry;
+uniform float u_gridDensity;
+uniform float u_morphFactor;
+uniform float u_chaos;
+uniform float u_speed;
+uniform float u_hue;
+uniform float u_intensity;
+uniform float u_saturation;
+uniform float u_dimension;
+uniform float u_rot4dXY;
+uniform float u_rot4dXZ;
+uniform float u_rot4dYZ;
+uniform float u_rot4dXW;
+uniform float u_rot4dYW;
+uniform float u_rot4dZW;
+uniform float u_mouseIntensity;
+uniform float u_clickIntensity;
+uniform float u_roleIntensity;
+
+// 6D rotation matrices - 3D space rotations (XY, XZ, YZ)
+mat4 rotateXY(float theta) {
+    float c = cos(theta);
+    float s = sin(theta);
+    return mat4(c, -s, 0.0, 0.0, s, c, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
+}
+
+mat4 rotateXZ(float theta) {
+    float c = cos(theta);
+    float s = sin(theta);
+    return mat4(c, 0.0, s, 0.0, 0.0, 1.0, 0.0, 0.0, -s, 0.0, c, 0.0, 0.0, 0.0, 0.0, 1.0);
+}
+
+mat4 rotateYZ(float theta) {
+    float c = cos(theta);
+    float s = sin(theta);
+    return mat4(1.0, 0.0, 0.0, 0.0, 0.0, c, -s, 0.0, 0.0, s, c, 0.0, 0.0, 0.0, 0.0, 1.0);
+}
+
+// 4D hyperspace rotations (XW, YW, ZW)
+mat4 rotateXW(float theta) {
+    float c = cos(theta);
+    float s = sin(theta);
+    return mat4(c, 0.0, 0.0, -s, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, s, 0.0, 0.0, c);
+}
+
+mat4 rotateYW(float theta) {
+    float c = cos(theta);
+    float s = sin(theta);
+    return mat4(1.0, 0.0, 0.0, 0.0, 0.0, c, 0.0, -s, 0.0, 0.0, 1.0, 0.0, 0.0, s, 0.0, c);
+}
+
+mat4 rotateZW(float theta) {
+    float c = cos(theta);
+    float s = sin(theta);
+    return mat4(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, c, -s, 0.0, 0.0, s, c);
+}
+
+vec3 project4Dto3D(vec4 p) {
+    float w = 2.5 / (2.5 + p.w);
+    return vec3(p.x * w, p.y * w, p.z * w);
+}
+
+// ========================================
+// POLYTOPE CORE WARP FUNCTIONS (24 Geometries)
+// ========================================
+vec3 warpHypersphereCore(vec3 p, int geometryIndex, vec2 mouseDelta) {
+    float radius = length(p);
+    float morphBlend = clamp(u_morphFactor * 0.6 + (u_dimension - 3.0) * 0.25, 0.0, 2.0);
+    float w = sin(radius * (1.3 + float(geometryIndex) * 0.12) + u_time * 0.0008 * u_speed);
+    w *= (0.4 + morphBlend * 0.45);
+
+    vec4 p4d = vec4(p * (1.0 + morphBlend * 0.2), w);
+    p4d = rotateXY(u_rot4dXY) * p4d;
+    p4d = rotateXZ(u_rot4dXZ) * p4d;
+    p4d = rotateYZ(u_rot4dYZ) * p4d;
+    p4d = rotateXW(u_rot4dXW) * p4d;
+    p4d = rotateYW(u_rot4dYW) * p4d;
+    p4d = rotateZW(u_rot4dZW) * p4d;
+
+    vec3 projected = project4Dto3D(p4d);
+    return mix(p, projected, clamp(0.45 + morphBlend * 0.35, 0.0, 1.0));
+}
+
+vec3 warpHypertetraCore(vec3 p, int geometryIndex, vec2 mouseDelta) {
+    vec3 c1 = normalize(vec3(1.0, 1.0, 1.0));
+    vec3 c2 = normalize(vec3(-1.0, -1.0, 1.0));
+    vec3 c3 = normalize(vec3(-1.0, 1.0, -1.0));
+    vec3 c4 = normalize(vec3(1.0, -1.0, -1.0));
+
+    float morphBlend = clamp(u_morphFactor * 0.8 + (u_dimension - 3.0) * 0.2, 0.0, 2.0);
+    float basisMix = dot(p, c1) * 0.14 + dot(p, c2) * 0.1 + dot(p, c3) * 0.08;
+    float w = sin(basisMix * 5.5 + u_time * 0.0009 * u_speed);
+    w *= cos(dot(p, c4) * 4.2 - u_time * 0.0007 * u_speed);
+    w *= (0.5 + morphBlend * 0.4);
+
+    vec3 offset = vec3(dot(p, c1), dot(p, c2), dot(p, c3)) * 0.1 * morphBlend;
+    vec4 p4d = vec4(p + offset, w);
+    p4d = rotateXY(u_rot4dXY) * p4d;
+    p4d = rotateXZ(u_rot4dXZ) * p4d;
+    p4d = rotateYZ(u_rot4dYZ) * p4d;
+    p4d = rotateXW(u_rot4dXW) * p4d;
+    p4d = rotateYW(u_rot4dYW) * p4d;
+    p4d = rotateZW(u_rot4dZW) * p4d;
+
+    vec3 projected = project4Dto3D(p4d);
+
+    float planeInfluence = min(min(abs(dot(p, c1)), abs(dot(p, c2))), min(abs(dot(p, c3)), abs(dot(p, c4))));
+    vec3 blended = mix(p, projected, clamp(0.45 + morphBlend * 0.35, 0.0, 1.0));
+    return mix(blended, blended * (1.0 - planeInfluence * 0.55), 0.2 + morphBlend * 0.2);
+}
+
+vec3 applyCoreWarp(vec3 p, float geometryType, vec2 mouseDelta) {
+    float totalBase = 8.0;
+    float coreFloat = floor(geometryType / totalBase);
+    int coreIndex = int(clamp(coreFloat, 0.0, 2.0));
+    float baseGeomFloat = mod(geometryType, totalBase);
+    int geometryIndex = int(clamp(floor(baseGeomFloat + 0.5), 0.0, totalBase - 1.0));
+
+    if (coreIndex == 1) {
+        return warpHypersphereCore(p, geometryIndex, mouseDelta);
+    }
+    if (coreIndex == 2) {
+        return warpHypertetraCore(p, geometryIndex, mouseDelta);
+    }
+    return p;
+}
+// ========================================
+
+// Complex 3D Lattice Functions - Superior Quantum Shaders
+float tetrahedronLattice(vec3 p, float gridSize) {
+    vec3 q = fract(p * gridSize) - 0.5;
+    float d1 = length(q);
+    float d2 = length(q - vec3(0.4, 0.0, 0.0));
+    float d3 = length(q - vec3(0.0, 0.4, 0.0));
+    float d4 = length(q - vec3(0.0, 0.0, 0.4));
+    float vertices = 1.0 - smoothstep(0.0, 0.04, min(min(d1, d2), min(d3, d4)));
+    float edges = 0.0;
+    edges = max(edges, 1.0 - smoothstep(0.0, 0.02, abs(length(q.xy) - 0.2)));
+    edges = max(edges, 1.0 - smoothstep(0.0, 0.02, abs(length(q.yz) - 0.2)));
+    edges = max(edges, 1.0 - smoothstep(0.0, 0.02, abs(length(q.xz) - 0.2)));
+    return max(vertices, edges * 0.5);
+}
+
+float hypercubeLattice(vec3 p, float gridSize) {
+    vec3 grid = fract(p * gridSize);
+    vec3 edges = min(grid, 1.0 - grid);
+    float minEdge = min(min(edges.x, edges.y), edges.z);
+    float lattice = 1.0 - smoothstep(0.0, 0.03, minEdge);
+
+    vec3 centers = abs(grid - 0.5);
+    float maxCenter = max(max(centers.x, centers.y), centers.z);
+    float vertices = 1.0 - smoothstep(0.45, 0.5, maxCenter);
+
+    return max(lattice * 0.7, vertices);
+}
+
+float sphereLattice(vec3 p, float gridSize) {
+    vec3 cell = fract(p * gridSize) - 0.5;
+    float sphere = 1.0 - smoothstep(0.15, 0.25, length(cell));
+
+    float rings = 0.0;
+    float ringRadius = length(cell.xy);
+    rings = max(rings, 1.0 - smoothstep(0.0, 0.02, abs(ringRadius - 0.3)));
+    rings = max(rings, 1.0 - smoothstep(0.0, 0.02, abs(ringRadius - 0.2)));
+
+    return max(sphere, rings * 0.6);
+}
+
+float torusLattice(vec3 p, float gridSize) {
+    vec3 cell = fract(p * gridSize) - 0.5;
+    float majorRadius = 0.3;
+    float minorRadius = 0.1;
+
+    float toroidalDist = length(vec2(length(cell.xy) - majorRadius, cell.z));
+    float torus = 1.0 - smoothstep(minorRadius - 0.02, minorRadius + 0.02, toroidalDist);
+
+    float rings = 0.0;
+    float angle = atan(cell.y, cell.x);
+    rings = sin(angle * 8.0) * 0.02;
+
+    return max(torus, 0.0) + rings;
+}
+
+float kleinLattice(vec3 p, float gridSize) {
+    vec3 cell = fract(p * gridSize) - 0.5;
+    float u = atan(cell.y, cell.x) / 3.14159 + 1.0;
+    float v = cell.z + 0.5;
+
+    float x = (2.0 + cos(u * 0.5)) * cos(u);
+    float y = (2.0 + cos(u * 0.5)) * sin(u);
+    float z = sin(u * 0.5) + v;
+
+    vec3 kleinPoint = vec3(x, y, z) * 0.1;
+    float dist = length(cell - kleinPoint);
+
+    return 1.0 - smoothstep(0.1, 0.15, dist);
+}
+
+float fractalLattice(vec3 p, float gridSize) {
+    vec3 cell = fract(p * gridSize);
+    cell = abs(cell * 2.0 - 1.0);
+
+    float dist = length(max(abs(cell) - 0.3, 0.0));
+
+    // Recursive subdivision
+    for(int i = 0; i < 3; i++) {
+        cell = abs(cell * 2.0 - 1.0);
+        float subdist = length(max(abs(cell) - 0.3, 0.0)) / pow(2.0, float(i + 1));
+        dist = min(dist, subdist);
+    }
+
+    return 1.0 - smoothstep(0.0, 0.05, dist);
+}
+
+float waveLattice(vec3 p, float gridSize) {
+    float time = u_time * 0.001 * u_speed;
+    vec3 cell = fract(p * gridSize) - 0.5;
+
+    float wave1 = sin(p.x * gridSize * 2.0 + time * 2.0);
+    float wave2 = sin(p.y * gridSize * 1.8 + time * 1.5);
+    float wave3 = sin(p.z * gridSize * 2.2 + time * 1.8);
+
+    float interference = (wave1 + wave2 + wave3) / 3.0;
+    float amplitude = 1.0 - length(cell) * 2.0;
+
+    return max(0.0, interference * amplitude);
+}
+
+float crystalLattice(vec3 p, float gridSize) {
+    vec3 cell = fract(p * gridSize) - 0.5;
+
+    // Octahedral crystal structure
+    float crystal = max(max(abs(cell.x) + abs(cell.y), abs(cell.y) + abs(cell.z)), abs(cell.x) + abs(cell.z));
+    crystal = 1.0 - smoothstep(0.3, 0.4, crystal);
+
+    // Add crystalline faces
+    float faces = 0.0;
+    faces = max(faces, 1.0 - smoothstep(0.0, 0.02, abs(abs(cell.x) - 0.35)));
+    faces = max(faces, 1.0 - smoothstep(0.0, 0.02, abs(abs(cell.y) - 0.35)));
+    faces = max(faces, 1.0 - smoothstep(0.0, 0.02, abs(abs(cell.z) - 0.35)));
+
+    return max(crystal, faces * 0.5);
+}
+
+// Enhanced geometry function with holographic effects (24 GEOMETRIES)
+float geometryFunction(vec4 p) {
+    // Decode geometry: base = geometry % 8 (supports 24 geometries)
+    float totalBase = 8.0;
+    float baseGeomFloat = mod(u_geometry, totalBase);
+    int geomType = int(clamp(floor(baseGeomFloat + 0.5), 0.0, totalBase - 1.0));
+
+    // Project to 3D and apply polytope warp
+    vec3 p3d = project4Dto3D(p);
+    vec3 warped = applyCoreWarp(p3d, u_geometry, vec2(0.0, 0.0));
+    float gridSize = u_gridDensity * 0.08;
+
+    if (geomType == 0) {
+        return tetrahedronLattice(warped, gridSize) * u_morphFactor;
+    }
+    else if (geomType == 1) {
+        return hypercubeLattice(warped, gridSize) * u_morphFactor;
+    }
+    else if (geomType == 2) {
+        return sphereLattice(warped, gridSize) * u_morphFactor;
+    }
+    else if (geomType == 3) {
+        return torusLattice(warped, gridSize) * u_morphFactor;
+    }
+    else if (geomType == 4) {
+        return kleinLattice(warped, gridSize) * u_morphFactor;
+    }
+    else if (geomType == 5) {
+        return fractalLattice(warped, gridSize) * u_morphFactor;
+    }
+    else if (geomType == 6) {
+        return waveLattice(warped, gridSize) * u_morphFactor;
+    }
+    else if (geomType == 7) {
+        return crystalLattice(warped, gridSize) * u_morphFactor;
+    }
+    else {
+        return hypercubeLattice(warped, gridSize) * u_morphFactor;
+    }
+}
+
+// EXTREME LAYER-BY-LAYER COLOR SYSTEM
+// Each canvas layer gets completely different color behavior
+
+// Layer-specific color palettes with extreme juxtapositions
+vec3 getLayerColorPalette(int layerIndex, float t) {
+    if (layerIndex == 0) {
+        // BACKGROUND LAYER: Deep space colors - purple/black/deep blue
+        vec3 color1 = vec3(0.05, 0.0, 0.2);   // Deep purple
+        vec3 color2 = vec3(0.0, 0.0, 0.1);    // Near black
+        vec3 color3 = vec3(0.0, 0.05, 0.3);   // Deep blue
+        return mix(mix(color1, color2, sin(t * 3.0) * 0.5 + 0.5), color3, cos(t * 2.0) * 0.5 + 0.5);
+    }
+    else if (layerIndex == 1) {
+        // SHADOW LAYER: Toxic greens and sickly yellows - high contrast
+        vec3 color1 = vec3(0.0, 1.0, 0.0);    // Pure toxic green
+        vec3 color2 = vec3(0.8, 1.0, 0.0);    // Sickly yellow-green
+        vec3 color3 = vec3(0.0, 0.8, 0.3);    // Forest green
+        return mix(mix(color1, color2, sin(t * 7.0) * 0.5 + 0.5), color3, cos(t * 5.0) * 0.5 + 0.5);
+    }
+    else if (layerIndex == 2) {
+        // CONTENT LAYER: Blazing hot colors - red/orange/white hot
+        vec3 color1 = vec3(1.0, 0.0, 0.0);    // Pure red
+        vec3 color2 = vec3(1.0, 0.5, 0.0);    // Blazing orange
+        vec3 color3 = vec3(1.0, 1.0, 1.0);    // White hot
+        return mix(mix(color1, color2, sin(t * 11.0) * 0.5 + 0.5), color3, cos(t * 8.0) * 0.5 + 0.5);
+    }
+    else if (layerIndex == 3) {
+        // HIGHLIGHT LAYER: Electric blues and cyans - crackling energy
+        vec3 color1 = vec3(0.0, 1.0, 1.0);    // Electric cyan
+        vec3 color2 = vec3(0.0, 0.5, 1.0);    // Electric blue
+        vec3 color3 = vec3(0.5, 1.0, 1.0);    // Bright cyan
+        return mix(mix(color1, color2, sin(t * 13.0) * 0.5 + 0.5), color3, cos(t * 9.0) * 0.5 + 0.5);
+    }
+    else {
+        // ACCENT LAYER: Violent magentas and purples - chaotic
+        vec3 color1 = vec3(1.0, 0.0, 1.0);    // Pure magenta
+        vec3 color2 = vec3(0.8, 0.0, 1.0);    // Violet
+        vec3 color3 = vec3(1.0, 0.3, 1.0);    // Hot pink
+        return mix(mix(color1, color2, sin(t * 17.0) * 0.5 + 0.5), color3, cos(t * 12.0) * 0.5 + 0.5);
+    }
+}
+
+// Extreme RGB separation and distortion for each layer
+vec3 extremeRGBSeparation(vec3 baseColor, vec2 uv, float intensity, int layerIndex) {
+    vec2 offset = vec2(0.01, 0.005) * intensity;
+
+    // Different separation patterns per layer
+    if (layerIndex == 0) {
+        // Background: Minimal separation, smooth
+        return baseColor + vec3(
+            sin(uv.x * 10.0 + u_time * 0.001) * 0.02,
+            cos(uv.y * 8.0 + u_time * 0.0015) * 0.02,
+            sin(uv.x * uv.y * 6.0 + u_time * 0.0008) * 0.02
+        ) * intensity;
+    }
+    else if (layerIndex == 1) {
+        // Shadow: Heavy vertical separation
+        float r = baseColor.r + sin(uv.y * 50.0 + u_time * 0.003) * intensity * 0.15;
+        float g = baseColor.g + sin((uv.y + 0.1) * 45.0 + u_time * 0.0025) * intensity * 0.12;
+        float b = baseColor.b + sin((uv.y - 0.1) * 55.0 + u_time * 0.0035) * intensity * 0.18;
+        return vec3(r, g, b);
+    }
+    else if (layerIndex == 2) {
+        // Content: Explosive radial separation
+        float dist = length(uv);
+        float angle = atan(uv.y, uv.x);
+        float r = baseColor.r + sin(dist * 30.0 + angle * 10.0 + u_time * 0.004) * intensity * 0.2;
+        float g = baseColor.g + cos(dist * 25.0 + angle * 8.0 + u_time * 0.0035) * intensity * 0.18;
+        float b = baseColor.b + sin(dist * 35.0 + angle * 12.0 + u_time * 0.0045) * intensity * 0.22;
+        return vec3(r, g, b);
+    }
+    else if (layerIndex == 3) {
+        // Highlight: Lightning-like separation
+        float lightning = sin(uv.x * 80.0 + u_time * 0.008) * cos(uv.y * 60.0 + u_time * 0.006);
+        float r = baseColor.r + lightning * intensity * 0.25;
+        float g = baseColor.g + sin(lightning * 40.0 + u_time * 0.005) * intensity * 0.2;
+        float b = baseColor.b + cos(lightning * 30.0 + u_time * 0.007) * intensity * 0.3;
+        return vec3(r, g, b);
+    }
+    else {
+        // Accent: Chaotic multi-directional separation
+        float chaos1 = sin(uv.x * 100.0 + uv.y * 80.0 + u_time * 0.01);
+        float chaos2 = cos(uv.x * 70.0 - uv.y * 90.0 + u_time * 0.008);
+        float chaos3 = sin(uv.x * uv.y * 150.0 + u_time * 0.012);
+        return baseColor + vec3(chaos1, chaos2, chaos3) * intensity * 0.3;
+    }
+}
+
+void main() {
+    vec2 uv = (gl_FragCoord.xy - u_resolution.xy * 0.5) / min(u_resolution.x, u_resolution.y);
+
+    // Enhanced 4D position with holographic depth
+    float timeSpeed = u_time * 0.0001 * u_speed;
+    vec4 pos = vec4(uv * 3.0, sin(timeSpeed * 3.0), cos(timeSpeed * 2.0));
+    pos.xy += (u_mouse - 0.5) * u_mouseIntensity * 2.0;
+
+    // Apply 6D rotations - 3D space rotations first, then 4D hyperspace
+    pos = rotateXY(u_rot4dXY) * pos;
+    pos = rotateXZ(u_rot4dXZ) * pos;
+    pos = rotateYZ(u_rot4dYZ) * pos;
+    pos = rotateXW(u_rot4dXW) * pos;
+    pos = rotateYW(u_rot4dYW) * pos;
+    pos = rotateZW(u_rot4dZW) * pos;
+
+    // Calculate enhanced geometry value
+    float value = geometryFunction(pos);
+
+    // Enhanced chaos with holographic effects
+    float noise = sin(pos.x * 7.0) * cos(pos.y * 11.0) * sin(pos.z * 13.0);
+    value += noise * u_chaos;
+
+    // Enhanced intensity calculation with holographic glow
+    float geometryIntensity = 1.0 - clamp(abs(value * 0.8), 0.0, 1.0);
+    geometryIntensity = pow(geometryIntensity, 1.5); // More dramatic falloff
+    geometryIntensity += u_clickIntensity * 0.3;
+
+    // Holographic shimmer effect
+    float shimmer = sin(uv.x * 20.0 + timeSpeed * 5.0) * cos(uv.y * 15.0 + timeSpeed * 3.0) * 0.1;
+    geometryIntensity += shimmer * geometryIntensity;
+
+    // Apply user intensity control
+    float finalIntensity = geometryIntensity * u_intensity;
+
+    // EXTREME LAYER-BY-LAYER COLOR SYSTEM
+    // Determine canvas layer from role/variant (0=background, 1=shadow, 2=content, 3=highlight, 4=accent)
+    int layerIndex = 0;
+    if (u_roleIntensity == 0.7) layerIndex = 1;      // shadow layer
+    else if (u_roleIntensity == 1.0) layerIndex = 2; // content layer
+    else if (u_roleIntensity == 0.85) layerIndex = 3; // highlight layer
+    else if (u_roleIntensity == 0.6) layerIndex = 4;  // accent layer
+
+    // Get layer-specific base color with extreme dynamics
+    // Use u_hue as global intensity modifier (0-1) affecting all layers
+    float globalIntensity = u_hue; // Now 0-1 from JavaScript
+    float colorTime = timeSpeed * 2.0 + value * 3.0 + globalIntensity * 5.0;
+    vec3 layerColor = getLayerColorPalette(layerIndex, colorTime) * (0.5 + globalIntensity * 1.5);
+
+    // Apply geometry-based intensity modulation per layer
+    vec3 extremeBaseColor;
+    if (layerIndex == 0) {
+        // Background: Subtle, fills empty space
+        extremeBaseColor = layerColor * (0.3 + geometryIntensity * 0.4);
+    }
+    else if (layerIndex == 1) {
+        // Shadow: Aggressive, high contrast where geometry is weak
+        float shadowIntensity = pow(1.0 - geometryIntensity, 2.0); // Inverted for shadows
+        extremeBaseColor = layerColor * (shadowIntensity * 0.8 + 0.1);
+    }
+    else if (layerIndex == 2) {
+        // Content: Dominant, follows geometry strongly
+        extremeBaseColor = layerColor * (geometryIntensity * 1.2 + 0.2);
+    }
+    else if (layerIndex == 3) {
+        // Highlight: Electric, peaks only
+        float peakIntensity = pow(geometryIntensity, 3.0); // Cubic for sharp peaks
+        extremeBaseColor = layerColor * (peakIntensity * 1.5 + 0.1);
+    }
+    else {
+        // Accent: Chaotic, random bursts
+        float randomBurst = sin(value * 50.0 + timeSpeed * 10.0) * 0.5 + 0.5;
+        extremeBaseColor = layerColor * (randomBurst * geometryIntensity * 2.0 + 0.05);
+    }
+
+    // Apply extreme RGB separation per layer
+    vec3 extremeColor = extremeRGBSeparation(extremeBaseColor, uv, finalIntensity, layerIndex);
+
+    // Layer-specific particle systems with extreme colors
+    float extremeParticles = 0.0;
+    if (layerIndex == 2 || layerIndex == 3) {
+        // Only content and highlight layers get particles
+        vec2 particleUV = uv * (layerIndex == 2 ? 12.0 : 20.0);
+        vec2 particleID = floor(particleUV);
+        vec2 particlePos = fract(particleUV) - 0.5;
+        float particleDist = length(particlePos);
+
+        float particleTime = timeSpeed * (layerIndex == 2 ? 3.0 : 8.0) + dot(particleID, vec2(127.1, 311.7));
+        float particleAlpha = sin(particleTime) * 0.5 + 0.5;
+        float particleSize = layerIndex == 2 ? 0.2 : 0.1;
+        extremeParticles = (1.0 - smoothstep(0.05, particleSize, particleDist)) * particleAlpha * 0.4;
+    }
+
+    // Combine extreme color with particles based on layer
+    vec3 finalColor;
+    if (layerIndex == 0) {
+        // Background: Pure extreme color
+        finalColor = extremeColor;
+    }
+    else if (layerIndex == 1) {
+        // Shadow: Dark with toxic highlights
+        finalColor = extremeColor * 0.8;
+    }
+    else if (layerIndex == 2) {
+        // Content: Blazing with white-hot particles
+        finalColor = extremeColor + extremeParticles * vec3(1.0, 1.0, 1.0);
+    }
+    else if (layerIndex == 3) {
+        // Highlight: Electric with cyan particles
+        finalColor = extremeColor + extremeParticles * vec3(0.0, 1.0, 1.0);
+    }
+    else {
+        // Accent: Chaotic magenta madness
+        finalColor = extremeColor * (1.0 + sin(timeSpeed * 20.0) * 0.3);
+    }
+
+    // Layer-specific alpha intensity with extreme contrast
+    float layerAlpha;
+    if (layerIndex == 0) layerAlpha = 0.6;        // Background: Medium
+    else if (layerIndex == 1) layerAlpha = 0.4;   // Shadow: Lower
+    else if (layerIndex == 2) layerAlpha = 1.0;   // Content: Full intensity
+    else if (layerIndex == 3) layerAlpha = 0.8;   // Highlight: High
+    else layerAlpha = 0.3;                        // Accent: Subtle bursts
+
+    gl_FragColor = vec4(finalColor, finalIntensity * layerAlpha);
+}