@vib3code/sdk 2.0.1 → 2.0.3-canary.91a95f3

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

@@ -1,11 +1,13 @@
 // 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
+uniform vec2 u_mouse;
+uniform float u_geometry;      // 0-23
 
 // 6D Rotation uniforms
 uniform float u_rot4dXY;
@@ -19,111 +21,249 @@ 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;
+uniform float u_mouseIntensity;
+uniform float u_clickIntensity;
+uniform float u_roleIntensity;
+uniform float u_bass;
+uniform float u_mid;
+uniform float u_high;
+uniform float u_breath; // Vitality System exhale (0.0 - 1.0)
+
+// ── 6D Rotation Matrices ──
 
-// ========== 6D Rotation ==========
-mat4 rotateXY(float angle) {
-    float c = cos(angle), s = sin(angle);
+mat4 rotateXY(float theta) {
+    float c = cos(theta); float s = sin(theta);
     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 rotateXZ(float theta) {
+    float c = cos(theta); float s = sin(theta);
+    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);
+mat4 rotateYZ(float theta) {
+    float c = cos(theta); float s = sin(theta);
     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);
+mat4 rotateXW(float theta) {
+    float c = cos(theta); float s = sin(theta);
     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);
+mat4 rotateYW(float theta) {
+    float c = cos(theta); float s = sin(theta);
     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);
+mat4 rotateZW(float theta) {
+    float c = cos(theta); float s = sin(theta);
     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;
+// ── 4D → 3D Projection ──
+
+vec3 project4Dto3D(vec4 p) {
+    float w = 2.5 / (2.5 + p.w);
+    return vec3(p.x * w, p.y * w, p.z * w);
 }
 
-// ========== 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;
-    }
+// ── 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));
 }
 
-float hypersphereCore(vec4 p, float baseType) {
-    return max(baseGeometry(p, baseType), length(p) - 1.2);
+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);
 }
 
-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);
+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));
+    // WebGL 1.0 compatible modulus
+    float baseGeomFloat = geometryType - floor(geometryType / totalBase) * 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;
 }
 
-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); }
+// ── 8 Lattice Geometry Functions ──
+
+float geometryFunction(vec4 p) {
+    float totalBase = 8.0;
+    // WebGL 1.0 compatible modulus
+    float baseGeomFloat = u_geometry - floor(u_geometry / totalBase) * totalBase;
+    int geomType = int(clamp(floor(baseGeomFloat + 0.5), 0.0, totalBase - 1.0));
+
+    if (geomType == 0) {
+        // Tetrahedron lattice
+        vec4 pos = fract(p * u_gridDensity * 0.08);
+        vec4 dist = min(pos, 1.0 - pos);
+        return min(min(dist.x, dist.y), min(dist.z, dist.w)) * u_morphFactor;
+    }
+    else if (geomType == 1) {
+        // Hypercube lattice
+        vec4 pos = fract(p * u_gridDensity * 0.08);
+        vec4 dist = min(pos, 1.0 - pos);
+        float minDist = min(min(dist.x, dist.y), min(dist.z, dist.w));
+        return minDist * u_morphFactor;
+    }
+    else if (geomType == 2) {
+        // Sphere lattice
+        float r = length(p);
+        float density = u_gridDensity * 0.08;
+        float spheres = abs(fract(r * density) - 0.5) * 2.0;
+        float theta = atan(p.y, p.x);
+        float harmonics = sin(theta * 3.0) * 0.2;
+        return (spheres + harmonics) * u_morphFactor;
+    }
+    else if (geomType == 3) {
+        // Torus lattice
+        float r1 = length(p.xy) - 2.0;
+        float torus = length(vec2(r1, p.z)) - 0.8;
+        float lattice = sin(p.x * u_gridDensity * 0.08) * sin(p.y * u_gridDensity * 0.08);
+        return (torus + lattice * 0.3) * u_morphFactor;
+    }
+    else if (geomType == 4) {
+        // Klein bottle lattice
+        float u_ang = atan(p.y, p.x);
+        float v_ang = atan(p.w, p.z);
+        float dist = length(p) - 2.0;
+        float lattice = sin(u_ang * u_gridDensity * 0.08) * sin(v_ang * u_gridDensity * 0.08);
+        return (dist + lattice * 0.4) * u_morphFactor;
+    }
+    else if (geomType == 5) {
+        // Fractal lattice
+        vec4 pos = fract(p * u_gridDensity * 0.08);
+        pos = abs(pos * 2.0 - 1.0);
+        float dist = length(max(abs(pos) - 1.0, 0.0));
+        return dist * u_morphFactor;
+    }
+    else if (geomType == 6) {
+        // Wave lattice
+        float freq = u_gridDensity * 0.08;
+        float time = u_time * 0.001 * u_speed;
+        float wave1 = sin(p.x * freq + time);
+        float wave2 = sin(p.y * freq + time * 1.3);
+        float wave3 = sin(p.z * freq * 0.8 + time * 0.7);
+        float interference = wave1 * wave2 * wave3;
+        return interference * u_morphFactor;
+    }
+    else if (geomType == 7) {
+        // Crystal lattice
+        vec4 pos = fract(p * u_gridDensity * 0.08) - 0.5;
+        float cube = max(max(abs(pos.x), abs(pos.y)), max(abs(pos.z), abs(pos.w)));
+        return cube * u_morphFactor;
+    }
+    else {
+        // Default hypercube
+        vec4 pos = fract(p * u_gridDensity * 0.08);
+        vec4 dist = min(pos, 1.0 - pos);
+        return min(min(dist.x, dist.y), min(dist.z, dist.w)) * u_morphFactor;
+    }
 }
 
