action-engine-js 1.0.0

package/actionengine/math/vector2.js

@@ -0,0 +1,277 @@
+// actionengine/math/vector2.js
+class Vector2 {
+    constructor(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+    }
+
+    // Static creation methods
+    static create(x = 0, y = 0) {
+        return new Vector2(x, y);
+    }
+
+    static fromAngle(angle) {
+        return new Vector2(Math.cos(angle), Math.sin(angle));
+    }
+
+    static fromArray(arr, offset = 0) {
+        return new Vector2(arr[offset], arr[offset + 1]);
+    }
+
+    static zero() {
+        return new Vector2(0, 0);
+    }
+
+    static one() {
+        return new Vector2(1, 1);
+    }
+
+    static up() {
+        return new Vector2(0, -1);
+    }
+
+    static down() {
+        return new Vector2(0, 1);
+    }
+
+    static left() {
+        return new Vector2(-1, 0);
+    }
+
+    static right() {
+        return new Vector2(1, 0);
+    }
+
+    // Basic operations (modifying this vector)
+    set(x, y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+
+    copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        return this;
+    }
+
+    add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        return this;
+    }
+
+    subtract(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        return this;
+    }
+
+    multiply(v) {
+        this.x *= v.x;
+        this.y *= v.y;
+        return this;
+    }
+
+    divide(v) {
+        this.x /= v.x;
+        this.y /= v.y;
+        return this;
+    }
+
+    scale(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        return this;
+    }
+
+    negate() {
+        this.x = -this.x;
+        this.y = -this.y;
+        return this;
+    }
+
+    normalize() {
+        const len = this.length();
+        if (len > 0) {
+            this.x /= len;
+            this.y /= len;
+        }
+        return this;
+    }
+
+    rotate(angle) {
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        const x = this.x * cos - this.y * sin;
+        const y = this.x * sin + this.y * cos;
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+
+    // Vector properties
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+
+    lengthSquared() {
+        return this.x * this.x + this.y * this.y;
+    }
+
+    angle() {
+        return Math.atan2(this.y, this.x);
+    }
+
+    distanceTo(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+
+    distanceToSquared(v) {
+        const dx = this.x - v.x;
+        const dy = this.y - v.y;
+        return dx * dx + dy * dy;
+    }
+
+    dot(v) {
+        return this.x * v.x + this.y * v.y;
+    }
+
+    cross(v) {
+        return this.x * v.y - this.y * v.x;
+    }
+
+    // Utility methods
+    clone() {
+        return new Vector2(this.x, this.y);
+    }
+
+    equals(v) {
+        return this.x === v.x && this.y === v.y;
+    }
+
+    isZero() {
+        return this.x === 0 && this.y === 0;
+    }
+
+    toString() {
+        return `Vector2(${this.x}, ${this.y})`;
+    }
+
+    toArray() {
+        return [this.x, this.y];
+    }
+
+    // Static operations (returning new vectors)
+    static add(out, a, b) {
+        out.x = a.x + b.x;
+        out.y = a.y + b.y;
+        return out;
+    }
+
+    static subtract(out, a, b) {
+        out.x = a.x - b.x;
+        out.y = a.y - b.y;
+        return out;
+    }
+
+    static multiply(out, a, b) {
+        out.x = a.x * b.x;
+        out.y = a.y * b.y;
+        return out;
+    }
+
+    static divide(out, a, b) {
+        out.x = a.x / b.x;
+        out.y = a.y / b.y;
+        return out;
+    }
+
+    static scale(out, v, scalar) {
+        out.x = v.x * scalar;
+        out.y = v.y * scalar;
+        return out;
+    }
+
+    static lerp(out, a, b, t) {
+        out.x = a.x + (b.x - a.x) * t;
+        out.y = a.y + (b.y - a.y) * t;
+        return out;
+    }
+
+    static min(out, a, b) {
+        out.x = Math.min(a.x, b.x);
+        out.y = Math.min(a.y, b.y);
+        return out;
+    }
+
+    static max(out, a, b) {
+        out.x = Math.max(a.x, b.x);
+        out.y = Math.max(a.y, b.y);
+        return out;
+    }
+
+    static normalize(out, v) {
+        const len = v.length();
+        if (len > 0) {
+            out.x = v.x / len;
+            out.y = v.y / len;
+        }
+        return out;
+    }
+
+    static rotate(out, v, angle) {
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        out.x = v.x * cos - v.y * sin;
+        out.y = v.x * sin + v.y * cos;
+        return out;
+    }
+
+    static dot(a, b) {
+        return a.x * b.x + a.y * b.y;
+    }
+
+    static cross(a, b) {
+        return a.x * b.y - a.y * b.x;
+    }
+
+    static distance(a, b) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+
+    static distanceSquared(a, b) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        return dx * dx + dy * dy;
+    }
+
+    static angle(a, b) {
+        return Math.atan2(b.y - a.y, b.x - a.x);
+    }
+
+    // Advanced operations
+    static reflect(out, v, normal) {
+        const dot = v.x * normal.x + v.y * normal.y;
+        out.x = v.x - 2 * dot * normal.x;
+        out.y = v.y - 2 * dot * normal.y;
+        return out;
+    }
+
+    static project(out, a, b) {
+        const dot = (a.x * b.x + a.y * b.y) / (b.x * b.x + b.y * b.y);
+        out.x = b.x * dot;
+        out.y = b.y * dot;
+        return out;
+    }
+
+    static perpendicular(out, v) {
+        out.x = -v.y;
+        out.y = v.x;
+        return out;
+    }
+}

