@vib3code/sdk 2.0.3-canary.60bc0f0 → 2.0.3-canary.74aebb4

package/src/holograms/HolographicVisualizer.js

@@ -132,28 +132,28 @@ export class HolographicVisualizer {
         const finalName = geometryName + suffixes[variationLevel];
         
         const geometryConfigs = {
-            0: { density: 0.8 + variationLevel * 0.2, speed: 0.3 + variationLevel * 0.1, chaos: variationLevel * 0.1, morph: 0.0 + variationLevel * 0.2 },
-            1: { density: 1.0 + variationLevel * 0.3, speed: 0.5 + variationLevel * 0.1, chaos: variationLevel * 0.15, morph: variationLevel * 0.2 },
-            2: { density: 1.2 + variationLevel * 0.4, speed: 0.4 + variationLevel * 0.2, chaos: 0.1 + variationLevel * 0.1, morph: 0.3 + variationLevel * 0.2 },
-            3: { density: 0.9 + variationLevel * 0.3, speed: 0.6 + variationLevel * 0.2, chaos: 0.2 + variationLevel * 0.2, morph: 0.5 + variationLevel * 0.1 },
-            4: { density: 1.4 + variationLevel * 0.5, speed: 0.7 + variationLevel * 0.1, chaos: 0.3 + variationLevel * 0.2, morph: 0.7 + variationLevel * 0.1 },
-            5: { density: 1.8 + variationLevel * 0.3, speed: 0.5 + variationLevel * 0.3, chaos: 0.5 + variationLevel * 0.2, morph: 0.8 + variationLevel * 0.05 },
-            6: { density: 0.6 + variationLevel * 0.4, speed: 0.8 + variationLevel * 0.4, chaos: 0.4 + variationLevel * 0.3, morph: 0.6 + variationLevel * 0.2 },
-            7: { density: 1.6 + variationLevel * 0.2, speed: 0.2 + variationLevel * 0.1, chaos: 0.1 + variationLevel * 0.1, morph: 0.2 + variationLevel * 0.2 }
+            0: { gridDensity: 0.8 + variationLevel * 0.2, speed: 0.3 + variationLevel * 0.1, chaos: variationLevel * 0.1, morphFactor: 0.0 + variationLevel * 0.2 },
+            1: { gridDensity: 1.0 + variationLevel * 0.3, speed: 0.5 + variationLevel * 0.1, chaos: variationLevel * 0.15, morphFactor: variationLevel * 0.2 },
+            2: { gridDensity: 1.2 + variationLevel * 0.4, speed: 0.4 + variationLevel * 0.2, chaos: 0.1 + variationLevel * 0.1, morphFactor: 0.3 + variationLevel * 0.2 },
+            3: { gridDensity: 0.9 + variationLevel * 0.3, speed: 0.6 + variationLevel * 0.2, chaos: 0.2 + variationLevel * 0.2, morphFactor: 0.5 + variationLevel * 0.1 },
+            4: { gridDensity: 1.4 + variationLevel * 0.5, speed: 0.7 + variationLevel * 0.1, chaos: 0.3 + variationLevel * 0.2, morphFactor: 0.7 + variationLevel * 0.1 },
+            5: { gridDensity: 1.8 + variationLevel * 0.3, speed: 0.5 + variationLevel * 0.3, chaos: 0.5 + variationLevel * 0.2, morphFactor: 0.8 + variationLevel * 0.05 },
+            6: { gridDensity: 0.6 + variationLevel * 0.4, speed: 0.8 + variationLevel * 0.4, chaos: 0.4 + variationLevel * 0.3, morphFactor: 0.6 + variationLevel * 0.2 },
+            7: { gridDensity: 1.6 + variationLevel * 0.2, speed: 0.2 + variationLevel * 0.1, chaos: 0.1 + variationLevel * 0.1, morphFactor: 0.2 + variationLevel * 0.2 }
         };
-        
+
         const config = geometryConfigs[baseGeometry];
-        
+
         return {
-            geometryType: baseGeometry,
+            geometry: baseGeometry,
             name: finalName,
-            density: config.density,
+            gridDensity: config.gridDensity,
             speed: config.speed,
             hue: (variant * 12.27) % 360,
-            saturation: 0.8 + (variationLevel * 0.05), // Add saturation parameter
+            saturation: 0.8 + (variationLevel * 0.05),
             intensity: 0.5 + (variationLevel * 0.1),
             chaos: config.chaos,
-            morph: config.morph
+            morphFactor: config.morphFactor
         };
     }
     