-// ========== Main Fragment ==========
+// ── Main ──
+
 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)
+    vec2 uv = (gl_FragCoord.xy - u_resolution.xy * 0.5) / min(u_resolution.x, u_resolution.y);
+    float timeSpeed = u_time * 0.0001 * u_speed;
+
+    // Create 4D point
+    vec4 pos = vec4(uv * 3.0, sin(timeSpeed * 3.0), cos(timeSpeed * 2.0));
+
+    // Mouse influence
+    pos.xy += (u_mouse - 0.5) * u_mouseIntensity * 2.0;
+
+    // Audio-reactive density and morph
+    float audioDensityMod = 1.0 + u_bass * 0.3;
+    float audioMorphMod = 1.0 + u_mid * 0.2;
+
+    // Apply full 6D rotation
+    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;
+
+    // 4D → 3D projection
+    vec3 basePoint = project4Dto3D(pos);
+
+    // Apply polytope core warp (types 8-23)
+    vec3 warpedPoint = applyCoreWarp(basePoint, u_geometry, u_mouse - 0.5);
+
+    // Evaluate lattice geometry
+    vec4 warpedPos = vec4(warpedPoint, pos.w);
+    float value = geometryFunction(warpedPos);
+
+    // Chaos noise
+    float noise = sin(pos.x * 7.0) * cos(pos.y * 11.0) * sin(pos.z * 13.0);
+    value += noise * u_chaos;
+
+    // Intensity from lattice
+    float geometryIntensity = 1.0 - clamp(abs(value), 0.0, 1.0);
+    geometryIntensity += u_clickIntensity * 0.3;
+    float finalIntensity = geometryIntensity * u_intensity;
+
+    // Audio-reactive hue shift
+    float hue = u_hue / 360.0 + value * 0.1 + u_high * 0.08;
+
+    // Color via sin-wave HSL
+    vec3 baseColor = vec3(
+        sin(hue * 6.28318 + 0.0) * 0.5 + 0.5,
+        sin(hue * 6.28318 + 2.0943) * 0.5 + 0.5,
+        sin(hue * 6.28318 + 4.1887) * 0.5 + 0.5
     );
 
-    float alpha = (edge + fill) * u_intensity;
-    gl_FragColor = vec4(color * alpha, alpha);
+    // Saturation control (mix to gray)
+    float gray = (baseColor.r + baseColor.g + baseColor.b) / 3.0;
+    vec3 color = mix(vec3(gray), baseColor, u_saturation) * finalIntensity;
+
+    gl_FragColor = vec4(color, finalIntensity);
 }

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

@@ -4,7 +4,7 @@
 
 struct VIB3Uniforms {
     time: f32,
-    _pad0: f32,
+    speed: f32,
     resolution: vec2<f32>,
     geometry: f32,
     rot4dXY: f32,
@@ -17,148 +17,189 @@ struct VIB3Uniforms {
     gridDensity: f32,
     morphFactor: f32,
     chaos: f32,
-    speed: f32,
     hue: f32,
     intensity: f32,
     saturation: f32,
     mouseIntensity: f32,
     clickIntensity: f32,
+    roleIntensity: f32,
     bass: f32,
     mid: f32,
     high: f32,
-    layerScale: f32,
-    layerOpacity: f32,
-    _pad1: f32,
-    layerColor: vec3<f32>,
-    densityMult: f32,
-    speedMult: f32,
-    _pad2: vec3<f32>,
+    breath: f32,
+    mouse: vec2<f32>,
+    _pad1: vec2<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);
+fn rotateXY_w(theta: f32) -> mat4x4<f32> {
+    let c = cos(theta); let s = sin(theta);
     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);
+fn rotateXZ_w(theta: f32) -> mat4x4<f32> {
+    let c = cos(theta); let s = sin(theta);
     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));