package/actionengine/math/vector3.js

@@ -0,0 +1,318 @@
+// actionengine/math/vector3.js
+class Vector3 {
+    // Vector pool for object reuse
+    static _pool = [];
+    static _poolSize = 0;
+    static _maxPoolSize = 1000;
+
+    // Get a vector from the pool or create a new one
+    static getFromPool(x = 0, y = 0, z = 0) {
+        if (Vector3._poolSize > 0) {
+            const vec = Vector3._pool[--Vector3._poolSize];
+            vec.set(x, y, z);
+            return vec;
+        }
+        return new Vector3(x, y, z);
+    }
+
+    // Return a vector to the pool when done with it
+    static returnToPool(vec) {
+        if (Vector3._poolSize < Vector3._maxPoolSize) {
+            Vector3._pool[Vector3._poolSize++] = vec;
+        }
+    }
+    constructor(x = 0, y = 0, z = 0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    set(x, y, z) {
+        if (y === undefined && z === undefined && x.x !== undefined) {
+            // If passed another vector
+            this.x = x.x;
+            this.y = x.y;
+            this.z = x.z;
+        } else {
+            // If passed 3 numbers
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
+        return this;
+    }
+
+    // Distance between two vectors
+    static distance(a, b) {
+        return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2) + Math.pow(a.z - b.z, 2));
+    }
+
+    // For distance calculations between points
+    distanceTo(other) {
+        const dx = this.x - other.x;
+        const dy = this.y - other.y;
+        const dz = this.z - other.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+
+    // More efficient squared distance, avoids costly sqrt when possible
+    distanceSquared(other) {
+        const dx = this.x - other.x;
+        const dy = this.y - other.y;
+        const dz = this.z - other.z;
+        return dx * dx + dy * dy + dz * dz;
+    }
+
+    // For horizontal distance (ignoring Y) - useful for camera calculations
+    horizontalDistanceTo(other) {
+        const dx = this.x - other.x;
+        const dz = this.z - other.z;
+        return Math.sqrt(dx * dx + dz * dz);
+    }
+
+    // More efficient squared horizontal distance
+    horizontalDistanceSquared(other) {
+        const dx = this.x - other.x;
+        const dz = this.z - other.z;
+        return dx * dx + dz * dz;
+    }
+
+    // For applying movement/translation
+    translate(direction, amount) {
+        return new Vector3(this.x + direction.x * amount, this.y + direction.y * amount, this.z + direction.z * amount);
+    }
+
+    // In-place version to avoid creating a new Vector3
+    translateInPlace(direction, amount) {
+        this.x += direction.x * amount;
+        this.y += direction.y * amount;
+        this.z += direction.z * amount;
+        return this;
+    }
+
+    // For rotation around Y axis (useful for camera orbiting)
+    rotateY(angle) {
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        return new Vector3(this.x * cos + this.z * sin, this.y, -this.x * sin + this.z * cos);
+    }
+
+    // In-place version to avoid creating a new Vector3
+    rotateYInPlace(angle) {
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        const x = this.x;
+        const z = this.z;
+        this.x = x * cos + z * sin;
+        this.z = -x * sin + z * cos;
+        return this;
+    }
+
+    // Gets a normalized vector representing just the horizontal component
+    horizontalNormalize() {
+        return new Vector3(this.x, 0, this.z).normalize();
+    }
+
+    static transformMat4(vec, mat) {
+        // Make sure we can access the matrix data whether it's Array or Float32Array
+        const getElement = (idx) => (mat[idx] !== undefined ? mat[idx] : mat.at(idx));
+
+        const x = vec.x;
+        const y = vec.y;
+        const z = vec.z;
+        let w = getElement(3) * x + getElement(7) * y + getElement(11) * z + getElement(15);
+        if (w === 0) w = 1;
+
+        return new Vector3(
+            (getElement(0) * x + getElement(4) * y + getElement(8) * z + getElement(12)) / w,
+            (getElement(1) * x + getElement(5) * y + getElement(9) * z + getElement(13)) / w,
+            (getElement(2) * x + getElement(6) * y + getElement(10) * z + getElement(14)) / w
+        );
+    }
+    static fromValues(x, y, z) {
+        return new Vector3(x, y, z);
+    }
+
+    static min(out, a, b) {
+        out.x = Math.min(a.x, b.x);
+        out.y = Math.min(a.y, b.y);
+        out.z = Math.min(a.z, b.z);
+        return out;
+    }
+
+    static max(out, a, b) {
+        out.x = Math.max(a.x, b.x);
+        out.y = Math.max(a.y, b.y);
+        out.z = Math.max(a.z, b.z);
+        return out;
+    }
+    static create(x = 0, y = 0, z = 0) {
+        return new Vector3(x, y, z);
+    }
+
+    // Add optimized add operation that creates less garbage
+    add(other) {
+        return new Vector3(this.x + other.x, this.y + other.y, this.z + other.z);
+    }
+
+    // In-place addition
+    addInPlace(other) {
+        this.x += other.x;
+        this.y += other.y;
+        this.z += other.z;
+        return this;
+    }
+
+    // Add optimized subtract operation
+    sub(other) {
+        return new Vector3(this.x - other.x, this.y - other.y, this.z - other.z);
+    }
+    // Subtract vector b from vector a
+    static subtract(a, b) {
+        return new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
+    }
+    // In-place subtraction
+    subInPlace(other) {
+        this.x -= other.x;
+        this.y -= other.y;
+        this.z -= other.z;
+        return this;
+    }
+
+    // Vector normalization
+    normalize() {
+        const len = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+        if (len === 0) {
+            return new Vector3(0, 0, 0);
+        }
+        return new Vector3(this.x / len, this.y / len, this.z / len);
+    }
+
+    // In-place normalization
+    normalizeInPlace() {
+        const len = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+        if (len !== 0) {
+            this.x /= len;
+            this.y /= len;
+            this.z /= len;
+        }
+        return this;
+    }
+
+    // Add dot product operation
+    dot(other) {
+        return this.x * other.x + this.y * other.y + this.z * other.z;
+    }
+
+    // Add cross product operation
+    cross(other) {
+        return new Vector3(
+            this.y * other.z - this.z * other.y,
+            this.z * other.x - this.x * other.z,
+            this.x * other.y - this.y * other.x
+        );
+    }
+
+    // Array conversion
+    toArray() {
+        return [this.x, this.y, this.z];
+    }
+
+    // Length calculation
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+
+    // Squared length (faster, avoids sqrt)
+    lengthSquared() {
+        return this.x * this.x + this.y * this.y + this.z * this.z;
+    }
+
+    toArray() {
+        return [this.x, this.y, this.z];
+    }
+
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+
+    add(v) {
+        return new Vector3(this.x + v.x, this.y + v.y, this.z + v.z);
+    }
+
+    sub(v) {
+        return new Vector3(this.x - v.x, this.y - v.y, this.z - v.z);
+    }
+
+    mult(n) {
+        return new Vector3(this.x * n, this.y * n, this.z * n);
+    }
+
+    normalize() {
+        const len = this.length();
+        if (len === 0) {
+            return new Vector3();
+        }
+        return new Vector3(this.x / len, this.y / len, this.z / len);
+    }
+
+    scale(scalar) {
+        return new Vector3(this.x * scalar, this.y * scalar, this.z * scalar);
+    }
+    // Scale a vector by a scalar
+    static scale(v, scalar) {
+        return new Vector3(v.x * scalar, v.y * scalar, v.z * scalar);
+    }
+    divideScalar(scalar) {
+        if (scalar === 0) {
+            console.warn("Vector3: Division by zero!");
+            return new Vector3(0, 0, 0);
+        }
+
+        return new Vector3(this.x / scalar, this.y / scalar, this.z / scalar);
+    }
+
+    subtract(other) {
+        return new Vector3(this.x - other.x, this.y - other.y, this.z - other.z);
+    }
+
+    equals(other) {
+        const epsilon = 0.000001; // Small threshold for floating point comparison
+        return (
+            Math.abs(this.x - other.x) < epsilon &&
+            Math.abs(this.y - other.y) < epsilon &&
+            Math.abs(this.z - other.z) < epsilon
+        );
+    }
+
+    dot(v) {
+        return this.x * v.x + this.y * v.y + this.z * v.z;
+    }
+
+    cross(v) {
+        return new Vector3(this.y * v.z - this.z * v.y, this.z * v.x - this.x * v.z, this.x * v.y - this.y * v.x);
+    }
+
+    clone() {
+        return new Vector3(this.x, this.y, this.z);
+    }
+    
+    /**
+     * Copy the values from another Vector3 into this one
+     * @param {Vector3} v - Vector to copy from
+     * @returns {Vector3} this vector
+     */
+    copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        return this;
+    }
+
+    lerp(target, t) {
+        return new Vector3(
+            this.x + (target.x - this.x) * t,
+            this.y + (target.y - this.y) * t,
+            this.z + (target.z - this.z) * t
+        );
+    }
+}