chili3d 0.6.1

package/packages/chili-core/src/math/plane.ts

@@ -0,0 +1,96 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Serializer } from "../serialize";
+import type { Line } from "./line";
+import { MathUtils } from "./mathUtils";
+import type { Matrix4 } from "./matrix4";
+import type { Ray } from "./ray";
+import { XYZ } from "./xyz";
+
+@Serializer.register(["origin", "normal", "xvec"])
+export class Plane {
+    static readonly XY: Plane = new Plane(XYZ.zero, XYZ.unitZ, XYZ.unitX);
+    static readonly YZ: Plane = new Plane(XYZ.zero, XYZ.unitX, XYZ.unitY);
+    static readonly ZX: Plane = new Plane(XYZ.zero, XYZ.unitY, XYZ.unitZ);
+
+    @Serializer.serialze()
+    readonly origin: XYZ;
+    /**
+     * unit vector
+     */
+    @Serializer.serialze()
+    readonly normal: XYZ;
+    @Serializer.serialze()
+    readonly xvec: XYZ;
+    readonly yvec: XYZ;
+    constructor(origin: XYZ, normal: XYZ, xvec: XYZ) {
+        this.origin = origin;
+        const n = normal.normalize(),
+            x = xvec.normalize();
+        if (n === undefined || n.isEqualTo(XYZ.zero)) {
+            throw new Error("normal can not be zero");
+        }
+        if (x === undefined || x.isEqualTo(XYZ.zero)) {
+            throw new Error("xDirector can not be zero");
+        }
+        if (n.isParallelTo(x)) {
+            throw new Error("xDirector can not parallel normal");
+        }
+        this.normal = n;
+        this.xvec = x;
+        this.yvec = n.cross(x).normalize()!;
+    }
+
+    translateTo(origin: XYZ) {
+        return new Plane(origin, this.normal, this.xvec);
+    }
+
+    project(point: XYZ): XYZ {
+        const vector = point.sub(this.origin);
+        const dot = vector.dot(this.normal);
+        return this.origin.add(vector.sub(this.normal.multiply(dot)));
+    }
+
+    transformed(matrix: Matrix4) {
+        const location = matrix.ofPoint(this.origin);
+        const x = matrix.ofVector(this.xvec);
+        const normal = matrix.ofVector(this.normal);
+        return new Plane(location, normal, x);
+    }
+
+    intersectLine(line: Line): XYZ | undefined {
+        const t = this.lineIntersectParameter(line);
+        if (t === undefined) return undefined;
+
+        return line.point.add(line.direction.multiply(t));
+    }
+
+    intersectRay(ray: Ray): XYZ | undefined {
+        const t = this.lineIntersectParameter(ray);
+        if (t === undefined || t < 0) return undefined;
+
+        return ray.point.add(ray.direction.multiply(t));
+    }
+
+    private lineIntersectParameter(line: { point: XYZ; direction: XYZ }) {
+        const vec = this.origin.sub(line.point);
+        if (vec.isEqualTo(XYZ.zero)) {
+            return 0;
+        }
+
+        const len = vec.dot(this.normal);
+        const dot = line.direction.dot(this.normal); // line parallel to plane
+        if (MathUtils.almostEqual(dot, 0)) {
+            return MathUtils.almostEqual(len, 0) ? 0 : undefined;
+        }
+
+        return len / dot;
+    }
+
+    projectDistance(p1: XYZ, p2: XYZ) {
+        const dp1 = this.project(p1);
+        const dp2 = this.project(p2);
+        return dp1.distanceTo(dp2);
+    }
+}

package/packages/chili-core/src/math/planeAngle.ts