+        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);
+fn rotateYZ_w(theta: f32) -> mat4x4<f32> {
+    let c = cos(theta); let s = sin(theta);
     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);
+fn rotateXW_w(theta: f32) -> mat4x4<f32> {
+    let c = cos(theta); let s = sin(theta);
     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);
+fn rotateYW_w(theta: f32) -> mat4x4<f32> {
+    let c = cos(theta); let s = sin(theta);
     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);
+fn rotateZW_w(theta: f32) -> mat4x4<f32> {
+    let c = cos(theta); let s = sin(theta);
     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;
+fn project4Dto3D_w(p: vec4<f32>) -> vec3<f32> {
+    let w = 2.5 / (2.5 + p.w);
+    return vec3<f32>(p.x * w, p.y * w, p.z * w);
 }
 
-// ========== 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 warpHypersphereCore_w(p: vec3<f32>, geomIdx: i32) -> vec3<f32> {
+    let radius = length(p);
+    let morphBlend = clamp(u.morphFactor * 0.6 + (u.dimension - 3.0) * 0.25, 0.0, 2.0);
+    let w = sin(radius * (1.3 + f32(geomIdx) * 0.12) + u.time * 0.0008 * u.speed)
+          * (0.4 + morphBlend * 0.45);
+    var p4d = vec4<f32>(p * (1.0 + morphBlend * 0.2), w);
+    p4d = rotateXY_w(u.rot4dXY) * p4d;
+    p4d = rotateXZ_w(u.rot4dXZ) * p4d;
+    p4d = rotateYZ_w(u.rot4dYZ) * p4d;
+    p4d = rotateXW_w(u.rot4dXW) * p4d;
+    p4d = rotateYW_w(u.rot4dYW) * p4d;
+    p4d = rotateZW_w(u.rot4dZW) * p4d;
+    let proj = project4Dto3D_w(p4d);
+    return mix(p, proj, clamp(0.45 + morphBlend * 0.35, 0.0, 1.0));
 }
 
-fn hypersphereCore(p: vec4<f32>, bt: f32) -> f32 {
-    return max(baseGeom(p, bt), length(p) - 1.2);
+fn warpHypertetraCore_w(p: vec3<f32>, geomIdx: i32) -> vec3<f32> {
+    let c1 = normalize(vec3<f32>(1.0, 1.0, 1.0));
+    let c2 = normalize(vec3<f32>(-1.0, -1.0, 1.0));
+    let c3 = normalize(vec3<f32>(-1.0, 1.0, -1.0));
+    let c4 = normalize(vec3<f32>(1.0, -1.0, -1.0));
+    let morphBlend = clamp(u.morphFactor * 0.8 + (u.dimension - 3.0) * 0.2, 0.0, 2.0);
+    let basisMix = dot(p, c1) * 0.14 + dot(p, c2) * 0.1 + dot(p, c3) * 0.08;
+    let w = sin(basisMix * 5.5 + u.time * 0.0009 * u.speed)
+          * cos(dot(p, c4) * 4.2 - u.time * 0.0007 * u.speed)
+          * (0.5 + morphBlend * 0.4);
+    let offset = vec3<f32>(dot(p, c1), dot(p, c2), dot(p, c3)) * 0.1 * morphBlend;
+    var p4d = vec4<f32>(p + offset, w);
+    p4d = rotateXY_w(u.rot4dXY) * p4d;
+    p4d = rotateXZ_w(u.rot4dXZ) * p4d;
+    p4d = rotateYZ_w(u.rot4dYZ) * p4d;
+    p4d = rotateXW_w(u.rot4dXW) * p4d;
+    p4d = rotateYW_w(u.rot4dYW) * p4d;
+    p4d = rotateZW_w(u.rot4dZW) * p4d;
+    let proj = project4Dto3D_w(p4d);
+    let planeInf = min(min(abs(dot(p, c1)), abs(dot(p, c2))),
+                       min(abs(dot(p, c3)), abs(dot(p, c4))));
+    let blended = mix(p, proj, clamp(0.45 + morphBlend * 0.35, 0.0, 1.0));
+    return mix(blended, blended * (1.0 - planeInf * 0.55), 0.2 + morphBlend * 0.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 applyCoreWarp_w(p: vec3<f32>, geomType: f32, mouseDelta: vec2<f32>) -> vec3<f32> {
+    let coreFloat = floor(geomType / 8.0);
+    let coreIndex = i32(clamp(coreFloat, 0.0, 2.0));
+    let baseFloat = geomType - floor(geomType / 8.0) * 8.0;
+    let geomIdx = i32(clamp(floor(baseFloat + 0.5), 0.0, 7.0));
+    if (coreIndex == 1) { return warpHypersphereCore_w(p, geomIdx); }
+    if (coreIndex == 2) { return warpHypertetraCore_w(p, geomIdx); }
+    return p;
 }
 
-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); }
+fn geometryFunction_w(p: vec4<f32>) -> f32 {
+    let baseFloat = u.geometry - floor(u.geometry / 8.0) * 8.0;
+    let gt = i32(clamp(floor(baseFloat + 0.5), 0.0, 7.0));
+    let d = u.gridDensity * 0.08;
+    if (gt == 0) {
+        let pos = fract(p * d); let dist = min(pos, 1.0 - pos);
+        return min(min(dist.x, dist.y), min(dist.z, dist.w)) * u.morphFactor;
+    } else if (gt == 1) {
+        let pos = fract(p * d); let dist = min(pos, 1.0 - pos);
+        return min(min(dist.x, dist.y), min(dist.z, dist.w)) * u.morphFactor;
+    } else if (gt == 2) {
+        let r = length(p); let sph = abs(fract(r * d) - 0.5) * 2.0;
+        let harm = sin(atan2(p.y, p.x) * 3.0) * 0.2;
+        return (sph + harm) * u.morphFactor;
+    } else if (gt == 3) {
+        let r1 = length(p.xy) - 2.0; let tor = length(vec2<f32>(r1, p.z)) - 0.8;
+        let lat = sin(p.x * d) * sin(p.y * d);
+        return (tor + lat * 0.3) * u.morphFactor;
+    } else if (gt == 4) {
+        let ua = atan2(p.y, p.x); let va = atan2(p.w, p.z);
+        let dist = length(p) - 2.0; let lat = sin(ua * d) * sin(va * d);
+        return (dist + lat * 0.4) * u.morphFactor;
+    } else if (gt == 5) {
+        var pos = fract(p * d); pos = abs(pos * 2.0 - 1.0);
+        return length(max(abs(pos) - 1.0, vec4<f32>(0.0))) * u.morphFactor;
+    } else if (gt == 6) {
+        let t = u.time * 0.001 * u.speed;
+        return sin(p.x * d + t) * sin(p.y * d + t * 1.3) * sin(p.z * d * 0.8 + t * 0.7) * u.morphFactor;
+    } else {
+        let pos = fract(p * d) - 0.5;
+        return max(max(abs(pos.x), abs(pos.y)), max(abs(pos.z), abs(pos.w))) * u.morphFactor;
+    }
 }
 
-// ========== Main Fragment ==========
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+};
+
 @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);
