@vib3code/sdk 2.0.3-canary.45332e3 → 2.0.3-canary.4874bcf

package/src/math/Vec4.js

@@ -2,7 +2,8 @@
  * Vec4 - 4D Vector Class
  *
  * Represents a point or direction in 4-dimensional space.
- * Uses Float32Array for GPU compatibility and potential SIMD optimization.
+ * Uses plain numeric properties internally for minimal allocation overhead.
+ * GPU-compatible Float32Array created on demand via toFloat32Array().
  *
  * @example
  * const v = new Vec4(1, 2, 3, 0.5);
@@ -19,26 +20,66 @@ export class Vec4 {
      * @param {number} w - W component (4th dimension)
      */
     constructor(x = 0, y = 0, z = 0, w = 0) {
-        // Use Float32Array for GPU compatibility
-        this.data = new Float32Array(4);
-        this.data[0] = x;
-        this.data[1] = y;
-        this.data[2] = z;
-        this.data[3] = w;
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        this._w = w;
     }
 
-    // Property accessors for readability
-    get x() { return this.data[0]; }
-    set x(v) { this.data[0] = v; }
+    // Property accessors
+    get x() { return this._x; }
+    set x(v) { this._x = v; }
 
-    get y() { return this.data[1]; }
-    set y(v) { this.data[1] = v; }
+    get y() { return this._y; }
+    set y(v) { this._y = v; }
 
-    get z() { return this.data[2]; }
-    set z(v) { this.data[2] = v; }
+    get z() { return this._z; }
+    set z(v) { this._z = v; }
 
-    get w() { return this.data[3]; }
-    set w(v) { this.data[3] = v; }
+    get w() { return this._w; }
+    set w(v) { this._w = v; }
+
+    /**
+     * Backward-compatible .data getter.
+     * Returns a Float32Array snapshot of current values.
+     * Note: writes to the returned array do NOT propagate back.
+     * Use setComponent(index, value) for index-based mutation.
+     * @returns {Float32Array}
+     */
+    get data() {
+        return new Float32Array([this._x, this._y, this._z, this._w]);
+    }
+
+    /**
+     * Set a component by index (0=x, 1=y, 2=z, 3=w)
+     * @param {number} index - Component index (0-3)
+     * @param {number} value - New value
+     * @returns {Vec4} this
+     */
+    setComponent(index, value) {
+        switch (index) {
+            case 0: this._x = value; break;
+            case 1: this._y = value; break;
+            case 2: this._z = value; break;
+            case 3: this._w = value; break;
+        }
+        return this;
+    }
+
+    /**
+     * Get a component by index (0=x, 1=y, 2=z, 3=w)
+     * @param {number} index - Component index (0-3)
+     * @returns {number}
+     */
+    getComponent(index) {
+        switch (index) {
+            case 0: return this._x;
+            case 1: return this._y;
+            case 2: return this._z;
+            case 3: return this._w;
+            default: return 0;
+        }
+    }
 
     /**
      * Create a Vec4 from an array
@@ -54,7 +95,7 @@ export class Vec4 {
      * @returns {Vec4}
      */
     clone() {
-        return new Vec4(this.x, this.y, this.z, this.w);
+        return new Vec4(this._x, this._y, this._z, this._w);
     }
 
     /**
@@ -63,10 +104,10 @@ export class Vec4 {
      * @returns {Vec4} this (for chaining)
      */
     copy(v) {
-        this.data[0] = v.data[0];
-        this.data[1] = v.data[1];
-        this.data[2] = v.data[2];
-        this.data[3] = v.data[3];
+        this._x = v._x;
+        this._y = v._y;
+        this._z = v._z;
+        this._w = v._w;
         return this;
     }
 
@@ -79,24 +120,32 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     set(x, y, z, w) {
-        this.data[0] = x;
-        this.data[1] = y;
-        this.data[2] = z;
-        this.data[3] = w;
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        this._w = w;
         return this;
     }
 
     /**
-     * Add another vector (immutable)
+     * Add another vector (immutable unless target provided)
      * @param {Vec4} v
-     * @returns {Vec4} New vector
-     */
-    add(v) {
+     * @param {Vec4} [target=null] - Optional target vector
+     * @returns {Vec4} New vector or target
+     */
+    add(v, target = null) {
+        if (target) {
+            target._x = this._x + v._x;
+            target._y = this._y + v._y;
+            target._z = this._z + v._z;
+            target._w = this._w + v._w;
+            return target;
+        }
         return new Vec4(
-            this.x + v.x,
-            this.y + v.y,
-            this.z + v.z,
-            this.w + v.w
+            this._x + v._x,
+            this._y + v._y,
+            this._z + v._z,
+            this._w + v._w
         );
     }
 
@@ -106,24 +155,32 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     addInPlace(v) {
-        this.data[0] += v.data[0];
-        this.data[1] += v.data[1];
-        this.data[2] += v.data[2];
-        this.data[3] += v.data[3];
+        this._x += v._x;
+        this._y += v._y;
+        this._z += v._z;
+        this._w += v._w;
         return this;
     }
 
     /**
-     * Subtract another vector (immutable)
+     * Subtract another vector (immutable unless target provided)
      * @param {Vec4} v
-     * @returns {Vec4} New vector
-     */
-    sub(v) {
+     * @param {Vec4} [target=null] - Optional target vector
+     * @returns {Vec4} New vector or target
+     */
+    sub(v, target = null) {
+        if (target) {
+            target._x = this._x - v._x;
+            target._y = this._y - v._y;
+            target._z = this._z - v._z;
+            target._w = this._w - v._w;
+            return target;
+        }
         return new Vec4(
-            this.x - v.x,
-            this.y - v.y,
-            this.z - v.z,
-            this.w - v.w
+            this._x - v._x,
+            this._y - v._y,
+            this._z - v._z,
+            this._w - v._w
         );
     }
 
@@ -133,24 +190,32 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     subInPlace(v) {
-        this.data[0] -= v.data[0];
-        this.data[1] -= v.data[1];
-        this.data[2] -= v.data[2];
-        this.data[3] -= v.data[3];
+        this._x -= v._x;
+        this._y -= v._y;
+        this._z -= v._z;
+        this._w -= v._w;
         return this;
     }
 
     /**
-     * Multiply by scalar (immutable)
+     * Multiply by scalar (immutable unless target provided)
      * @param {number} s
-     * @returns {Vec4} New vector
-     */
-    scale(s) {
+     * @param {Vec4} [target=null] - Optional target vector
+     * @returns {Vec4} New vector or target
+     */
+    scale(s, target = null) {
+        if (target) {
+            target._x = this._x * s;
+            target._y = this._y * s;
+            target._z = this._z * s;
+            target._w = this._w * s;
+            return target;
+        }
         return new Vec4(
-            this.x * s,
-            this.y * s,
-            this.z * s,
-            this.w * s
+            this._x * s,
+            this._y * s,
+            this._z * s,
+            this._w * s
         );
     }
 
@@ -160,33 +225,49 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     scaleInPlace(s) {
-        this.data[0] *= s;
-        this.data[1] *= s;
-        this.data[2] *= s;
-        this.data[3] *= s;
+        this._x *= s;
+        this._y *= s;
+        this._z *= s;
+        this._w *= s;
         return this;
     }
 
     /**
      * Component-wise multiply (Hadamard product)
      * @param {Vec4} v
-     * @returns {Vec4} New vector
-     */
-    multiply(v) {
+     * @param {Vec4} [target=null] - Optional target vector
+     * @returns {Vec4} New vector or target
+     */
+    multiply(v, target = null) {
+        if (target) {
+            target._x = this._x * v._x;
+            target._y = this._y * v._y;
+            target._z = this._z * v._z;
+            target._w = this._w * v._w;
+            return target;
+        }
         return new Vec4(
-            this.x * v.x,
-            this.y * v.y,
-            this.z * v.z,
-            this.w * v.w
+            this._x * v._x,
+            this._y * v._y,
+            this._z * v._z,
+            this._w * v._w
         );
     }
 
     /**
-     * Negate vector (immutable)
-     * @returns {Vec4} New vector
+     * Negate vector (immutable unless target provided)
+     * @param {Vec4} [target=null] - Optional target vector
+     * @returns {Vec4} New vector or target
      */
-    negate() {
-        return new Vec4(-this.x, -this.y, -this.z, -this.w);
+    negate(target = null) {
+        if (target) {
+            target._x = -this._x;
+            target._y = -this._y;
+            target._z = -this._z;
+            target._w = -this._w;
+            return target;
+        }
+        return new Vec4(-this._x, -this._y, -this._z, -this._w);
     }
 
     /**
@@ -194,10 +275,10 @@ export class Vec4 {
      * @returns {Vec4} this
      */
     negateInPlace() {
-        this.data[0] = -this.data[0];
-        this.data[1] = -this.data[1];
-        this.data[2] = -this.data[2];
-        this.data[3] = -this.data[3];
+        this._x = -this._x;
+        this._y = -this._y;
+        this._z = -this._z;
+        this._w = -this._w;
         return this;
     }
 
@@ -207,7 +288,7 @@ export class Vec4 {
      * @returns {number}
      */
     dot(v) {
-        return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
+        return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
     }
 
     /**
@@ -215,7 +296,7 @@ export class Vec4 {
      * @returns {number}
      */
     lengthSquared() {
-        return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+        return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
     }
 
     /**
@@ -232,7 +313,11 @@ export class Vec4 {
      * @returns {number}
      */
     distanceTo(v) {
-        return this.sub(v).length();
+        const dx = this._x - v._x;
+        const dy = this._y - v._y;
+        const dz = this._z - v._z;
+        const dw = this._w - v._w;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz + dw * dw);
     }
 
     /**
@@ -241,19 +326,31 @@ export class Vec4 {
      * @returns {number}
      */
     distanceToSquared(v) {
-        return this.sub(v).lengthSquared();
+        const dx = this._x - v._x;
+        const dy = this._y - v._y;
+        const dz = this._z - v._z;
+        const dw = this._w - v._w;
+        return dx * dx + dy * dy + dz * dz + dw * dw;
     }
 
     /**
-     * Normalize to unit length (immutable)
-     * @returns {Vec4} New normalized vector
+     * Normalize to unit length (immutable unless target provided)
+     * @param {Vec4} [target=null] - Optional target vector
+     * @returns {Vec4} New normalized vector or target
      */
-    normalize() {
+    normalize(target = null) {
         const len = this.length();
         if (len < 1e-10) {
+            if (target) {
+                target._x = 0;
+                target._y = 0;
+                target._z = 0;
+                target._w = 0;
+                return target;
+            }
             return new Vec4(0, 0, 0, 0);
         }
-        return this.scale(1 / len);
+        return this.scale(1 / len, target);
     }
 
     /**
@@ -273,14 +370,22 @@ export class Vec4 {
      * Linear interpolation to another vector
      * @param {Vec4} v - Target vector
      * @param {number} t - Interpolation factor (0-1)
-     * @returns {Vec4} New interpolated vector
-     */
-    lerp(v, t) {
+     * @param {Vec4} [target=null] - Optional target vector
+     * @returns {Vec4} New interpolated vector or target
+     */
+    lerp(v, t, target = null) {
+        if (target) {
+            target._x = this._x + (v._x - this._x) * t;
+            target._y = this._y + (v._y - this._y) * t;
+            target._z = this._z + (v._z - this._z) * t;
+            target._w = this._w + (v._w - this._w) * t;
+            return target;
+        }
         return new Vec4(
-            this.x + (v.x - this.x) * t,
-            this.y + (v.y - this.y) * t,
-            this.z + (v.z - this.z) * t,
-            this.w + (v.w - this.w) * t
+            this._x + (v._x - this._x) * t,
+            this._y + (v._y - this._y) * t,
+            this._z + (v._z - this._z) * t,
+            this._w + (v._w - this._w) * t
         );
     }
 
@@ -292,10 +397,10 @@ export class Vec4 {
      */
     equals(v, epsilon = 1e-6) {
         return (
-            Math.abs(this.x - v.x) < epsilon &&
-            Math.abs(this.y - v.y) < epsilon &&
-            Math.abs(this.z - v.z) < epsilon &&
-            Math.abs(this.w - v.w) < epsilon
+            Math.abs(this._x - v._x) < epsilon &&
+            Math.abs(this._y - v._y) < epsilon &&
+            Math.abs(this._z - v._z) < epsilon &&
+            Math.abs(this._w - v._w) < epsilon
         );
     }
 
@@ -311,43 +416,92 @@ export class Vec4 {
     /**
      * Project 4D point to 3D using perspective projection
      * Projects from 4D to 3D by dividing by (d - w)
-     * @param {number} d - Distance parameter (usually 2-5)
-     * @param {object} [options] - Projection options (epsilon, distance)
+     * @param {number|object} d - Distance parameter (usually 2-5) or options object
+     * @param {object|Vec4} [options] - Projection options or target vector
+     * @param {Vec4} [target] - Target vector to store result
      * @returns {Vec4} Projected point (w component is 0)
      */
-    projectPerspective(d = 2, options = {}) {
+    projectPerspective(d = 2, options = {}, target = null) {
         if (typeof d === 'object') {
+            // usage: projectPerspective({ distance: 2, ... }, target?)
+            if (options instanceof Vec4) {
+                target = options;
+            }
             options = d;
             d = options.distance ?? options.d ?? 2;
+        } else {
+            // usage: projectPerspective(d, options?, target?)
+            // usage: projectPerspective(d, target?)
+            if (options instanceof Vec4) {
+                target = options;
+                options = {};
+            }
         }
+
+        options = options || {};
+
         const epsilon = options.epsilon ?? 1e-5;
-        const denom = d - this.w;
+        const denom = d - this._w;
         const clamped = Math.abs(denom) < epsilon ? (denom >= 0 ? epsilon : -epsilon) : denom;
         const scale = 1 / clamped;
-        return new Vec4(this.x * scale, this.y * scale, this.z * scale, 0);
+
+        if (target) {
+            target._x = this._x * scale;
+            target._y = this._y * scale;
+            target._z = this._z * scale;
+            target._w = 0;
+            return target;
+        }
+
+        return new Vec4(this._x * scale, this._y * scale, this._z * scale, 0);
     }
 
     /**
      * Project 4D point to 3D using stereographic projection
      * Maps 4D hypersphere to 3D space
-     * @param {object} [options] - Projection options (epsilon)
+     * @param {object|Vec4} [options] - Projection options or target vector
+     * @param {Vec4} [target] - Target vector to store result
      * @returns {Vec4} Projected point (w component is 0)
      */
-    projectStereographic(options = {}) {
+    projectStereographic(options = {}, target = null) {
+        if (options instanceof Vec4) {
+            target = options;
+            options = {};
+        }
+
+        options = options || {};
+
         const epsilon = options.epsilon ?? 1e-5;
-        const denom = 1 - this.w;
+        const denom = 1 - this._w;
         const clamped = Math.abs(denom) < epsilon ? (denom >= 0 ? epsilon : -epsilon) : denom;
         const scale = 1 / clamped;
-        return new Vec4(this.x * scale, this.y * scale, this.z * scale, 0);
+
+        if (target) {
+            target._x = this._x * scale;
+            target._y = this._y * scale;
+            target._z = this._z * scale;
+            target._w = 0;
+            return target;
+        }
+
+        return new Vec4(this._x * scale, this._y * scale, this._z * scale, 0);
     }
 
     /**
      * Project 4D point to 3D using orthographic projection
      * Simply drops the W component
+     * @param {Vec4} [target=null] - Optional target vector
      * @returns {Vec4} Projected point (w component is 0)
      */
-    projectOrthographic() {
-        return new Vec4(this.x, this.y, this.z, 0);
+    projectOrthographic(target = null) {
+        if (target) {
+            target._x = this._x;
+            target._y = this._y;
+            target._z = this._z;
+            target._w = 0;
+            return target;
+        }
+        return new Vec4(this._x, this._y, this._z, 0);
     }
 
     /**
@@ -355,7 +509,7 @@ export class Vec4 {
      * @returns {number[]}
      */
     toArray() {
-        return [this.x, this.y, this.z, this.w];
+        return [this._x, this._y, this._z, this._w];
     }
 
     /**
@@ -363,7 +517,7 @@ export class Vec4 {
      * @returns {Float32Array}
      */
     toFloat32Array() {
-        return new Float32Array(this.data);
+        return new Float32Array([this._x, this._y, this._z, this._w]);
     }
 
     /**
@@ -371,7 +525,7 @@ export class Vec4 {
      * @returns {number[]}
      */
     toArray3() {
-        return [this.x, this.y, this.z];
+        return [this._x, this._y, this._z];
     }
 
     /**
@@ -380,7 +534,7 @@ export class Vec4 {
      * @returns {string}
      */
     toString(precision = 3) {
-        return `Vec4(${this.x.toFixed(precision)}, ${this.y.toFixed(precision)}, ${this.z.toFixed(precision)}, ${this.w.toFixed(precision)})`;
+        return `Vec4(${this._x.toFixed(precision)}, ${this._y.toFixed(precision)}, ${this._z.toFixed(precision)}, ${this._w.toFixed(precision)})`;
     }
 
     /**
@@ -388,7 +542,7 @@ export class Vec4 {
      * @returns {object}
      */
     toJSON() {
-        return { x: this.x, y: this.y, z: this.z, w: this.w };
+        return { x: this._x, y: this._y, z: this._z, w: this._w };
     }
 
     // Static factory methods for common vectors

package/src/quantum/QuantumVisualizer.js

@@ -787,6 +787,11 @@ void main() {
 }`;
         
         this.program = this.createProgram(vertexShaderSource, fragmentShaderSource);
+
+        if (!this.program) {
+            return;
+        }
+
         this.uniforms = {
             resolution: this.gl.getUniformLocation(this.program, 'u_resolution'),
             time: this.gl.getUniformLocation(this.program, 'u_time'),
@@ -817,6 +822,18 @@ void main() {
      * Create WebGL program from shaders
      */
     createProgram(vertexSource, fragmentSource) {
+        // CRITICAL FIX: Check WebGL context state before shader operations
+        if (!this.gl) {
+            console.error('❌ Cannot create program: WebGL context is null');
+            return null;
+        }
+
+        if (this.gl.isContextLost()) {
+            console.error('❌ Cannot create program: WebGL context is lost');
+            this._contextLost = true;
+            return null;
+        }
+
         const vertexShader = this.createShader(this.gl.VERTEX_SHADER, vertexSource);
         const fragmentShader = this.createShader(this.gl.FRAGMENT_SHADER, fragmentSource);
         
@@ -860,6 +877,7 @@ void main() {
         
         if (this.gl.isContextLost()) {
             console.error('❌ Cannot create shader: WebGL context is lost');
+            this._contextLost = true;
             if (window.mobileDebug) {
                 window.mobileDebug.log(`❌ ${this.canvas?.id}: Cannot create shader - WebGL context is lost`);
             }
@@ -924,6 +942,11 @@ void main() {
      * Initialize vertex buffers
      */
     initBuffers() {
+        // CRITICAL FIX: Check WebGL context state before buffer operations
+        if (!this.gl || this.gl.isContextLost()) {
+            return;
+        }
+
         const positions = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
         
         this.buffer = this.gl.createBuffer();
@@ -939,6 +962,11 @@ void main() {
      * Resize canvas and viewport
      */
     resize() {
+        // CRITICAL FIX: Check WebGL context state before viewport operations
+        if (!this.gl || this.gl.isContextLost()) {
+            return;
+        }
+
         // Mobile-optimized canvas sizing
         const dpr = Math.min(window.devicePixelRatio || 1, 2); // Cap at 2x for mobile performance
         const width = this.canvas.clientWidth;