@vib3code/sdk 2.0.1

package/src/shaders/common/geometry24.glsl

@@ -0,0 +1,65 @@
+// VIB3+ 24 Geometry SDF Library (GLSL)
+// 8 base + 8 Hypersphere Core + 8 Hypertetrahedron Core
+
+// Base geometry SDFs (0-7)
+float baseGeometry(vec4 p, float type) {
+    if (type < 0.5) {
+        // 0: Tetrahedron
+        return max(max(max(abs(p.x + p.y) - p.z, abs(p.x - p.y) - p.z),
+                           abs(p.x + p.y) + p.z), abs(p.x - p.y) + p.z) / sqrt(3.0);
+    } else if (type < 1.5) {
+        // 1: Hypercube
+        vec4 q = abs(p) - 0.8;
+        return length(max(q, 0.0)) + min(max(max(max(q.x, q.y), q.z), q.w), 0.0);
+    } else if (type < 2.5) {
+        // 2: Sphere
+        return length(p) - 1.0;
+    } else if (type < 3.5) {
+        // 3: Torus
+        vec2 t = vec2(length(p.xy) - 0.8, p.z);
+        return length(t) - 0.3;
+    } else if (type < 4.5) {
+        // 4: Klein Bottle (simplified)
+        float r = length(p.xy);
+        return abs(r - 0.7) - 0.2 + sin(atan(p.y, p.x) * 3.0 + p.z * 5.0) * 0.1;
+    } else if (type < 5.5) {
+        // 5: Fractal (Mandelbulb approximation)
+        return length(p) - 0.8 + sin(p.x * 5.0) * sin(p.y * 5.0) * sin(p.z * 5.0) * 0.2;
+    } else if (type < 6.5) {
+        // 6: Wave
+        return abs(p.z - sin(p.x * 5.0 + u_time) * cos(p.y * 5.0 + u_time) * 0.3) - 0.1;
+    } else {
+        // 7: Crystal
+        vec4 q = abs(p);
+        return max(max(max(q.x, q.y), q.z), q.w) - 0.8;
+    }
+}
+
+// Hypersphere Core wrapper (8-15)
+float hypersphereCore(vec4 p, float baseType) {
+    float baseShape = baseGeometry(p, baseType);
+    float sphereField = length(p) - 1.2;
+    return max(baseShape, sphereField);
+}
+
+// Hypertetrahedron Core wrapper (16-23)
+float hypertetrahedronCore(vec4 p, float baseType) {
+    float baseShape = baseGeometry(p, baseType);
+    float tetraField = max(max(max(
+        abs(p.x + p.y) - p.z - p.w,
+        abs(p.x - p.y) - p.z + p.w),
+        abs(p.x + p.y) + p.z - p.w),
+        abs(p.x - p.y) + p.z + p.w) / sqrt(4.0);
+    return max(baseShape, tetraField);
+}
+
+// Main geometry dispatcher (0-23)
+float geometry(vec4 p, float type) {
+    if (type < 8.0) {
+        return baseGeometry(p, type);
+    } else if (type < 16.0) {
+        return hypersphereCore(p, type - 8.0);
+    } else {
+        return hypertetrahedronCore(p, type - 16.0);
+    }
+}

package/src/shaders/common/geometry24.wgsl