@@ -169,20 +169,20 @@ export class HolographicVisualizer {
                 densityMult: 0.8, speedMult: 0.3, colorShift: 180.0, intensity: 0.4,
                 mouseReactivity: 0.5, clickReactivity: 0.3 
             },
-            'content': { 
-                densityMult: vp.density, speedMult: vp.speed, 
+            'content': {
+                densityMult: vp.gridDensity, speedMult: vp.speed,
                 colorShift: vp.hue, intensity: vp.intensity,
-                mouseReactivity: 1.0, clickReactivity: 0.8 
+                mouseReactivity: 1.0, clickReactivity: 0.8
             },
-            'highlight': { 
-                densityMult: 1.5 + (vp.density * 0.3), speedMult: 0.8 + (vp.speed * 0.2), 
+            'highlight': {
+                densityMult: 1.5 + (vp.gridDensity * 0.3), speedMult: 0.8 + (vp.speed * 0.2),
                 colorShift: vp.hue + 60.0, intensity: 0.6 + (vp.intensity * 0.2),
-                mouseReactivity: 1.2, clickReactivity: 1.0 
+                mouseReactivity: 1.2, clickReactivity: 1.0
             },
-            'accent': { 
-                densityMult: 2.5 + (vp.density * 0.5), speedMult: 0.4 + (vp.speed * 0.1), 
+            'accent': {
+                densityMult: 2.5 + (vp.gridDensity * 0.5), speedMult: 0.4 + (vp.speed * 0.1),
                 colorShift: vp.hue + 300.0, intensity: 0.3 + (vp.intensity * 0.1),
-                mouseReactivity: 1.5, clickReactivity: 1.2 
+                mouseReactivity: 1.5, clickReactivity: 1.2
             }
         };
         
@@ -207,7 +207,7 @@ export class HolographicVisualizer {
             uniform float u_time;
             uniform vec2 u_mouse;
             uniform float u_geometry;
-            uniform float u_density;
+            uniform float u_gridDensity;
             uniform float u_speed;
             uniform vec3 u_color;
             uniform float u_intensity;
@@ -218,9 +218,8 @@ export class HolographicVisualizer {
             uniform float u_mouseIntensity;
             uniform float u_clickIntensity;
             uniform float u_densityVariation;
-            uniform float u_geometryType;
             uniform float u_chaos;
-            uniform float u_morph;
+            uniform float u_morphFactor;
             uniform float u_touchMorph;
             uniform float u_touchChaos;
             uniform float u_scrollParallax;
@@ -293,7 +292,7 @@ export class HolographicVisualizer {
             // ========================================
             vec3 warpHypersphereCore(vec3 p, int geometryIndex, vec2 mouseDelta) {
                 float radius = length(p);
-                float morphBlend = clamp(u_morph * 0.6 + 0.3, 0.0, 2.0);
+                float morphBlend = clamp(u_morphFactor * 0.6 + 0.3, 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);
 
@@ -315,7 +314,7 @@ export class HolographicVisualizer {
                 vec3 c3 = normalize(vec3(-1.0, 1.0, -1.0));
                 vec3 c4 = normalize(vec3(1.0, -1.0, -1.0));
 
-                float morphBlend = clamp(u_morph * 0.8 + 0.2, 0.0, 2.0);
+                float morphBlend = clamp(u_morphFactor * 0.8 + 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);
@@ -551,12 +550,12 @@ export class HolographicVisualizer {
                 float audioDensityMod = 1.0 + u_audioDensityBoost * 0.5;
                 // Controlled density calculation - breathing modulation added
                 float breathDensityMod = 1.0 + u_breath * 0.1;
-                float baseDensity = u_density * u_roleDensity * breathDensityMod;
+                float baseDensity = u_gridDensity * u_roleDensity * breathDensityMod;
 
                 float densityVariations = (u_densityVariation * 0.3 + (scrollDensityMod - 1.0) * 0.4 + (audioDensityMod - 1.0) * 0.2);
                 float roleDensity = baseDensity + densityVariations;
                 
-                float morphedGeometry = u_geometryType + u_morph * 3.0 + u_touchMorph * 2.0 + u_audioMorphBoost * 1.5;
+                float morphedGeometry = u_geometry + u_morphFactor * 3.0 + u_touchMorph * 2.0 + u_audioMorphBoost * 1.5;
                 float lattice = getDynamicGeometry(p, roleDensity, morphedGeometry);
                 
                 // Enhanced holographic color processing
@@ -590,9 +589,9 @@ export class HolographicVisualizer {
                 color = rgbGlitch(color, uv, enhancedChaos);
                 
                 // Apply morph distortion to position
-                vec2 morphDistortion = vec2(sin(uv.y * 10.0 + u_time * 0.001) * u_morph * 0.1, 
-                                           cos(uv.x * 10.0 + u_time * 0.001) * u_morph * 0.1);
-                color = mix(color, color * (1.0 + length(morphDistortion)), u_morph * 0.5);
+                vec2 morphDistortion = vec2(sin(uv.y * 10.0 + u_time * 0.001) * u_morphFactor * 0.1, 
+                                           cos(uv.x * 10.0 + u_time * 0.001) * u_morphFactor * 0.1);
+                color = mix(color, color * (1.0 + length(morphDistortion)), u_morphFactor * 0.5);
                 
                 // Enhanced holographic interaction effects
                 float mouseDist = length(uv - (u_mouse - 0.5) * vec2(aspectRatio, 1.0));
@@ -621,7 +620,7 @@ export class HolographicVisualizer {
             time: this.gl.getUniformLocation(this.program, 'u_time'),
             mouse: this.gl.getUniformLocation(this.program, 'u_mouse'),
             geometry: this.gl.getUniformLocation(this.program, 'u_geometry'),
-            density: this.gl.getUniformLocation(this.program, 'u_density'),
+            gridDensity: this.gl.getUniformLocation(this.program, 'u_gridDensity'),
             speed: this.gl.getUniformLocation(this.program, 'u_speed'),
             color: this.gl.getUniformLocation(this.program, 'u_color'),
             intensity: this.gl.getUniformLocation(this.program, 'u_intensity'),
@@ -632,9 +631,8 @@ export class HolographicVisualizer {
             mouseIntensity: this.gl.getUniformLocation(this.program, 'u_mouseIntensity'),
             clickIntensity: this.gl.getUniformLocation(this.program, 'u_clickIntensity'),
             densityVariation: this.gl.getUniformLocation(this.program, 'u_densityVariation'),
-            geometryType: this.gl.getUniformLocation(this.program, 'u_geometryType'),
             chaos: this.gl.getUniformLocation(this.program, 'u_chaos'),
-            morph: this.gl.getUniformLocation(this.program, 'u_morph'),
+            morphFactor: this.gl.getUniformLocation(this.program, 'u_morphFactor'),
             touchMorph: this.gl.getUniformLocation(this.program, 'u_touchMorph'),
             touchChaos: this.gl.getUniformLocation(this.program, 'u_touchChaos'),
             scrollParallax: this.gl.getUniformLocation(this.program, 'u_scrollParallax'),
@@ -894,11 +892,11 @@ export class HolographicVisualizer {
         this.gl.uniform2f(this.uniforms.resolution, this.canvas.width, this.canvas.height);
         this.gl.uniform1f(this.uniforms.time, time);
         this.gl.uniform2f(this.uniforms.mouse, this.mouseX, this.mouseY);
-        this.gl.uniform1f(this.uniforms.geometryType, this.variantParams.geometryType || 0);
-        this.gl.uniform1f(this.uniforms.density, this.variantParams.density || 1.0);
-        // FIX: Controlled speed calculation - base speed controls main movement, audio provides subtle boost
-        const baseSpeed = (this.variantParams.speed || 0.5) * 0.2; // Much slower base speed
-        const audioBoost = (this.audioSpeedBoost || 0.0) * 0.1; // Subtle audio boost only
+        this.gl.uniform1f(this.uniforms.geometry, this.variantParams.geometry !== undefined ? this.variantParams.geometry : this.variant || 0);
+        this.gl.uniform1f(this.uniforms.gridDensity, this.variantParams.gridDensity || 1.0);
+        // Controlled speed calculation - base speed controls main movement, audio provides subtle boost
+        const baseSpeed = (this.variantParams.speed || 0.5) * 0.2;
+        const audioBoost = (this.audioSpeedBoost || 0.0) * 0.1;
         this.gl.uniform1f(this.uniforms.speed, baseSpeed + audioBoost);
         this.gl.uniform3fv(this.uniforms.color, new Float32Array(rgbColor));
         this.gl.uniform1f(this.uniforms.intensity, (this.variantParams.intensity || 0.5) * this.roleParams.intensity);
@@ -909,9 +907,8 @@ export class HolographicVisualizer {
         this.gl.uniform1f(this.uniforms.mouseIntensity, this.mouseIntensity);
         this.gl.uniform1f(this.uniforms.clickIntensity, this.clickIntensity);
         this.gl.uniform1f(this.uniforms.densityVariation, this.densityVariation);
-        this.gl.uniform1f(this.uniforms.geometryType, this.variantParams.geometryType !== undefined ? this.variantParams.geometryType : this.variant || 0);
         this.gl.uniform1f(this.uniforms.chaos, this.variantParams.chaos || 0.0);
-        this.gl.uniform1f(this.uniforms.morph, this.variantParams.morph || 0.0);
+        this.gl.uniform1f(this.uniforms.morphFactor, this.variantParams.morphFactor || 0.0);
         
         // Touch and scroll uniforms
         this.gl.uniform1f(this.uniforms.touchMorph, this.touchMorph);
@@ -1001,62 +998,34 @@ export class HolographicVisualizer {
     }
 
     /**
-     * CRITICAL FIX: Update visualization parameters with immediate re-render
-     * This method was missing and causing parameter sliders to not work in holographic system
+     * Update visualization parameters from SDK global parameter names.
+     * Parameters are written directly to variantParams — no name mapping needed
+     * since shader uniforms now use SDK-standard names.
      */
     updateParameters(params) {
         if (!params || typeof params !== 'object') return;
-        // Update variant parameters with proper mapping and scaling
         if (this.variantParams) {
             Object.keys(params).forEach(param => {
-                const mappedParam = this.mapParameterName(param);
-                if (mappedParam !== null) {
-                    let scaledValue = params[param];
-                    // Guard against NaN/Infinity reaching GPU uniforms
-                    if (typeof scaledValue !== 'number' || !Number.isFinite(scaledValue)) return;
-                    
-                    // FIX: Scale gridDensity to reasonable holographic density range (back to normal levels)
-                    if (param === 'gridDensity') {
-                        // Convert gridDensity (5-100) to holographic density (0.3-2.5) - reasonable range
-                        // Formula: density = 0.3 + (gridDensity - 5) / (100 - 5) * (2.5 - 0.3)
-                        scaledValue = 0.3 + (parseFloat(params[param]) - 5) / 95 * 2.2;
-                        console.log(`🔧 Density scaling: gridDensity=${params[param]} → density=${scaledValue.toFixed(3)} (normal range)`);
-                    }
-                    
-                    this.variantParams[mappedParam] = scaledValue;
-                    
-                    // Handle special parameter types
-                    if (mappedParam === 'geometryType') {
-                        // Regenerate role params with new geometry
-                        this.roleParams = this.generateRoleParams(this.role);
-                    }
+                let scaledValue = params[param];
+                // Guard against NaN/Infinity reaching GPU uniforms
+                if (typeof scaledValue !== 'number' || !Number.isFinite(scaledValue)) return;
+
+                // Scale gridDensity (5-100) to holographic density range (0.3-2.5)
+                if (param === 'gridDensity') {
+                    scaledValue = 0.3 + (parseFloat(params[param]) - 5) / 95 * 2.2;
+                }
+
+                this.variantParams[param] = scaledValue;
+
+                // Regenerate role params when geometry changes
+                if (param === 'geometry') {
+                    this.roleParams = this.generateRoleParams(this.role);
                 }
             });
         }
-        
+
         // Don't call render() here - engine will call it to prevent infinite loop
     }
-    
-    /**
-     * Map global parameter names to holographic system parameter names
-     */
-    mapParameterName(globalParam) {
-        const paramMap = {
-            'gridDensity': 'density',
-            'morphFactor': 'morph',
-            'rot4dXW': 'rot4dXW',
-            'rot4dYW': 'rot4dYW', 
-            'rot4dZW': 'rot4dZW',
-            'hue': 'hue',
-            'intensity': 'intensity',
-            'saturation': 'saturation',
-            'chaos': 'chaos',
-            'speed': 'speed',
-            'geometry': 'geometryType',
-            'breath': 'breath'
-        };
-        return paramMap[globalParam] || globalParam;
-    }
 
     /**
      * Clean up all WebGL resources and event listeners

package/src/math/Mat4x4.js

@@ -547,6 +547,122 @@ export class Mat4x4 {
         return new Mat4x4(json.data);
     }
 
+    // ========== IN-PLACE ROTATIONS ==========
+
+    /**
+     * Rotate in XY plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateXY(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a0 = m[i];      // Col 0
+            const a1 = m[i + 4];  // Col 1
+            m[i]     = a0 * c + a1 * s;
+            m[i + 4] = -a0 * s + a1 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in XZ plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateXZ(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a0 = m[i];      // Col 0
+            const a2 = m[i + 8];  // Col 2
+            m[i]     = a0 * c - a2 * s;
+            m[i + 8] = a0 * s + a2 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in YZ plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateYZ(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a1 = m[i + 4];  // Col 1
+            const a2 = m[i + 8];  // Col 2
+            m[i + 4] = a1 * c + a2 * s;
+            m[i + 8] = -a1 * s + a2 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in XW plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateXW(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a0 = m[i];       // Col 0
+            const a3 = m[i + 12];  // Col 3
+            m[i]      = a0 * c + a3 * s;
+            m[i + 12] = -a0 * s + a3 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in YW plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateYW(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a1 = m[i + 4];   // Col 1
+            const a3 = m[i + 12];  // Col 3
+            m[i + 4]  = a1 * c + a3 * s;
+            m[i + 12] = -a1 * s + a3 * c;
+        }
+        return this;
+    }
+
+    /**
+     * Rotate in ZW plane in place
+     * @param {number} angle
+     * @returns {Mat4x4} this
+     */
+    rotateZW(angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const m = this.data;
+
+        for (let i = 0; i < 4; i++) {
+            const a2 = m[i + 8];   // Col 2
+            const a3 = m[i + 12];  // Col 3
+            m[i + 8]  = a2 * c + a3 * s;
+            m[i + 12] = -a2 * s + a3 * c;
+        }
+        return this;
+    }
+
     // ========== ROTATION MATRICES FOR ALL 6 PLANES ==========
 
     /**
@@ -681,12 +797,12 @@ export class Mat4x4 {
     static rotationFromAngles(angles) {
         let result = Mat4x4.identity();
 
-        if (angles.xy) result = result.multiply(Mat4x4.rotationXY(angles.xy));
-        if (angles.xz) result = result.multiply(Mat4x4.rotationXZ(angles.xz));
-        if (angles.yz) result = result.multiply(Mat4x4.rotationYZ(angles.yz));
-        if (angles.xw) result = result.multiply(Mat4x4.rotationXW(angles.xw));
-        if (angles.yw) result = result.multiply(Mat4x4.rotationYW(angles.yw));
-        if (angles.zw) result = result.multiply(Mat4x4.rotationZW(angles.zw));
+        if (angles.xy) result.rotateXY(angles.xy);
+        if (angles.xz) result.rotateXZ(angles.xz);
+        if (angles.yz) result.rotateYZ(angles.yz);
+        if (angles.xw) result.rotateXW(angles.xw);
+        if (angles.yw) result.rotateYW(angles.yw);
+        if (angles.zw) result.rotateZW(angles.zw);
 
         return result;
     }

package/src/math/Rotor4D.js

@@ -323,54 +323,108 @@ export class Rotor4D {
     /**
      * Rotate a 4D vector using sandwich product: v' = R v R†
      *
+     * Matrix math is inlined to avoid allocating a temporary Float32Array(16).
+     * Pass an optional target Vec4 to eliminate all allocations.
+     *
      * @param {Vec4} v - Vector to rotate
-     * @returns {Vec4} Rotated vector
+     * @param {Vec4} [target] - Optional pre-allocated Vec4 to write result into
+     * @returns {Vec4} Rotated vector (target if provided, otherwise new Vec4)
      */
-    rotate(v) {
-        // For efficiency, we expand the sandwich product directly
-        // rather than doing two rotor multiplications
-
+    rotate(v, target) {
         const x = v.x, y = v.y, z = v.z, w = v.w;
 
-        // Compute R v (rotor times vector)
-        // Vector in GA is: x*e1 + y*e2 + z*e3 + w*e4
-        // This produces a mixed multivector
-
-        // Then multiply by R† (reverse of rotor)
-        // Extract the vector part of the result
+        // Normalize for numerical stability (same as toMatrix)
+        const n = this.norm();
+        const invN = n > 1e-10 ? 1 / n : 1;
 
-        // Pre-compute some common terms
-        const s = this.s;
-        const xy = this.xy, xz = this.xz, yz = this.yz;
-        const xw = this.xw, yw = this.yw, zw = this.zw;
-        const xyzw = this.xyzw;
+        const s = this.s * invN;
+        const xy = this.xy * invN;
+        const xz = this.xz * invN;
+        const yz = this.yz * invN;
+        const xw = this.xw * invN;
+        const yw = this.yw * invN;
+        const zw = this.zw * invN;
+        const xyzw = this.xyzw * invN;
 
-        // Squared terms for the rotation formula
+        // Squared terms
         const s2 = s * s;
-        const xy2 = xy * xy, xz2 = xz * xz, yz2 = yz * yz;
-        const xw2 = xw * xw, yw2 = yw * yw, zw2 = zw * zw;
+        const xy2 = xy * xy;
+        const xz2 = xz * xz;
+        const yz2 = yz * yz;
+        const xw2 = xw * xw;
+        const yw2 = yw * yw;
+        const zw2 = zw * zw;
         const xyzw2 = xyzw * xyzw;
 
-        // The full rotation formula derived from R v R†
-        const newX =
-            x * (s2 + xy2 + xz2 - yz2 + xw2 - yw2 - zw2 - xyzw2) +
-            2 * y * (s * xy + xz * yz + xw * yw - s * xyzw * zw + xy * s - xyzw * zw) +
-            2 * z * (s * xz - xy * yz + xw * zw + xyzw * yw) +
-            2 * w * (s * xw - xy * yw - xz * zw - xyzw * yz);
-
-        // Simplified rotation using matrix form
-        // This is equivalent but clearer
-
-        // Actually, let's use the direct matrix multiplication approach
-        // which is more numerically stable
-
-        const m = this.toMatrix();
-        return new Vec4(
-            m[0] * x + m[4] * y + m[8] * z + m[12] * w,
-            m[1] * x + m[5] * y + m[9] * z + m[13] * w,
-            m[2] * x + m[6] * y + m[10] * z + m[14] * w,
-            m[3] * x + m[7] * y + m[11] * z + m[15] * w
-        );
+        // Cross terms (pre-multiplied by 2)
+        const sxy = 2 * s * xy;
+        const sxz = 2 * s * xz;
+        const syz = 2 * s * yz;
+        const sxw = 2 * s * xw;
+        const syw = 2 * s * yw;
+        const szw = 2 * s * zw;
+
+        const xzyz = 2 * xz * yz;
+        const xyyz = 2 * xy * yz;
+        const xyxz = 2 * xy * xz;
+        const xyxw = 2 * xy * xw;
+        const xyyw = 2 * xy * yw;
+
+        const xzxw = 2 * xz * xw;
+        const xzyw = 2 * xz * yw;
+        const xzzw = 2 * xz * zw;
+
+        const yzxw = 2 * yz * xw;
+        const yzyw = 2 * yz * yw;
+        const yzzw = 2 * yz * zw;
+
+        const xwyw = 2 * xw * yw;
+        const xwzw = 2 * xw * zw;
+        const ywzw = 2 * yw * zw;
+
+        const xyxyzw = 2 * xy * xyzw;
+        const xzxyzw = 2 * xz * xyzw;
+        const yzxyzw = 2 * yz * xyzw;
+        const xwxyzw = 2 * xw * xyzw;
+        const ywxyzw = 2 * yw * xyzw;
+        const zwxyzw = 2 * zw * xyzw;
+
+        // Column-major 4x4 rotation matrix entries (inlined from toMatrix)
+        // Column 0
+        const m0  = s2 - xy2 - xz2 + yz2 - xw2 + yw2 + zw2 - xyzw2;
+        const m1  = sxy + xzyz + xwyw - zwxyzw;
+        const m2  = sxz - xyyz + xwzw + ywxyzw;
+        const m3  = sxw - xyyw - xzzw - yzxyzw;
+        // Column 1
+        const m4  = -sxy + xzyz + xwyw + zwxyzw;
+        const m5  = s2 - xy2 + xz2 - yz2 + xw2 - yw2 + zw2 - xyzw2;
+        const m6  = syz + xyxz + ywzw - xwxyzw;
+        const m7  = syw + xyxw - yzzw + xzxyzw;
+        // Column 2
+        const m8  = -sxz - xyyz + xwzw - ywxyzw;
+        const m9  = -syz + xyxz + ywzw + xwxyzw;
+        const m10 = s2 + xy2 - xz2 - yz2 + xw2 + yw2 - zw2 - xyzw2;
+        const m11 = szw + xzxw + yzyw - xyxyzw;
+        // Column 3
+        const m12 = -sxw - xyyw - xzzw + yzxyzw;
+        const m13 = -syw + xyxw - yzzw - xzxyzw;
+        const m14 = -szw + xzxw + yzyw + xyxyzw;
+        const m15 = s2 + xy2 + xz2 + yz2 - xw2 - yw2 - zw2 - xyzw2;
+
+        // Matrix-vector multiply
+        const rx = m0 * x + m4 * y + m8  * z + m12 * w;
+        const ry = m1 * x + m5 * y + m9  * z + m13 * w;
+        const rz = m2 * x + m6 * y + m10 * z + m14 * w;
+        const rw = m3 * x + m7 * y + m11 * z + m15 * w;
+
+        if (target) {
+            target.x = rx;
+            target.y = ry;
+            target.z = rz;
+            target.w = rw;
+            return target;
+        }
+        return new Vec4(rx, ry, rz, rw);
     }
 
     /**