+    let uv2 = (fragCoord - u.resolution * 0.5) / min(u.resolution.x, u.resolution.y);
+    let timeSpeed = u.time * 0.0001 * u.speed;
+
+    var pos = vec4<f32>(uv2 * 3.0, sin(timeSpeed * 3.0), cos(timeSpeed * 2.0));
+    pos = vec4<f32>(pos.xy + (vec2<f32>(0.5, 0.5) - 0.5) * u.mouseIntensity * 2.0, pos.z, pos.w);
+
+    pos = rotateXY_w(u.rot4dXY) * pos;
+    pos = rotateXZ_w(u.rot4dXZ) * pos;
+    pos = rotateYZ_w(u.rot4dYZ) * pos;
+    pos = rotateXW_w(u.rot4dXW) * pos;
+    pos = rotateYW_w(u.rot4dYW) * pos;
+    pos = rotateZW_w(u.rot4dZW) * pos;
+
+    let basePoint = project4Dto3D_w(pos);
+    let warpedPoint = applyCoreWarp_w(basePoint, u.geometry, vec2<f32>(0.0, 0.0));
+    let warpedPos = vec4<f32>(warpedPoint, pos.w);
+    var value = geometryFunction_w(warpedPos);
+
+    let noise = sin(pos.x * 7.0) * cos(pos.y * 11.0) * sin(pos.z * 13.0);
+    value += noise * u.chaos;
+
+    var geomIntensity = 1.0 - clamp(abs(value), 0.0, 1.0);
+    geomIntensity += u.clickIntensity * 0.3;
+    let finalIntensity = geomIntensity * u.intensity;
+
+    let hueVal = u.hue / 360.0 + value * 0.1 + u.high * 0.08;
+    let baseColor = vec3<f32>(
+        sin(hueVal * 6.28318 + 0.0) * 0.5 + 0.5,
+        sin(hueVal * 6.28318 + 2.0943) * 0.5 + 0.5,
+        sin(hueVal * 6.28318 + 4.1887) * 0.5 + 0.5);
+    let gray = (baseColor.r + baseColor.g + baseColor.b) / 3.0;
+    let color = mix(vec3<f32>(gray), baseColor, u.saturation) * finalIntensity;
+
+    return vec4<f32>(color, finalIntensity);
 }