@@ -0,0 +1,53 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Precision } from "../foundation";
+import type { Plane } from "./plane";
+import type { XYZ } from "./xyz";
+
+export class PlaneAngle {
+    private lastX: number = 1;
+    private lastY: number = 0;
+    private isNegativeRotation: boolean = false;
+    private currentAngle: number = 0;
+
+    get angle() {
+        return this.currentAngle;
+    }
+
+    constructor(readonly plane: Plane) {}
+
+    movePoint(point: XYZ) {
+        const vectorToPoint = point.sub(this.plane.origin);
+        const projectionX = vectorToPoint.dot(this.plane.xvec);
+        const projectionY = vectorToPoint.dot(this.plane.yvec);
+
+        if (this.isCrossingPositiveXAxis(projectionX, projectionY)) {
+            this.isNegativeRotation = !this.isNegativeRotation;
+        }
+
+        this.currentAngle = this.calculateAngle(vectorToPoint);
+        this.updateLastProjections(projectionX, projectionY);
+    }
+
+    private calculateAngle(vector: XYZ): number {
+        const angleInRadians = this.plane.xvec.angleOnPlaneTo(vector, this.plane.normal)!;
+        const angleInDegrees = (angleInRadians * 180) / Math.PI;
+        return this.isNegativeRotation ? angleInDegrees - 360 : angleInDegrees;
+    }
+
+    private isCrossingPositiveXAxis(x: number, y: number): boolean {
+        const isMovingUpward = this.lastY < -Precision.Distance && y > Precision.Distance;
+        const isMovingDownward = this.lastY > -Precision.Distance && y < -Precision.Distance;
+        const isCrossingX =
+            (isMovingUpward && this.currentAngle < Precision.Angle) ||
+            (isMovingDownward && this.currentAngle > -Precision.Angle);
+
+        return isCrossingX && this.lastX > 0 && x > 0;
+    }
+
+    private updateLastProjections(x: number, y: number) {
+        if (Math.abs(x) > Precision.Distance) this.lastX = x;
+        if (Math.abs(y) > Precision.Distance) this.lastY = y;
+    }
+}

package/packages/chili-core/src/math/quaternion.ts

