@vib3code/sdk 2.0.1 → 2.0.3-canary.0a63e71

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

@@ -29,136 +29,190 @@ struct VIB3Uniforms {
     layerScale: f32,
     layerOpacity: f32,
     _pad1: f32,
-    layerColor: vec3<f32>,
+    layerColorR: f32,
+    layerColorG: f32,
+    layerColorB: f32,
     densityMult: f32,
     speedMult: f32,
-    _pad2: vec3<f32>,
+    breath: 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) {
+        // Tetrahedron — tetrahedral symmetry planes
+        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 q = fract(p.xyz * d + 0.5) - 0.5;
+        let minPlane = min(min(abs(dot(q, c1)), abs(dot(q, c2))),
+                           min(abs(dot(q, c3)), abs(dot(q, c4))));
+        return (1.0 - smoothstep(0.0, 0.05, minPlane)) * 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);
 }

package/src/shaders/holographic/holographic.frag.glsl

@@ -9,7 +9,8 @@ uniform vec2 u_resolution;
 uniform float u_time;
 uniform vec2 u_mouse;
 uniform float u_geometry;
-uniform float u_density;
+uniform float u_density;        // Used by inline visualizer (scaled 0.3-2.5)
+uniform float u_gridDensity;    // Used by bridge/external (raw 5-100)
 uniform float u_speed;
 uniform vec3 u_color;
 uniform float u_intensity;
@@ -40,6 +41,9 @@ uniform float u_rot4dXW;
 uniform float u_rot4dYW;
 uniform float u_rot4dZW;
 
+// EXHALE FEATURE: Breathing uniform
+uniform float u_breath;
+
 // 6D rotation matrices - 3D space rotations (XY, XZ, YZ)
 mat4 rotateXY(float theta) {
     float c = cos(theta);
@@ -78,9 +82,12 @@ mat4 rotateZW(float theta) {
     return mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, c, -s, 0, 0, s, c);
 }
 
-// 4D to 3D projection
+// 4D to 3D projection - BREATHING EFFECT
 vec3 project4Dto3D(vec4 p) {
-    float w = 2.5 / (2.5 + p.w);
+    // Modulate projection distance with breath for "exhale" effect (expansion/contraction)
+    float baseDim = 2.5;
+    float dim = baseDim + u_breath * 0.5; // Expands on exhale
+    float w = dim / (dim + p.w);
     return vec3(p.x * w, p.y * w, p.z * w);
 }
 