@@ -0,0 +1,54 @@
+// VIB3+ 24 Geometry SDF Library (WGSL)
+// 8 base + 8 Hypersphere Core + 8 Hypertetrahedron Core
+
+fn baseGeometry(p: vec4<f32>, t: f32) -> f32 {
+    if (t < 0.5) {
+        // 0: Tetrahedron
+        return max(max(max(abs(p.x + p.y) - p.z, abs(p.x - p.y) - p.z),
+                       abs(p.x + p.y) + p.z), abs(p.x - p.y) + p.z) / sqrt(3.0);
+    } else if (t < 1.5) {
+        // 1: Hypercube
+        let q = abs(p) - vec4<f32>(0.8);
+        return length(max(q, vec4<f32>(0.0))) + min(max(max(max(q.x, q.y), q.z), q.w), 0.0);
+    } else if (t < 2.5) {
+        // 2: Sphere
+        return length(p) - 1.0;
+    } else if (t < 3.5) {
+        // 3: Torus
+        let t2 = vec2<f32>(length(p.xy) - 0.8, p.z);
+        return length(t2) - 0.3;
+    } else if (t < 4.5) {
+        // 4: Klein Bottle (simplified)
+        let r = length(p.xy);
+        return abs(r - 0.7) - 0.2 + sin(atan2(p.y, p.x) * 3.0 + p.z * 5.0) * 0.1;
+    } else if (t < 5.5) {
+        // 5: Fractal (Mandelbulb approximation)
+        return length(p) - 0.8 + sin(p.x * 5.0) * sin(p.y * 5.0) * sin(p.z * 5.0) * 0.2;
+    } else if (t < 6.5) {
+        // 6: Wave
+        return abs(p.z - sin(p.x * 5.0 + u.time) * cos(p.y * 5.0 + u.time) * 0.3) - 0.1;
+    } else {
+        // 7: Crystal
+        let q = abs(p);
+        return max(max(max(q.x, q.y), q.z), q.w) - 0.8;
+    }
+}
+
+fn hypersphereCore(p: vec4<f32>, baseType: f32) -> f32 {
+    return max(baseGeometry(p, baseType), length(p) - 1.2);
+}
+
+fn hypertetrahedronCore(p: vec4<f32>, baseType: f32) -> f32 {
+    let tf = max(max(max(
+        abs(p.x + p.y) - p.z - p.w,
+        abs(p.x - p.y) - p.z + p.w),
+        abs(p.x + p.y) + p.z - p.w),
+        abs(p.x - p.y) + p.z + p.w) / sqrt(4.0);
+    return max(baseGeometry(p, baseType), tf);
+}
+
+fn geometry(p: vec4<f32>, t: f32) -> f32 {
+    if (t < 8.0) { return baseGeometry(p, t); }
+    else if (t < 16.0) { return hypersphereCore(p, t - 8.0); }
+    else { return hypertetrahedronCore(p, t - 16.0); }
+}

package/src/shaders/common/rotation4d.glsl

@@ -0,0 +1,85 @@
+// VIB3+ 6D Rotation Functions (GLSL)
+// 3D space: XY, XZ, YZ | 4D hyperspace: XW, YW, ZW
+
+mat4 rotateXY(float angle) {
+    float c = cos(angle);
+    float s = sin(angle);
+    return mat4(
+        c, -s, 0, 0,
+        s,  c, 0, 0,
+        0,  0, 1, 0,
+        0,  0, 0, 1
+    );
+}
+
+mat4 rotateXZ(float angle) {
+    float c = cos(angle);
+    float s = sin(angle);
+    return mat4(
+        c, 0, -s, 0,
+        0, 1,  0, 0,
+        s, 0,  c, 0,
+        0, 0,  0, 1
+    );
+}
+
+mat4 rotateYZ(float angle) {
+    float c = cos(angle);
+    float s = sin(angle);
+    return mat4(
+        1, 0,  0, 0,
+        0, c, -s, 0,
+        0, s,  c, 0,
+        0, 0,  0, 1
+    );
+}
+
+mat4 rotateXW(float angle) {
+    float c = cos(angle);
+    float s = sin(angle);
+    return mat4(
+        c, 0, 0, -s,
+        0, 1, 0,  0,
+        0, 0, 1,  0,
+        s, 0, 0,  c
+    );
+}
+
+mat4 rotateYW(float angle) {
+    float c = cos(angle);
+    float s = sin(angle);
+    return mat4(
+        1, 0, 0,  0,
+        0, c, 0, -s,
+        0, 0, 1,  0,
+        0, s, 0,  c
+    );
+}
+
+mat4 rotateZW(float angle) {
+    float c = cos(angle);
+    float s = sin(angle);
+    return mat4(
+        1, 0, 0,  0,
+        0, 1, 0,  0,
+        0, 0, c, -s,
+        0, 0, s,  c
+    );
+}
+
+// Apply all 6 rotations in canonical order: XY -> XZ -> YZ -> XW -> YW -> ZW
+vec4 apply6DRotation(vec4 pos) {
+    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;
+    return pos;
+}
+
+// 4D -> 3D perspective projection
+vec3 project4Dto3D(vec4 p) {
+    float w = u_dimension / (u_dimension + p.w);
+    return vec3(p.x * w, p.y * w, p.z * w);
+}