@@ -0,0 +1,131 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { XYZ, type XYZLike } from "./xyz";
+
+export class Quaternion {
+    readonly w: number;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    constructor(w = 1, x = 0, y = 0, z = 0) {
+        this.w = w;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    static fromAxisAngle(axis: XYZLike, rad: number): Quaternion {
+        const sin = Math.sin(rad * 0.5);
+        const cos = Math.cos(rad * 0.5);
+        return new Quaternion(cos, axis.x * sin, axis.y * sin, axis.z * sin);
+    }
+
+    conjugate(): Quaternion {
+        return new Quaternion(this.w, -this.x, -this.y, -this.z);
+    }
+
+    invert(): Quaternion {
+        return this.conjugate();
+    }
+
+    rotateVector(vec3: XYZLike): XYZ {
+        const q = new Quaternion(0, vec3.x, vec3.y, vec3.z);
+        const r = this.multiply(q).multiply(this.conjugate());
+        return new XYZ(r.x, r.y, r.z);
+    }
+
+    toAxes() {
+        const { x, y, z, w } = this;
+        const x2 = x + x;
+        const y2 = y + y;
+        const z2 = z + z;
+        const xx = x * x2;
+        const xy = x * y2;
+        const xz = x * z2;
+        const yy = y * y2;
+        const yz = y * z2;
+        const zz = z * z2;
+        const wx = w * x2;
+        const wy = w * y2;
+        const wz = w * z2;
+        return [
+            1.0 - (yy + zz),
+            xy + wz,
+            xz - wy,
+            0.0,
+            xy - wz,
+            1.0 - (xx + zz),
+            yz + wx,
+            0.0,
+            xz + wy,
+            yz - wx,
+            1.0 - (xx + yy),
+            0.0,
+        ];
+    }
+
+    add(q: Quaternion): Quaternion {
+        return new Quaternion(this.w + q.w, this.x + q.x, this.y + q.y, this.z + q.z);
+    }
+    subtract(q: Quaternion): Quaternion {
+        return new Quaternion(this.w - q.w, this.x - q.x, this.y - q.y, this.z - q.z);
+    }
+    multiply(q: Quaternion): Quaternion {
+        const { w: w1, x: x1, y: y1, z: z1 } = this;
+        const { w: w2, x: x2, y: y2, z: z2 } = q;
+
+        return new Quaternion(
+            w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2,
+            w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,
+            w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2,
+            w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2,
+        );
+    }
+    toEuler(): { x: number; y: number; z: number } {
+        const sig = 0.499;
+        const [qw, qx, qy, qz] = [this.w, this.x, this.y, this.z];
+        const [sqw, sqx, sqy, sqz] = [qw * qw, qx * qx, qy * qy, qz * qz];
+        const unit = sqx + sqz + sqy + sqw;
+        const test = qx * qz + qy * qw;
+        if (test > sig * unit) {
+            return {
+                x: 0,
+                y: Math.PI / 4,
+                z: Math.atan2(qx, qw) * 2,
+            };
+        } else if (test < -sig * unit) {
+            return {
+                x: 0,
+                y: -Math.PI / 4,
+                z: Math.atan2(qx, qw) * 2,
+            };
+        } else {
+            return {
+                x: Math.atan2(2 * (-qy * qz + qx * qw), 1 - 2 * (sqx + sqy)),
+                y: Math.asin(2 * (qx * qz + qy * qw)),
+                z: Math.atan2(2 * (-qx * qy + qz * qw), 1 - 2 * (sqy + sqz)),
+            };
+        }
+    }
+
+    static fromEuler(roll: number, pitch: number, yaw: number): Quaternion {
+        const halfRoll = roll * 0.5;
+        const halfPitch = pitch * 0.5;
+        const halfYaw = yaw * 0.5;
+
+        const cr = Math.cos(halfRoll);
+        const sr = Math.sin(halfRoll);
+        const cp = Math.cos(halfPitch);
+        const sp = Math.sin(halfPitch);
+        const cy = Math.cos(halfYaw);
+        const sy = Math.sin(halfYaw);
+
+        return new Quaternion(
+            -sr * sp * sy + cr * cp * cy,
+            sr * cp * cy + cr * sp * sy,
+            -sr * cp * sy + cr * sp * cy,
+            cr * cp * sy + sr * sp * cy,
+        );
+    }
+}

package/packages/chili-core/src/math/ray.ts

@@ -0,0 +1,30 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Serializer } from "../serialize";
+import { Line } from "./line";
+import { XYZ } from "./xyz";
+
+@Serializer.register(["point", "direction"])
+export class Ray {
+    @Serializer.serialze()
+    readonly point: XYZ;
+    /**
+     * unit vector
+     */
+    @Serializer.serialze()
+    readonly direction: XYZ;
+
+    constructor(point: XYZ, direction: XYZ) {
+        this.point = point;
+        const n = direction.normalize();
+        if (n === undefined || n.isEqualTo(XYZ.zero)) {
+            throw new Error("direction can not be zero");
+        }
+        this.direction = n;
+    }
+
+    toLine(): Line {
+        return new Line(this.point, this.direction);
+    }
+}

package/packages/chili-core/src/math/xy.ts