@@ -227,10 +234,10 @@ float torusLattice(vec3 p, float gridSize) {
 
 float kleinLattice(vec3 p, float gridSize) {
     vec3 q = fract(p * gridSize);
-    float ku = q.x * 2.0 * 3.14159;
-    float kv = q.y * 2.0 * 3.14159;
-    float kx = cos(ku) * (3.0 + cos(ku/2.0) * sin(kv) - sin(ku/2.0) * sin(2.0*kv));
-    float klein = length(vec2(kx, q.z)) - 0.1;
+    float u = q.x * 2.0 * 3.14159;
+    float v = q.y * 2.0 * 3.14159;
+    float x = cos(u) * (3.0 + cos(u/2.0) * sin(v) - sin(u/2.0) * sin(2.0*v));
+    float klein = length(vec2(x, q.z)) - 0.1;
     return 1.0 - smoothstep(0.0, 0.05, abs(klein));
 }
 
@@ -345,8 +352,17 @@ void main() {
 
     float scrollDensityMod = 1.0 + u_gridDensityShift * 0.3;
     float audioDensityMod = 1.0 + u_audioDensityBoost * 0.5;
-    // Controlled density calculation
-    float baseDensity = u_density * u_roleDensity;
+
+    // SCALE FIX: Support raw gridDensity (5-100) or pre-scaled density (0.3-2.5)
+    float effectiveDensity = u_density;
+    if (u_gridDensity > 0.1) {
+        // Convert 5-100 to 0.3-2.5
+        effectiveDensity = 0.3 + (u_gridDensity - 5.0) / 95.0 * 2.2;
+    }
+
+    float breathDensityMod = 1.0 + u_breath * 0.1;
+    float baseDensity = effectiveDensity * u_roleDensity * breathDensityMod;
+
     float densityVariations = (u_densityVariation * 0.3 + (scrollDensityMod - 1.0) * 0.4 + (audioDensityMod - 1.0) * 0.2);
     float roleDensity = baseDensity + densityVariations;
 
@@ -357,6 +373,9 @@ void main() {
     vec3 baseColor = u_color;
     float latticeIntensity = lattice * u_intensity;
 
+    // Breathing glow effect
+    latticeIntensity *= (1.0 + u_breath * 0.2);
+
     // Multi-layer color composition for higher fidelity
     vec3 color = baseColor * (0.2 + latticeIntensity * 0.8);
 

package/src/shaders/holographic/holographic.frag.wgsl

@@ -1,6 +1,6 @@
 // VIB3+ Holographic System Fragment Shader (WGSL)
 // 5-layer glassmorphic audio-reactive effects
-// Port of the GLSL HolographicVisualizer shader
+// Port of the GLSL HolographicVisualizer shader with Exhale feature
 
 struct VIB3Uniforms {
     time: f32,
@@ -29,10 +29,12 @@ struct VIB3Uniforms {
     layerScale: f32,
     layerOpacity: f32,
     _pad1: f32,
-    layerColor: vec3<f32>,
+    layerColorR: f32,
+    layerColorG: f32,
+    layerColorB: f32,
     densityMult: f32,
     speedMult: f32,
-    _pad2: vec3<f32>,
+    breath: f32,
 };
 
 @group(0) @binding(0) var<uniform> u: VIB3Uniforms;
@@ -52,8 +54,8 @@ fn rotateXY(angle: f32) -> mat4x4<f32> {
 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));
+        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);
@@ -91,42 +93,91 @@ fn apply6DRot(pos: vec4<f32>) -> vec4<f32> {
     return p;
 }
 
-// ========== 24 Geometry SDFs ==========
-fn baseGeometry(p: vec4<f32>, t: f32) -> f32 {
-    if (t < 0.5) {
+// ========== 4D to 3D Projection (Breathing) ==========
+fn project4Dto3D_w(p: vec4<f32>) -> vec3<f32> {
+    // Modulate projection with breath
+    let baseDim = 2.5;
+    let dim = baseDim + u.breath * 0.5;
+    let w = dim / (dim + p.w);
+    return vec3<f32>(p.x * w, p.y * w, p.z * w);
+}
+
+// ========== Polytope Core Warp Functions ==========
+fn warpHypersphereCore_w(p: vec3<f32>, geomIdx: i32) -> vec3<f32> {
+    let radius = length(p);
+    let morphBlend = clamp(u.morphFactor * 0.6 + 0.3, 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 = apply6DRot(p4d); // Reuse rotation helper
+
+    let proj = project4Dto3D_w(p4d);
+    return mix(p, proj, clamp(0.45 + morphBlend * 0.35, 0.0, 1.0));
+}
+
+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 + 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 = apply6DRot(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 applyCoreWarp_w(p: vec3<f32>, geomType: f32) -> vec3<f32> {
+    let totalBase = 8.0;
+    let coreFloat = floor(geomType / totalBase);
+    let coreIndex = i32(clamp(coreFloat, 0.0, 2.0));
+    let baseFloat = geomType - floor(geomType / totalBase) * totalBase;
+    let geomIdx = i32(clamp(floor(baseFloat + 0.5), 0.0, totalBase - 1.0));
+
+    if (coreIndex == 1) { return warpHypersphereCore_w(p, geomIdx); }
+    if (coreIndex == 2) { return warpHypertetraCore_w(p, geomIdx); }
+    return p;
+}
+
+// ========== 24 Geometry SDFs (Base 8) ==========
+fn baseGeometry(p: vec3<f32>, t: f32) -> f32 {
+    let totalBase = 8.0;
+    let baseFloat = t - floor(t / totalBase) * totalBase;
+    // We use integer comparison here since WGSL doesn't like float switches
+    if (baseFloat < 0.5) { // 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) {
-        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) {
+    } else if (baseFloat < 1.5) { // Hypercube (projected)
+        let q = abs(p) - vec3<f32>(0.8);
+        return length(max(q, vec3<f32>(0.0))) + min(max(max(q.x, q.y), q.z), 0.0);
+    } else if (baseFloat < 2.5) { // Sphere
         return length(p) - 1.0;
-    } else if (t < 3.5) {
+    } else if (baseFloat < 3.5) { // Torus
         let t2 = vec2<f32>(length(p.xy) - 0.8, p.z);
         return length(t2) - 0.3;
-    } else if (t < 4.5) {
+    } else if (baseFloat < 4.5) { // Klein
         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) {
+    } else if (baseFloat < 5.5) { // Fractal
         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) {
+    } else if (baseFloat < 6.5) { // Wave
         return abs(p.z - sin(p.x * 5.0 + u.time) * cos(p.y * 5.0 + u.time) * 0.3) - 0.1;
-    } else {
+    } else { // Crystal
         let q = abs(p);
-        return max(max(max(q.x, q.y), q.z), q.w) - 0.8;
-    }
-}
-
-fn geom(p: vec4<f32>, t: f32) -> f32 {
-    if (t < 8.0) { return baseGeometry(p, t); }
-    else if (t < 16.0) { return max(baseGeometry(p, t - 8.0), length(p) - 1.2); }
-    else {
-        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, t - 16.0), tf);
+        return max(max(q.x, q.y), q.z) - 0.8;
     }
 }
 
@@ -161,25 +212,45 @@ fn main(input: VertexOutput) -> @location(0) vec4<f32> {
     let density = u.densityMult;
     let spd = u.speedMult;
 
-    // Create 4D point
-    var pos = vec4<f32>(uv * 2.0 * density, sin(u.time * 0.3 * spd) * 0.5, cos(u.time * 0.2 * spd) * 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;
+    // Create 4D point (simplified to 3D base + W)
+    // SCALE FIX: Apply gridDensity scaling if densityMult is weak?
+    // WGSL density logic usually relies on densityMult passed by bridge.
+    // But let's apply the same scaling logic just in case:
+    var effectiveDensity = density;
+    if (u.gridDensity > 0.1 && density < 0.5) {
+         effectiveDensity = 0.3 + (u.gridDensity - 5.0) / 95.0 * 2.2;
+    }
+
+    var pos4d = vec4<f32>(uv * 2.0 * effectiveDensity, sin(u.time * 0.3 * spd) * 0.5, cos(u.time * 0.2 * spd) * 0.5);
+
+    // Rotate
+    pos4d = apply6DRot(pos4d);
+
+    // Project to 3D (with breath)
+    let pos3d = project4Dto3D_w(pos4d);
+
+    // Warp (Polytope logic)
+    var warpedPos = applyCoreWarp_w(pos3d, u.geometry);
+
+    // Apply morph/chaos to warped point
+    warpedPos *= u.morphFactor;
+    warpedPos += vec3<f32>(sin(u.time * 0.1), cos(u.time * 0.15), sin(u.time * 0.12)) * u.chaos;
+
+    // Geometry evaluation on warped 3D point
+    let dist = baseGeometry(warpedPos, u.geometry);
 
-    // Geometry evaluation
-    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;
 
     // Color from HSL
-    // colorShift is baked into layerColor; use hue directly
     let hueVal = u.hue / 360.0;
     let sat = clamp(u.saturation, 0.0, 1.0);
     let lightness = clamp(u.intensity, 0.2, 0.8);
     let color = hslToRgb(hueVal, sat, lightness);
 
-    // Final alpha
-    let alpha = (edge + fill) * u.intensity * u.layerOpacity;
+    // Final alpha - modulate with breath
+    let breathAlpha = 1.0 + u.breath * 0.2;
+    let alpha = (edge + fill) * u.intensity * u.layerOpacity * breathAlpha;
+
     return vec4<f32>(color * alpha, alpha);
 }

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

@@ -30,6 +30,7 @@ uniform float u_rot4dZW;
 uniform float u_mouseIntensity;
 uniform float u_clickIntensity;
 uniform float u_roleIntensity;
+uniform float u_breath; // Vitality System exhale (0.0 - 1.0)
 
 // 6D rotation matrices - 3D space rotations (XY, XZ, YZ)
 mat4 rotateXY(float theta) {

package/src/shaders/quantum/quantum.frag.wgsl

@@ -29,10 +29,12 @@ struct VIB3Uniforms {
     layerScale: f32,
     layerOpacity: f32,
     _pad1: f32,
-    layerColor: vec3<f32>,
+    layerColorR: f32,
+    layerColorG: f32,
+    layerColorB: f32,
     densityMult: f32,
     speedMult: f32,
-    _pad2: vec3<f32>,
+    breath: f32,
 };
 
 @group(0) @binding(0) var<uniform> u: VIB3Uniforms;
@@ -52,8 +54,8 @@ fn rotateXY(angle: f32) -> mat4x4<f32> {
 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));
+        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);

package/src/testing/ParallelTestFramework.js

@@ -151,8 +151,8 @@ export class ParallelTestFramework {
         // Create system instance based on type
         switch (testSpec.system) {
             case 'faceted':
-                const { VIB34DIntegratedEngine } = await import('../core/Engine.js');
-                testSystem = new VIB34DIntegratedEngine();
+                const { VIB3Engine } = await import('../core/VIB3Engine.js');
+                testSystem = new VIB3Engine();
                 break;
             case 'quantum':
                 const { QuantumEngine } = await import('../quantum/QuantumEngine.js');

package/src/ui/adaptive/renderers/webgpu/WebGPURenderer.ts

@@ -546,9 +546,9 @@ 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>( 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>(-s, 0.0, c, 0.0),
         vec4<f32>(0.0, 0.0, 0.0, 1.0)
     );
 }

package/src/viewer/GalleryUI.js

@@ -749,6 +749,23 @@ export class GalleryUI extends EventEmitter {
         this.render();
     }
 
+    /**
+     * Handle search input
+     */
+    _onSearch(event) {
+        this.searchQuery = event.target.value;
+        this._applyFilters();
+        this.render();
+    }
+
+    /**
+     * Handle page change
+     */
+    _onPageChange(page) {
+        this.currentPage = page;
+        this.render();
+    }
+
     /**
      * Handle variation hover
      */