@rocon/balcan 0.0.1

package/dist/core/math.balcan.js

@@ -0,0 +1,90 @@
+export var math;
+(function (math) {
+    function average(...values) {
+        if (values.length === 0)
+            return 0;
+        return values.reduce((acc, cur) => acc + cur, 0) / values.length;
+    }
+    math.average = average;
+    /** degree -> radian */
+    function radian(deg, opt) {
+        const parsedDeg = typeof deg === 'string' ? parseFloat(deg) : Number(deg);
+        const semi = opt?.invertY ? -180 : 180;
+        const rad = (parsedDeg * Math.PI) / semi;
+        if (opt?.toFixed) {
+            return parseFloat(rad.toFixed(opt.toFixed));
+        }
+        else {
+            return rad;
+        }
+    }
+    math.radian = radian;
+    /** radian -> degree */
+    function degree(rad, opt) {
+        const parsedRad = typeof rad === 'string' ? parseFloat(rad) : Number(rad);
+        const semi = opt?.invertY ? -180 : 180;
+        const degree = (parsedRad * semi) / Math.PI;
+        if (opt?.toFixed) {
+            return parseFloat(degree.toFixed(opt.toFixed));
+        }
+        else {
+            return degree;
+        }
+    }
+    math.degree = degree;
+    /** 주어진 각도를 -180 ~ 180 범위로 좁힌다 */
+    function normalizeAngle(degree) {
+        const mod = degree % 360;
+        if (mod <= -180)
+            return mod + 360;
+        if (mod > 180)
+            return mod - 360;
+        else
+            return mod;
+    }
+    math.normalizeAngle = normalizeAngle;
+    /** 위치 간 거리를 구한다, 위치는 Vector와 Position 타입을 사용할 수 있다 */
+    function vectorDistance(p1, p2) {
+        const v1 = vector2d(p1);
+        const v2 = vector2d(p2);
+        const dx = v2.x - v1.x;
+        const dy = v2.y - v1.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    math.vectorDistance = vectorDistance;
+    /** 두 점을 잇는 직선의 기울기를 구한다 */
+    function vectorSlope(params) {
+        const { point1, point2, outputUnit = 'radian' } = params;
+        let angle = 0;
+        const v1 = vector2d(point1);
+        const v2 = vector2d(point2);
+        angle = Math.atan2(v2.y - v1.y, v2.x - v1.x);
+        if (outputUnit === 'degree')
+            return degree(angle);
+        else
+            return angle;
+    }
+    math.vectorSlope = vectorSlope;
+    /** 벡터 덧셈 */
+    function vectorAdd(v1, v2) {
+        const r = { x: v1.x + v2.x, y: v1.y + v2.y };
+        if ('theta' in v1 && 'theta' in v2)
+            return { ...r, theta: v1.theta + v2.theta };
+        else
+            return r;
+    }
+    math.vectorAdd = vectorAdd;
+    /** 벡터 내적 */
+    function vectorDot(v1, v2) {
+        return v1.x * v2.x + v1.y * v2.y;
+    }
+    math.vectorDot = vectorDot;
+    /** position like 자료형을 vector2d 로 변환함 */
+    function vector2d(point) {
+        if ('stagex' in point)
+            return { x: point.stagex, y: point.stagey };
+        else
+            return { x: point.x, y: point.y };
+    }
+    math.vector2d = vector2d;
+})(math || (math = {}));

package/dist/core/ts-matrix/Matrix.d.ts

@@ -0,0 +1,111 @@
+import Vector from './Vector';
+export default class Matrix {
+    /** Number of rows of the matrix */
+    private _rows;
+    /** Number of columns of the matrix */
+    private _columns;
+    /** Values of the matrix as a two dimensional array */
+    private _values;
+    constructor(rows: number, columns: number, values?: number[][]);
+    get rows(): number;
+    get columns(): number;
+    get values(): number[][];
+    /**
+     * Set values into the matrix.
+     * If the parameters matrix is to wide, the values are cropped to the current matrix size.
+     * It the parameters matrix is to small, remaining cells will be filled with 0.
+     * @param newValues Arrays of new values.
+     */
+    set values(newValues: number[][]);
+    /**
+     * Get a matrix value, from its position
+     * @param row Matrix line, from 0 to `rows`
+     * @param col Matric column, from 0 to `columns`
+     */
+    at(row: number, col: number): number;
+    /**
+     * Sets all matrix values to 0
+     */
+    reset(): void;
+    /**
+     * Add an new column to the matrix, filled with 0
+     */
+    addAColumn(): Matrix;
+    /**
+     * Add an new row to the matrix, filled with 0
+     */
+    addARow(): Matrix;
+    /**
+     * Check if two matrix are equals, value by value
+     * @param mat The matrix against to check equality
+     */
+    equals(mat: Matrix): boolean;
+    /**
+     * Sets the matrix as an identity matrix
+     */
+    setAsIdentity(): this;
+    /**
+     * Gets an identity matrix (1 on diagonal)
+     * @param dimension Dimension of the squared matrix
+     */
+    static identity(dimension: number): Matrix;
+    /**
+     * Computes the product with another matrix
+     * @param mat The second operand matrix
+     * @throws Error if matrixA.columns != matrixB.rows
+     * @return A new Matrix, result of the multiplication
+     */
+    multiply(mat: Matrix): Matrix;
+    /**
+     * Computes the product with a vector
+     * @param vec The vector to multiply with
+     * @throws Error if matrix.columns != vector.rows
+     * @return A new Vector, result of the multiplication
+     */
+    multiplyVector(vec: Vector): Vector;
+    /**
+     * Get the position, from its matrix value
+     * @param value The value to search
+     * @return The position of the value, or -1 if not found
+     */
+    indexOf(value: number): [number, number];
+    /**
+     * Computes the maximum value of the matrix
+     * @return The maximum value
+     */
+    max(): number;
+    /**
+     * Computes the minimum value of the matrix
+     * @return The minimum value
+     * @throws Error if the matrix is empty
+     */
+    min(): number;
+    /**
+     * Rounds all matrix values to the nearest integer
+     * @return A new matrix with the rounded values
+     */
+    round(): Matrix;
+    /**
+     * Computes the determinant of the matrix
+     * @throws Error if the matrix is not squared
+     */
+    determinant(): number;
+    /**
+     * Gets a cofactor matrix
+     * @param row The row to omit in the matrix
+     * @param col The column to omit in the matrix
+     * @return The cofactor matrix sized (r-1)x(c-1)
+     */
+    getCofactor(row: number, col: number): Matrix;
+    /**
+     * Computes a transposed the matrix
+     * @return A new matrix sized (columns) x (rows)
+     */
+    transpose(): Matrix;
+    /**
+     * Computes the inversed matrix
+     * @return A new matrix inversed
+     */
+    inverse(): Matrix;
+    toString(): string;
+}

package/dist/core/ts-matrix/Matrix.js

@@ -0,0 +1,243 @@
+import Vector from './Vector';
+export default class Matrix {
+    /** Number of rows of the matrix */
+    _rows;
+    /** Number of columns of the matrix */
+    _columns;
+    /** Values of the matrix as a two dimensional array */
+    _values;
+    constructor(rows, columns, values) {
+        this._rows = Math.max(rows, 1);
+        this._columns = Math.max(columns, 1);
+        // Create matrix filled with 0 by default
+        this._values = new Array(this._rows)
+            .fill([])
+            .map(() => new Array(this._columns).fill(0));
+        if (values) {
+            this.values = values;
+        }
+    }
+    get rows() {
+        return this._rows;
+    }
+    get columns() {
+        return this._columns;
+    }
+    get values() {
+        return this._values;
+    }
+    /**
+     * Set values into the matrix.
+     * If the parameters matrix is to wide, the values are cropped to the current matrix size.
+     * It the parameters matrix is to small, remaining cells will be filled with 0.
+     * @param newValues Arrays of new values.
+     */
+    set values(newValues) {
+        const minRow = Math.min(newValues.length, this.rows);
+        const minCol = Math.min(newValues[0].length, this.columns);
+        for (let r = 0; r < minRow; r++) {
+            for (let c = 0; c < minCol; c++) {
+                this.values[r][c] = newValues[r][c];
+            }
+        }
+    }
+    /**
+     * Get a matrix value, from its position
+     * @param row Matrix line, from 0 to `rows`
+     * @param col Matric column, from 0 to `columns`
+     */
+    at(row, col) {
+        return this.values[row][col];
+    }
+    /**
+     * Sets all matrix values to 0
+     */
+    reset() {
+        this.values = this.values.map((row) => row.map(() => 0));
+    }
+    /**
+     * Add an new column to the matrix, filled with 0
+     */
+    addAColumn() {
+        return new Matrix(this.rows, this.columns + 1, this.values);
+    }
+    /**
+     * Add an new row to the matrix, filled with 0
+     */
+    addARow() {
+        return new Matrix(this.rows + 1, this.columns, this.values);
+    }
+    /**
+     * Check if two matrix are equals, value by value
+     * @param mat The matrix against to check equality
+     */
+    equals(mat) {
+        // Reduce on rows -> reduce on columns -> if a value != then false!
+        return (this.rows === mat.rows &&
+            this.columns === mat.columns &&
+            this.values.reduce(
+            // Rows
+            (eql, row, i) => eql &&
+                row.reduce(
+                // Columns (real values)
+                (eql2, val, j) => eql2 && mat.at(i, j) === val, eql), true));
+    }
+    /**
+     * Sets the matrix as an identity matrix
+     */
+    setAsIdentity() {
+        if (this.rows !== this.columns)
+            throw new Error("Dimension error! The matrix isn't squared!");
+        this.values.forEach((row, i) => {
+            row.forEach((c, j) => {
+                this.values[i][j] = i === j ? 1 : 0;
+            });
+        });
+        return this;
+    }
+    /**
+     * Gets an identity matrix (1 on diagonal)
+     * @param dimension Dimension of the squared matrix
+     */
+    static identity(dimension) {
+        if (dimension < 1)
+            throw Error('Dimension error! Matrix dimension must be positive.');
+        return new Matrix(dimension, dimension).setAsIdentity();
+    }
+    /**
+     * Computes the product with another matrix
+     * @param mat The second operand matrix
+     * @throws Error if matrixA.columns != matrixB.rows
+     * @return A new Matrix, result of the multiplication
+     */
+    multiply(mat) {
+        if (this.columns !== mat.rows)
+            throw new Error("Dimension error! The operand matrix must have the same number of rows as 'this' matrix columns!");
+        const resMatrix = new Matrix(this.rows, mat.columns);
+        resMatrix.values = resMatrix.values.map((row, i) => {
+            return row.map((val, j) => {
+                return this.values[i].reduce((sum, elm, k) => sum + elm * mat.at(k, j), 0);
+            });
+        });
+        return resMatrix;
+    }
+    /**
+     * Computes the product with a vector
+     * @param vec The vector to multiply with
+     * @throws Error if matrix.columns != vector.rows
+     * @return A new Vector, result of the multiplication
+     */
+    multiplyVector(vec) {
+        if (this.columns !== vec.rows)
+            throw new Error('Dimension error! The vector must have the same number of elements as the matrix columns!');
+        const resultValues = this.values.map((row) => {
+            return row.reduce((sum, element, index) => sum + element * vec.at(index), 0);
+        });
+        return new Vector(resultValues);
+    }
+    /**
+     * Get the position, from its matrix value
+     * @param value The value to search
+     * @return The position of the value, or -1 if not found
+     */
+    indexOf(value) {
+        for (let i = 0; i < this.rows; i++) {
+            for (let j = 0; j < this.columns; j++) {
+                if (this.values[i][j] === value)
+                    return [i, j];
+            }
+        }
+        return [-1, -1];
+    }
+    /**
+     * Computes the maximum value of the matrix
+     * @return The maximum value
+     */
+    max() {
+        return this.values.reduce((max, row) => Math.max(max, ...row), -Infinity);
+    }
+    /**
+     * Computes the minimum value of the matrix
+     * @return The minimum value
+     * @throws Error if the matrix is empty
+     */
+    min() {
+        return this.values.reduce((min, row) => Math.min(min, ...row), Infinity);
+    }
+    /**
+     * Rounds all matrix values to the nearest integer
+     * @return A new matrix with the rounded values
+     */
+    round() {
+        return new Matrix(this.rows, this.columns, this.values.map((row) => row.map((val) => Math.round(val))));
+    }
+    /**
+     * Computes the determinant of the matrix
+     * @throws Error if the matrix is not squared
+     */
+    determinant() {
+        if (this.rows !== this.columns)
+            throw new Error("Dimension error! The matrix isn't squared!");
+        if (this.rows === this.columns && this.columns === 1) {
+            return this.values[0][0];
+        }
+        let det = 0;
+        let sign = 1;
+        if (this.rows === 2) {
+            det =
+                this.values[0][0] * this.values[1][1] -
+                    this.values[1][0] * this.values[0][1];
+        }
+        else {
+            for (let i = 0; i < this.rows; i++) {
+                const minor = this.getCofactor(0, i);
+                det += sign * this.at(0, i) * minor.determinant();
+                sign = -sign;
+            }
+        }
+        return det;
+    }
+    /**
+     * Gets a cofactor matrix
+     * @param row The row to omit in the matrix
+     * @param col The column to omit in the matrix
+     * @return The cofactor matrix sized (r-1)x(c-1)
+     */
+    getCofactor(row, col) {
+        return new Matrix(this.rows - 1, this.columns - 1, this.values
+            .filter((v, i) => i !== row) // Remove the unnecessary row
+            .map((c) => c.filter((v, i) => i !== col)));
+    }
+    /**
+     * Computes a transposed the matrix
+     * @return A new matrix sized (columns) x (rows)
+     */
+    transpose() {
+        return new Matrix(this.columns, this.rows, new Array(this.columns)
+            .fill([])
+            .map((row, i) => new Array(this.rows).fill(0).map((c, j) => this.at(j, i))));
+    }
+    /**
+     * Computes the inversed matrix
+     * @return A new matrix inversed
+     */
+    inverse() {
+        if (this.rows !== this.columns)
+            throw new Error("Dimension error! The matrix isn't squared!");
+        const det = this.determinant();
+        if (det === 0)
+            throw new Error("Determinant is 0, can't compute inverse.");
+        // Get cofactor matrix: i.e. for each matrix value, get the cofactor's determinant
+        const cofactorMatrix = new Matrix(this.rows, this.columns, this.values.map((row, i) => row.map((val, j) => {
+            const sign = Math.pow(-1, i + j);
+            return sign * this.getCofactor(i, j).determinant();
+        })));
+        // Transpose it
+        const transposedCofactor = cofactorMatrix.transpose();
+        // Compute inverse of transposed / determinant on each value
+        return new Matrix(this.rows, this.columns, this.values.map((row, i) => row.map((val, j) => transposedCofactor.at(i, j) / det)));
+    }
+    toString() {
+        return `[${this.values.map((row) => `[${row.join(', ')}]`).join(',\n')}]`;
+    }
+}

package/dist/core/ts-matrix/Quat.d.ts

@@ -0,0 +1,168 @@
+import type Vector from './Vector';
+/**
+ * Class representing a Quaternion for 3D rotations
+ */
+export default class Quat {
+    /** Values of the quaternion as [x, y, z, w] */
+    private _values;
+    constructor(values?: [number, number, number, number]);
+    get values(): number[];
+    /**
+     * Set values into the quaternion.
+     * @param newValues Array of new values [x, y, z, w].
+     */
+    set values(newValues: number[]);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    get xy(): [number, number];
+    set xy(values: [number, number]);
+    get xyz(): [number, number, number];
+    set xyz(values: [number, number, number]);
+    get xyzw(): [number, number, number, number];
+    set xyzw(values: [number, number, number, number]);
+    /**
+     * Get an identity quaternion (rotation by 0 degrees)
+     * @return A new identity quaternion
+     */
+    static identity(): Quat;
+    /**
+     * Get a quaternion value at a specific index
+     * @param index Index from 0 to 3
+     * @return The value at the specified index
+     */
+    at(index: number): number;
+    /**
+     * Reset all quaternion values to 0
+     */
+    reset(): void;
+    /**
+     * Copy the quaternion to another quaternion
+     * @param dest Destination quaternion (optional)
+     * @return The destination quaternion
+     */
+    copy(dest?: Quat): Quat;
+    /**
+     * Calculate the roll angle (rotation around x-axis)
+     * @return Roll angle in radians
+     */
+    roll(): number;
+    /**
+     * Calculate the pitch angle (rotation around y-axis)
+     * @return Pitch angle in radians
+     */
+    pitch(): number;
+    /**
+     * Calculate the yaw angle (rotation around z-axis)
+     * @return Yaw angle in radians
+     */
+    yaw(): number;
+    /**
+     * Check if two quaternions are equal within a threshold
+     * @param quat The quaternion to compare against
+     * @param threshold The threshold for comparison (default: EPSILON)
+     * @return True if quaternions are equal within threshold
+     */
+    equals(quat: Quat, threshold?: number): boolean;
+    /**
+     * Set the quaternion as an identity quaternion
+     * @return This quaternion for method chaining
+     */
+    setIdentity(): Quat;
+    /**
+     * Calculate the w component based on x, y, z components
+     * @return This quaternion for method chaining
+     */
+    calculateW(): Quat;
+    /**
+     * Compute the inverse of the quaternion
+     * @return This quaternion for method chaining
+     */
+    inverse(): Quat;
+    /**
+     * Compute the conjugate of the quaternion
+     * @return This quaternion for method chaining
+     */
+    conjugate(): Quat;
+    /**
+     * Calculate the length (magnitude) of the quaternion
+     * @return The length of the quaternion
+     */
+    length(): number;
+    /**
+     * Normalize the quaternion to unit length
+     * @param dest Destination quaternion (optional)
+     * @return The normalized quaternion
+     */
+    normalize(dest?: Quat): Quat;
+    /**
+     * Add another quaternion to this quaternion
+     * @param other The quaternion to add
+     * @return This quaternion for method chaining
+     */
+    add(other: Quat): Quat;
+    /**
+     * Multiply this quaternion by another quaternion
+     * @param other The quaternion to multiply with
+     * @return This quaternion for method chaining
+     */
+    multiply(other: Quat): Quat;
+    /**
+     * Calculate the dot product of two quaternions
+     * @param q1 First quaternion
+     * @param q2 Second quaternion
+     * @return The dot product
+     */
+    static dot(q1: Quat, q2: Quat): number;
+    /**
+     * Calculate the sum of two quaternions
+     * @param q1 First quaternion
+     * @param q2 Second quaternion
+     * @return A new quaternion with the sum
+     */
+    static sum(q1: Quat, q2: Quat): Quat;
+    /**
+     * Calculate the product of two quaternions
+     * @param q1 First quaternion
+     * @param q2 Second quaternion
+     * @return A new quaternion with the product
+     */
+    static product(q1: Quat, q2: Quat): Quat;
+    /**
+     * Calculate the cross product of two quaternions
+     * @param q1 First quaternion
+     * @param q2 Second quaternion
+     * @return A new quaternion with the cross product
+     */
+    static cross(q1: Quat, q2: Quat): Quat;
+    /**
+     * Spherical linear interpolation between two quaternions with short path
+     * @param q1 First quaternion
+     * @param q2 Second quaternion
+     * @param time Interpolation parameter (0 to 1)
+     * @return A new interpolated quaternion
+     */
+    static shortMix(q1: Quat, q2: Quat, time: number): Quat;
+    /**
+     * Spherical linear interpolation between two quaternions
+     * @param q1 First quaternion
+     * @param q2 Second quaternion
+     * @param time Interpolation parameter (0 to 1)
+     * @return A new interpolated quaternion
+     */
+    static mix(q1: Quat, q2: Quat, time: number): Quat;
+    /**
+     * Create a quaternion from an axis and angle
+     * @param axis The rotation axis as a 3D vector
+     * @param angle The rotation angle in radians
+     * @return A new quaternion representing the rotation
+     * @throws Error if the axis vector is not 3D
+     */
+    static fromAxisAngle(axis: Vector, angle: number): Quat;
+    toString(): string;
+}