package/src/shaders/common/rotation4d.wgsl

@@ -0,0 +1,86 @@
+// VIB3+ 6D Rotation Functions (WGSL)
+// 3D space: XY, XZ, YZ | 4D hyperspace: XW, YW, ZW
+
+fn rotateXY(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle);
+    let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(c, -s, 0.0, 0.0),
+        vec4<f32>(s,  c, 0.0, 0.0),
+        vec4<f32>(0.0, 0.0, 1.0, 0.0),
+        vec4<f32>(0.0, 0.0, 0.0, 1.0)
+    );
+}
+
+fn rotateXZ(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle);
+    let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(c, 0.0, -s, 0.0),
+        vec4<f32>(0.0, 1.0, 0.0, 0.0),
+        vec4<f32>(s, 0.0,  c, 0.0),
+        vec4<f32>(0.0, 0.0, 0.0, 1.0)
+    );
+}
+
+fn rotateYZ(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle);
+    let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(1.0, 0.0, 0.0, 0.0),
+        vec4<f32>(0.0, c, -s, 0.0),
+        vec4<f32>(0.0, s,  c, 0.0),
+        vec4<f32>(0.0, 0.0, 0.0, 1.0)
+    );
+}
+
+fn rotateXW(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle);
+    let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(c, 0.0, 0.0, -s),
+        vec4<f32>(0.0, 1.0, 0.0, 0.0),
+        vec4<f32>(0.0, 0.0, 1.0, 0.0),
+        vec4<f32>(s, 0.0, 0.0,  c)
+    );
+}
+
+fn rotateYW(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle);
+    let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(1.0, 0.0, 0.0, 0.0),
+        vec4<f32>(0.0, c, 0.0, -s),
+        vec4<f32>(0.0, 0.0, 1.0, 0.0),
+        vec4<f32>(0.0, s, 0.0,  c)
+    );
+}
+
+fn rotateZW(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle);
+    let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(1.0, 0.0, 0.0, 0.0),
+        vec4<f32>(0.0, 1.0, 0.0, 0.0),
+        vec4<f32>(0.0, 0.0, c, -s),
+        vec4<f32>(0.0, 0.0, s,  c)
+    );
+}
+
+// Apply all 6 rotations in canonical order: XY -> XZ -> YZ -> XW -> YW -> ZW
+fn apply6DRotation(pos: vec4<f32>) -> vec4<f32> {
+    var p = pos;
+    p = rotateXY(u.rot4dXY) * p;
+    p = rotateXZ(u.rot4dXZ) * p;
+    p = rotateYZ(u.rot4dYZ) * p;
+    p = rotateXW(u.rot4dXW) * p;
+    p = rotateYW(u.rot4dYW) * p;
+    p = rotateZW(u.rot4dZW) * p;
+    return p;
+}
+
+// 4D -> 3D perspective projection
+fn project4Dto3D(p: vec4<f32>) -> vec3<f32> {
+    let w = u.dimension / (u.dimension + p.w);
+    return vec3<f32>(p.x * w, p.y * w, p.z * w);
+}

package/src/shaders/common/uniforms.glsl