@@ -0,0 +1,104 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Precision } from "../foundation";
+import { Serializer } from "../serialize";
+import { MathUtils } from "./mathUtils";
+
+export type XYLike = { x: number; y: number };
+
+@Serializer.register(["x", "y"])
+export class XY {
+    static readonly zero = new XY(0, 0);
+    static readonly unitX = new XY(1, 0);
+    static readonly unitY = new XY(0, 1);
+
+    @Serializer.serialze()
+    readonly x: number;
+    @Serializer.serialze()
+    readonly y: number;
+
+    constructor(x: number, y: number) {
+        this.x = x;
+        this.y = y;
+    }
+
+    cross(right: XY): number {
+        return this.x * right.y - this.y * right.x;
+    }
+
+    dot(right: XY): number {
+        return this.x * right.x + this.y * right.y;
+    }
+
+    divided(scalar: number): XY | undefined {
+        return Math.abs(scalar) < Precision.Float ? undefined : new XY(this.x / scalar, this.y / scalar);
+    }
+
+    reverse(): XY {
+        return new XY(-this.x, -this.y);
+    }
+
+    multiply(scalar: number): XY {
+        return new XY(this.x * scalar, this.y * scalar);
+    }
+
+    sub(right: XY): XY {
+        return new XY(this.x - right.x, this.y - right.y);
+    }
+
+    add(right: XY): XY {
+        return new XY(this.x + right.x, this.y + right.y);
+    }
+
+    normalize(): XY | undefined {
+        const d = this.length();
+        return d < Precision.Float ? undefined : new XY(this.x / d, this.y / d);
+    }
+
+    distanceTo(right: XY): number {
+        const dx = this.x - right.x;
+        const dy = this.y - right.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+
+    static center(p1: XY, p2: XY): XY {
+        return new XY((p1.x + p2.x) / 2, (p1.y + p2.y) / 2);
+    }
+
+    lengthSq(): number {
+        return this.x ** 2 + this.y ** 2;
+    }
+
+    length(): number {
+        return Math.sqrt(this.lengthSq());
+    }
+
+    /**
+     * Computes the angular value in radians between me and right
+     * @param right vector
+     * @returns [0, PI]
+     */
+    angleTo(right: XY): number | undefined {
+        if (this.isEqualTo(XY.zero) || right.isEqualTo(XY.zero)) return undefined;
+        // tan(x) = |a||b|sin(x) / |a||b|cos(x)
+        return Math.atan2(this.cross(right), this.dot(right));
+    }
+
+    isEqualTo(right: XY, tolerance: number = 1e-8) {
+        return (
+            MathUtils.almostEqual(this.x, right.x, tolerance) &&
+            MathUtils.almostEqual(this.y, right.y, tolerance)
+        );
+    }
+
+    isParallelTo(right: XY, tolerance: number = 1e-8): boolean | undefined {
+        const angle = this.angleTo(right);
+        return angle === undefined ? undefined : angle <= tolerance || Math.PI - angle <= tolerance;
+    }
+
+    isOppositeTo(right: XY, tolerance: number = 1e-8): boolean | undefined {
+        const angle = this.angleTo(right);
+        return angle === undefined ? undefined : Math.PI - angle <= tolerance;
+    }
+}

package/packages/chili-core/src/math/xyz.ts

@@ -0,0 +1,181 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Precision } from "../foundation";
+import { Serializer } from "../serialize";
+import { MathUtils } from "./mathUtils";
+
+export type XYZLike = { x: number; y: number; z: number };
+
+@Serializer.register(["x", "y", "z"])
+export class XYZ {
+    static readonly zero = Object.freeze(new XYZ(0, 0, 0));
+    static readonly unitX = Object.freeze(new XYZ(1, 0, 0));
+    static readonly unitY = Object.freeze(new XYZ(0, 1, 0));
+    static readonly unitZ = Object.freeze(new XYZ(0, 0, 1));
+    static readonly unitNX = Object.freeze(new XYZ(-1, 0, 0));
+    static readonly unitNY = Object.freeze(new XYZ(0, -1, 0));
+    static readonly unitNZ = Object.freeze(new XYZ(0, 0, -1));
+    static readonly one = Object.freeze(new XYZ(1, 1, 1));
+
+    @Serializer.serialze()
+    readonly x: number;
+    @Serializer.serialze()
+    readonly y: number;
+    @Serializer.serialze()
+    readonly z: number;
+
+    constructor(x: number, y: number, z: number) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    toString() {
+        return `${this.x}, ${this.y}, ${this.z}`;
+    }
+
+    toArray(): number[] {
+        return [this.x, this.y, this.z];
+    }
+
+    static fromArray(arr: number[]) {
+        if (!arr) return XYZ.zero;
+
+        const x = arr.at(0) ?? 0;
+        const y = arr.at(1) ?? 0;
+        const z = arr.at(2) ?? 0;
+        return new XYZ(x, y, z);
+    }
+
+    cross(right: XYZLike): XYZ {
+        return new XYZ(
+            this.y * right.z - this.z * right.y,
+            this.z * right.x - this.x * right.z,
+            this.x * right.y - this.y * right.x,
+        );
+    }
+
+    dot(right: XYZLike): number {
+        return this.x * right.x + this.y * right.y + this.z * right.z;
+    }
+
+    divided(scalar: number): XYZ | undefined {
+        if (Math.abs(scalar) < Precision.Float) return undefined;
+        return new XYZ(this.x / scalar, this.y / scalar, this.z / scalar);
+    }
+
+    reverse(): XYZ {
+        const x = MathUtils.almostEqual(this.x, 0) ? 0 : -this.x;
+        const y = MathUtils.almostEqual(this.y, 0) ? 0 : -this.y;
+        const z = MathUtils.almostEqual(this.z, 0) ? 0 : -this.z;
+
+        return new XYZ(x, y, z);
+    }
+
+    multiply(scalar: number): XYZ {
+        return new XYZ(this.x * scalar, this.y * scalar, this.z * scalar);
+    }
+
+    sub(right: XYZLike): XYZ {
+        return new XYZ(this.x - right.x, this.y - right.y, this.z - right.z);
+    }
+
+    add(right: XYZLike): XYZ {
+        return new XYZ(this.x + right.x, this.y + right.y, this.z + right.z);
+    }
+
+    normalize(): XYZ | undefined {
+        const d = this.length();
+        return d < Precision.Float ? undefined : new XYZ(this.x / d, this.y / d, this.z / d);
+    }
+
+    distanceTo(right: XYZLike): number {
+        const dx = this.x - right.x;
+        const dy = this.y - right.y;
+        const dz = this.z - right.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+
+    static center(p1: XYZLike, p2: XYZLike): XYZ {
+        return new XYZ((p1.x + p2.x) / 2, (p1.y + p2.y) / 2, (p1.z + p2.z) / 2);
+    }
+
+    lengthSq(): number {
+        return this.x * this.x + this.y * this.y + this.z * this.z;
+    }
+
+    length(): number {
+        return Math.sqrt(this.lengthSq());
+    }
+
+    /**
+     * Computes the angular value in radians between me and right
+     * @param right vector
+     * @returns [0, PI]
+     */
+    angleTo(right: XYZLike): number | undefined {
+        if (this.isEqualTo(XYZ.zero) || XYZ.zero.isEqualTo(right)) return undefined;
+        const cross = this.cross(right);
+        const dot = this.dot(right);
+        // tan(x) = |a||b|sin(x) / |a||b|cos(x)
+        return Math.atan2(cross.length(), dot);
+    }
+
+    /**
+     * Computes the angular value in radians between me and right on plane
+     * @param right vector
+     * @param normal plane normal
+     * @returns [0, 2PI]
+     */
+    angleOnPlaneTo(right: XYZLike, normal: XYZLike): number | undefined {
+        const angle = this.angleTo(right);
+        if (angle === undefined || XYZ.zero.isEqualTo(normal)) return undefined;
+        const vec = this.cross(right).normalize();
+        return vec?.isOppositeTo(normal) ? Math.PI * 2 - angle : angle;
+    }
+
+    /**
+     *
+     * @param normal rotate axis
+     * @param angle angular value in radians
+     * @returns
+     */
+    rotate(normal: XYZ, angle: number): XYZ | undefined {
+        const n = normal.normalize();
+        if (n === undefined) return undefined;
+        const cos = Math.cos(angle);
+        return this.multiply(cos)
+            .add(n.multiply((1 - cos) * n.dot(this)))
+            .add(n.cross(this).multiply(Math.sin(angle)));
+    }
+
+    isEqualTo(right: XYZLike, tolerance: number = 1e-6) {
+        return (
+            MathUtils.almostEqual(this.x, right.x, tolerance) &&
+            MathUtils.almostEqual(this.y, right.y, tolerance) &&
+            MathUtils.almostEqual(this.z, right.z, tolerance)
+        );
+    }
+
+    isPerpendicularTo(right: XYZLike, tolerance: number = 1e-6): boolean {
+        const angle = this.angleTo(right);
+        if (angle === undefined) return false;
+
+        return Math.abs(angle - Math.PI * 0.5) < tolerance;
+    }
+
+    isParallelTo(right: XYZLike, tolerance: number = 1e-6): boolean {
+        const angle = this.angleTo(right);
+        if (angle === undefined) return false;
+
+        return Math.abs(angle) < tolerance || Math.abs(Math.PI - angle) < tolerance;
+    }
+
+    isOppositeTo(right: XYZLike, tolerance: number = 1e-6): boolean {
+        const angle = this.angleTo(right);
+        if (angle === undefined) return false;
+
+        return Math.abs(Math.PI - angle) < tolerance;
+    }
+}