@@ -0,0 +1,44 @@
+// VIB3+ Common Uniform Declarations (GLSL)
+// Shared across all visualization systems
+
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+    precision highp float;
+#else
+    precision mediump float;
+#endif
+
+uniform float u_time;
+uniform vec2 u_resolution;
+uniform float u_geometry;
+
+// 6D Rotation (radians)
+uniform float u_rot4dXY;
+uniform float u_rot4dXZ;
+uniform float u_rot4dYZ;
+uniform float u_rot4dXW;
+uniform float u_rot4dYW;
+uniform float u_rot4dZW;
+
+// Visual parameters
+uniform float u_dimension;
+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;
+
+// Reactivity
+uniform float u_mouseIntensity;
+uniform float u_clickIntensity;
+uniform float u_bass;
+uniform float u_mid;
+uniform float u_high;
+
+// Layer parameters (holographic multi-layer)
+uniform float u_layerScale;
+uniform float u_layerOpacity;
+uniform vec3 u_layerColor;
+uniform float u_densityMult;
+uniform float u_speedMult;

package/src/shaders/common/uniforms.wgsl

@@ -0,0 +1,48 @@
+// VIB3+ Common Uniform Struct (WGSL)
+// Shared across all visualization systems
+
+struct VIB3Uniforms {
+    // Time and resolution
+    time: f32,
+    _pad0: f32,
+    resolution: vec2<f32>,
+
+    // Geometry selection (0-23)
+    geometry: f32,
+
+    // 6D Rotation (radians)
+    rot4dXY: f32,
+    rot4dXZ: f32,
+    rot4dYZ: f32,
+    rot4dXW: f32,
+    rot4dYW: f32,
+    rot4dZW: f32,
+
+    // Visual parameters
+    dimension: f32,
+    gridDensity: f32,
+    morphFactor: f32,
+    chaos: f32,
+    speed: f32,
+    hue: f32,
+    intensity: f32,
+    saturation: f32,
+
+    // Reactivity
+    mouseIntensity: f32,
+    clickIntensity: f32,
+    bass: f32,
+    mid: f32,
+    high: f32,
+
+    // Layer parameters (holographic multi-layer)
+    layerScale: f32,
+    layerOpacity: f32,
+    _pad1: f32,
+    layerColor: vec3<f32>,
+    densityMult: f32,
+    speedMult: f32,
+    _pad2: vec3<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u: VIB3Uniforms;

package/src/shaders/faceted/faceted.frag.glsl

@@ -0,0 +1,129 @@
+// VIB3+ Faceted System Fragment Shader (GLSL)
+// Clean 2D geometric patterns with 4D rotation projection
+// 24 geometry variants: 8 base + 8 Hypersphere Core + 8 Hypertetrahedron Core
+precision highp float;
+
+uniform float u_time;
+uniform vec2 u_resolution;
+uniform float u_geometry;  // 0-23
+
+// 6D Rotation uniforms
+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_dimension;
+uniform float u_gridDensity;
+uniform float u_morphFactor;
+uniform float u_chaos;
+uniform float u_hue;
+uniform float u_intensity;
+
+// ========== 6D Rotation ==========
+mat4 rotateXY(float angle) {
+    float c = cos(angle), s = sin(angle);
+    return mat4(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+}
+mat4 rotateXZ(float angle) {
+    float c = cos(angle), s = sin(angle);
+    return mat4(c, 0, -s, 0, 0, 1, 0, 0, s, 0, c, 0, 0, 0, 0, 1);
+}
+mat4 rotateYZ(float angle) {
+    float c = cos(angle), s = sin(angle);
+    return mat4(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1);
+}
+mat4 rotateXW(float angle) {
+    float c = cos(angle), s = sin(angle);
+    return mat4(c, 0, 0, -s, 0, 1, 0, 0, 0, 0, 1, 0, s, 0, 0, c);
+}
+mat4 rotateYW(float angle) {
+    float c = cos(angle), s = sin(angle);
+    return mat4(1, 0, 0, 0, 0, c, 0, -s, 0, 0, 1, 0, 0, s, 0, c);
+}
+mat4 rotateZW(float angle) {
+    float c = cos(angle), s = sin(angle);
+    return mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, c, -s, 0, 0, s, c);
+}
+
+vec4 apply6DRotation(vec4 pos) {
+    pos = rotateXY(u_rot4dXY + u_time * 0.05) * pos;
+    pos = rotateXZ(u_rot4dXZ + u_time * 0.06) * pos;
+    pos = rotateYZ(u_rot4dYZ + u_time * 0.04) * pos;
+    pos = rotateXW(u_rot4dXW + u_time * 0.07) * pos;
+    pos = rotateYW(u_rot4dYW + u_time * 0.08) * pos;
+    pos = rotateZW(u_rot4dZW + u_time * 0.09) * pos;
+    return pos;
+}
+
+// ========== 24 Geometry SDFs ==========
+float baseGeometry(vec4 p, float type) {
+    if (type < 0.5) {
+        return max(max(max(abs(p.x + p.y) - p.z, abs(p.x - p.y) - p.z),
+                           abs(p.x + p.y) + p.z), abs(p.x - p.y) + p.z) / sqrt(3.0);
+    } else if (type < 1.5) {
+        vec4 q = abs(p) - 0.8;
+        return length(max(q, 0.0)) + min(max(max(max(q.x, q.y), q.z), q.w), 0.0);
+    } else if (type < 2.5) {
+        return length(p) - 1.0;
+    } else if (type < 3.5) {
+        vec2 t = vec2(length(p.xy) - 0.8, p.z);
+        return length(t) - 0.3;
+    } else if (type < 4.5) {
+        float r = length(p.xy);
+        return abs(r - 0.7) - 0.2 + sin(atan(p.y, p.x) * 3.0 + p.z * 5.0) * 0.1;
+    } else if (type < 5.5) {
+        return length(p) - 0.8 + sin(p.x * 5.0) * sin(p.y * 5.0) * sin(p.z * 5.0) * 0.2;
+    } else if (type < 6.5) {
+        return abs(p.z - sin(p.x * 5.0 + u_time) * cos(p.y * 5.0 + u_time) * 0.3) - 0.1;
+    } else {
+        vec4 q = abs(p);
+        return max(max(max(q.x, q.y), q.z), q.w) - 0.8;
+    }
+}
+
+float hypersphereCore(vec4 p, float baseType) {
+    return max(baseGeometry(p, baseType), length(p) - 1.2);
+}
+
+float hypertetrahedronCore(vec4 p, float baseType) {
+    float tetraField = max(max(max(
+        abs(p.x + p.y) - p.z - p.w,
+        abs(p.x - p.y) - p.z + p.w),
+        abs(p.x + p.y) + p.z - p.w),
+        abs(p.x - p.y) + p.z + p.w) / sqrt(4.0);
+    return max(baseGeometry(p, baseType), tetraField);
+}
+
+float geometry(vec4 p, float type) {
+    if (type < 8.0) { return baseGeometry(p, type); }
+    else if (type < 16.0) { return hypersphereCore(p, type - 8.0); }
+    else { return hypertetrahedronCore(p, type - 16.0); }
+}
+
+// ========== Main Fragment ==========
+void main() {
+    vec2 uv = (gl_FragCoord.xy - 0.5 * u_resolution.xy) / min(u_resolution.x, u_resolution.y);
+    uv *= 2.0 / u_gridDensity;
+
+    vec4 pos = vec4(uv, sin(u_time * 0.3) * 0.5, cos(u_time * 0.2) * 0.5);
+    pos = apply6DRotation(pos);
+    pos *= u_morphFactor;
+    pos += vec4(sin(u_time * 0.1), cos(u_time * 0.15), sin(u_time * 0.12), cos(u_time * 0.18)) * u_chaos;
+
+    float dist = geometry(pos, u_geometry);
+    float edge = smoothstep(0.02, 0.0, abs(dist));
+    float fill = smoothstep(0.1, 0.0, dist) * 0.3;
+
+    float hueVal = u_hue / 360.0 + dist * 0.2 + u_time * 0.05;
+    vec3 color = vec3(
+        0.5 + 0.5 * cos(hueVal * 6.28),
+        0.5 + 0.5 * cos((hueVal + 0.33) * 6.28),
+        0.5 + 0.5 * cos((hueVal + 0.67) * 6.28)
+    );
+
+    float alpha = (edge + fill) * u_intensity;
+    gl_FragColor = vec4(color * alpha, alpha);
+}

package/src/shaders/faceted/faceted.frag.wgsl

@@ -0,0 +1,164 @@
+// VIB3+ Faceted System Fragment Shader (WGSL)
+// Clean 2D geometric patterns with 4D rotation projection
+// 24 geometry variants: 8 base + 8 Hypersphere Core + 8 Hypertetrahedron Core
+
+struct VIB3Uniforms {
+    time: f32,
+    _pad0: f32,
+    resolution: vec2<f32>,
+    geometry: f32,
+    rot4dXY: f32,
+    rot4dXZ: f32,
+    rot4dYZ: f32,
+    rot4dXW: f32,
+    rot4dYW: f32,
+    rot4dZW: f32,
+    dimension: f32,
+    gridDensity: f32,
+    morphFactor: f32,
+    chaos: f32,
+    speed: f32,
+    hue: f32,
+    intensity: f32,
+    saturation: f32,
+    mouseIntensity: f32,
+    clickIntensity: f32,
+    bass: f32,
+    mid: f32,
+    high: f32,
+    layerScale: f32,
+    layerOpacity: f32,
+    _pad1: f32,
+    layerColor: vec3<f32>,
+    densityMult: f32,
+    speedMult: f32,
+    _pad2: vec3<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u: VIB3Uniforms;
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+};
+
+// ========== 6D Rotation ==========
+fn rotateXY(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle); let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(c, -s, 0.0, 0.0), vec4<f32>(s, c, 0.0, 0.0),
+        vec4<f32>(0.0, 0.0, 1.0, 0.0), vec4<f32>(0.0, 0.0, 0.0, 1.0));
+}
+fn rotateXZ(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle); let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(c, 0.0, -s, 0.0), vec4<f32>(0.0, 1.0, 0.0, 0.0),
+        vec4<f32>(s, 0.0, c, 0.0), vec4<f32>(0.0, 0.0, 0.0, 1.0));
+}
+fn rotateYZ(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle); let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(1.0, 0.0, 0.0, 0.0), vec4<f32>(0.0, c, -s, 0.0),
+        vec4<f32>(0.0, s, c, 0.0), vec4<f32>(0.0, 0.0, 0.0, 1.0));
+}
+fn rotateXW(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle); let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(c, 0.0, 0.0, -s), vec4<f32>(0.0, 1.0, 0.0, 0.0),
+        vec4<f32>(0.0, 0.0, 1.0, 0.0), vec4<f32>(s, 0.0, 0.0, c));
+}
+fn rotateYW(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle); let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(1.0, 0.0, 0.0, 0.0), vec4<f32>(0.0, c, 0.0, -s),
+        vec4<f32>(0.0, 0.0, 1.0, 0.0), vec4<f32>(0.0, s, 0.0, c));
+}
+fn rotateZW(angle: f32) -> mat4x4<f32> {
+    let c = cos(angle); let s = sin(angle);
+    return mat4x4<f32>(
+        vec4<f32>(1.0, 0.0, 0.0, 0.0), vec4<f32>(0.0, 1.0, 0.0, 0.0),
+        vec4<f32>(0.0, 0.0, c, -s), vec4<f32>(0.0, 0.0, s, c));
+}
+
+fn apply6DRot(pos: vec4<f32>) -> vec4<f32> {
+    var p = pos;
+    p = rotateXY(u.rot4dXY + u.time * 0.05) * p;
+    p = rotateXZ(u.rot4dXZ + u.time * 0.06) * p;
+    p = rotateYZ(u.rot4dYZ + u.time * 0.04) * p;
+    p = rotateXW(u.rot4dXW + u.time * 0.07) * p;
+    p = rotateYW(u.rot4dYW + u.time * 0.08) * p;
+    p = rotateZW(u.rot4dZW + u.time * 0.09) * p;
+    return p;
+}
+
+// ========== 24 Geometry SDFs ==========
+fn baseGeom(p: vec4<f32>, t: f32) -> f32 {
+    if (t < 0.5) {
+        return max(max(max(abs(p.x + p.y) - p.z, abs(p.x - p.y) - p.z),
+                       abs(p.x + p.y) + p.z), abs(p.x - p.y) + p.z) / sqrt(3.0);
+    } else if (t < 1.5) {
+        let q = abs(p) - vec4<f32>(0.8);
+        return length(max(q, vec4<f32>(0.0))) + min(max(max(max(q.x, q.y), q.z), q.w), 0.0);
+    } else if (t < 2.5) {
+        return length(p) - 1.0;
+    } else if (t < 3.5) {
+        let t2 = vec2<f32>(length(p.xy) - 0.8, p.z);
+        return length(t2) - 0.3;
+    } else if (t < 4.5) {
+        let r = length(p.xy);
+        return abs(r - 0.7) - 0.2 + sin(atan2(p.y, p.x) * 3.0 + p.z * 5.0) * 0.1;
+    } else if (t < 5.5) {
+        return length(p) - 0.8 + sin(p.x * 5.0) * sin(p.y * 5.0) * sin(p.z * 5.0) * 0.2;
+    } else if (t < 6.5) {
+        return abs(p.z - sin(p.x * 5.0 + u.time) * cos(p.y * 5.0 + u.time) * 0.3) - 0.1;
+    } else {
+        let q = abs(p);
+        return max(max(max(q.x, q.y), q.z), q.w) - 0.8;
+    }
+}
+
+fn hypersphereCore(p: vec4<f32>, bt: f32) -> f32 {
+    return max(baseGeom(p, bt), length(p) - 1.2);
+}
+
+fn hypertetraCore(p: vec4<f32>, bt: f32) -> f32 {
+    let tf = max(max(max(
+        abs(p.x + p.y) - p.z - p.w,
+        abs(p.x - p.y) - p.z + p.w),
+        abs(p.x + p.y) + p.z - p.w),
+        abs(p.x - p.y) + p.z + p.w) / sqrt(4.0);
+    return max(baseGeom(p, bt), tf);
+}
+
+fn geom(p: vec4<f32>, t: f32) -> f32 {
+    if (t < 8.0) { return baseGeom(p, t); }
+    else if (t < 16.0) { return hypersphereCore(p, t - 8.0); }
+    else { return hypertetraCore(p, t - 16.0); }
+}
+
+// ========== Main Fragment ==========
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let fragCoord = input.position.xy;
+    var uv2 = (fragCoord - 0.5 * u.resolution) / min(u.resolution.x, u.resolution.y);
+    uv2 *= 2.0 / u.gridDensity;
+
+    var pos = vec4<f32>(uv2, sin(u.time * 0.3) * 0.5, cos(u.time * 0.2) * 0.5);
+    pos = apply6DRot(pos);
+    pos *= u.morphFactor;
+    pos += vec4<f32>(sin(u.time * 0.1), cos(u.time * 0.15), sin(u.time * 0.12), cos(u.time * 0.18)) * u.chaos;
+
+    let dist = geom(pos, u.geometry);
+    let edge = smoothstep(0.02, 0.0, abs(dist));
+    let fill = smoothstep(0.1, 0.0, dist) * 0.3;
+
+    let hueVal = u.hue / 360.0 + dist * 0.2 + u.time * 0.05;
+    let color = vec3<f32>(
+        0.5 + 0.5 * cos(hueVal * 6.28),
+        0.5 + 0.5 * cos((hueVal + 0.33) * 6.28),
+        0.5 + 0.5 * cos((hueVal + 0.67) * 6.28)
+    );
+
+    let alpha = (edge + fill) * u.intensity;
+    return vec4<f32>(color * alpha, alpha);
+}