@immugio/three-math-extensions 0.3.4 → 0.3.6

package/src/Rectangle.ts

@@ -1,93 +1,93 @@
-import { Polygon } from "./Polygon";
-import { Vec2 } from "./Vec2";
-import { Point2 } from "./Point2";
-
-export class Rectangle {
-
-    constructor(public leftX: number, public rightX: number, public topY: number, public bottomY: number) { }
-
-    public clone(): Rectangle {
-        return new Rectangle(this.leftX, this.rightX, this.topY, this.bottomY);
-    }
-
-    public get size(): Vec2 {
-        return new Vec2(
-            this.rightX - this.leftX,
-            this.topY - this.bottomY
-        );
-    }
-
-    public get center(): Vec2 {
-        return new Vec2(
-            (this.leftX + this.rightX) / 2,
-            (this.topY + this.bottomY) / 2
-        );
-    }
-
-    public get offset(): Vec2 {
-        return new Vec2(
-            (this.leftX + this.rightX) / -2,
-            (this.topY + this.bottomY) / -2
-        );
-    }
-
-    public overlaps(other: Rectangle): boolean {
-        // Proof is by contradiction. Any one of four conditions guarantees that NO OVERLAP CAN EXIST.
-        const result = this.bottomY >= other.topY || this.topY <= other.bottomY || this.rightX <= other.leftX || this.leftX >= other.rightX;
-
-        return !result;
-    }
-
-    public get hasSize(): boolean {
-        return this.rightX - this.leftX > 1 && this.topY - this.bottomY > 1;
-    }
-
-    public translate(diff: Point2): Rectangle {
-        this.leftX += diff.x;
-        this.rightX += diff.x;
-        this.topY += diff.y;
-        this.bottomY += diff.y;
-
-        return this;
-    }
-
-    public centerOnOrigin(): Rectangle {
-        const center = this.center;
-        this.leftX -= center.x;
-        this.rightX -= center.x;
-        this.topY -= center.y;
-        this.bottomY -= center.y;
-
-        return this;
-    }
-
-    public toPolygon(): Polygon {
-        return new Polygon(this.toPoints());
-    }
-
-    /**
-     * The polygon is always constructed as "clockwise", assuming X axis to the right and Y axis down.
-     */
-    public toPoints(): Vec2[] {
-        return [
-            new Vec2(this.leftX, Math.min(this.topY, this.bottomY)),
-            new Vec2(this.rightX, Math.min(this.topY, this.bottomY)),
-            new Vec2(this.rightX, Math.max(this.topY, this.bottomY)),
-            new Vec2(this.leftX, Math.max(this.topY, this.bottomY)),
-        ];
-    }
-
-    public flipVertical(xCenter: number): Rectangle {
-        const left = xCenter - (this.rightX - xCenter);
-        const right = xCenter - (this.leftX - xCenter);
-
-        this.leftX = left;
-        this.rightX = right;
-
-        return this;
-    }
-
-    public equals(other: Rectangle): boolean {
-        return !!other && this.leftX === other.leftX && this.rightX === other.rightX && this.topY === other.topY && this.bottomY === other.bottomY;
-    }
+import { Polygon } from "./Polygon";
+import { Vec2 } from "./Vec2";
+import { Point2 } from "./Point2";
+
+export class Rectangle {
+
+    constructor(public leftX: number, public rightX: number, public topY: number, public bottomY: number) { }
+
+    public clone(): Rectangle {
+        return new Rectangle(this.leftX, this.rightX, this.topY, this.bottomY);
+    }
+
+    public get size(): Vec2 {
+        return new Vec2(
+            this.rightX - this.leftX,
+            this.topY - this.bottomY
+        );
+    }
+
+    public get center(): Vec2 {
+        return new Vec2(
+            (this.leftX + this.rightX) / 2,
+            (this.topY + this.bottomY) / 2
+        );
+    }
+
+    public get offset(): Vec2 {
+        return new Vec2(
+            (this.leftX + this.rightX) / -2,
+            (this.topY + this.bottomY) / -2
+        );
+    }
+
+    public overlaps(other: Rectangle): boolean {
+        // Proof is by contradiction. Any one of four conditions guarantees that NO OVERLAP CAN EXIST.
+        const result = this.bottomY >= other.topY || this.topY <= other.bottomY || this.rightX <= other.leftX || this.leftX >= other.rightX;
+
+        return !result;
+    }
+
+    public get hasSize(): boolean {
+        return this.rightX - this.leftX > 1 && this.topY - this.bottomY > 1;
+    }
+
+    public translate(diff: Point2): Rectangle {
+        this.leftX += diff.x;
+        this.rightX += diff.x;
+        this.topY += diff.y;
+        this.bottomY += diff.y;
+
+        return this;
+    }
+
+    public centerOnOrigin(): Rectangle {
+        const center = this.center;
+        this.leftX -= center.x;
+        this.rightX -= center.x;
+        this.topY -= center.y;
+        this.bottomY -= center.y;
+
+        return this;
+    }
+
+    public toPolygon(): Polygon {
+        return new Polygon(this.toPoints());
+    }
+
+    /**
+     * The polygon is always constructed as "clockwise", assuming X axis to the right and Y axis down.
+     */
+    public toPoints(): Vec2[] {
+        return [
+            new Vec2(this.leftX, Math.min(this.topY, this.bottomY)),
+            new Vec2(this.rightX, Math.min(this.topY, this.bottomY)),
+            new Vec2(this.rightX, Math.max(this.topY, this.bottomY)),
+            new Vec2(this.leftX, Math.max(this.topY, this.bottomY)),
+        ];
+    }
+
+    public flipVertical(xCenter: number): Rectangle {
+        const left = xCenter - (this.rightX - xCenter);
+        const right = xCenter - (this.leftX - xCenter);
+
+        this.leftX = left;
+        this.rightX = right;
+
+        return this;
+    }
+
+    public equals(other: Rectangle): boolean {
+        return !!other && this.leftX === other.leftX && this.rightX === other.rightX && this.topY === other.topY && this.bottomY === other.bottomY;
+    }
 }

package/src/Size2.ts

@@ -1,4 +1,4 @@
-export class Size2 {
-    constructor(public width: number, public height: number) {
-    }
+export class Size2 {
+    constructor(public width: number, public height: number) {
+    }
 }

package/src/Vec2.ts

@@ -1,125 +1,125 @@
-import { Vector2 } from "three";
-import { Vec3 } from "./Vec3";
-import { Point2 } from "./Point2";
-import { normalizeAngleRadians } from "./normalizeAngleRadians";
-
-/**
- * Vec2 represents a 2D vector. It extends `Vector2` from the `threejs` library.
- */
-export class Vec2 extends Vector2 {
-
-    /**
-     * Creates a new Vec2 instance from an {x, y} object.
-     * @param point - The {x, y} instance.
-     * @returns A new Vec2 instance.
-     */
-    public static fromPoint(point: Point2): Vec2 {
-        return new Vec2(point?.x, point?.y);
-    }
-
-    /**
-     * Creates a new Vec2[] array from arguments of {x, y} objects.
-      * @param points - The ...{x, y} instances.
-     */
-    public static fromPoints(...points: Point2[]): Vec2[] {
-        return points?.map(p => Vec2.fromPoint(p)) ?? [];
-    }
-
-    /**
-     * Moves this Vec2 instance towards the target Vec2 by the given amount.
-     * @param target - The target Vec2.
-     * @param amount - The distance to move.
-     * @returns This Vec2 instance.
-     */
-    public moveTowards(target: Vector2, amount: number): this {
-        const move = target.clone().sub(this).normalize().multiplyScalar(amount);
-        this.add(move);
-        return this;
-    }
-
-    /**
-     * Adds y amount to this Vec3 instance and return this
-     * @param y
-     */
-    public addY(y: number): this {
-        this.y += y;
-        return this;
-    }
-
-    /**
-     * Adds x amount to this Vec3 instance and return this
-     * @param x
-     */
-    public addX(x: number): this {
-        this.x += x;
-        return this;
-    }
-
-    /**
-     * Rounds the x and y values of this Vec2 instance if they are close to an integer value.
-     * @param max - The maximum difference between the value and the nearest integer.
-     * @returns This Vec2 instance.
-     */
-    public roundIfCloseToInteger(max: number = 0.000000000001): this {
-        if (Math.abs(this.x - Math.round(this.x)) < max) {
-            this.x = Math.round(this.x);
-        }
-        if (Math.abs(this.y - Math.round(this.y)) < max) {
-            this.y = Math.round(this.y);
-        }
-        if (Object.is(this.x, -0)) {
-            this.x = 0;
-        }
-        if (Object.is(this.y, -0)) {
-            this.y = 0;
-        }
-        return this;
-    }
-
-    /**
-     * Projects this Vec2 instance to a Vec3 instance in 3D space. Vec2.y becomes Vec3.z. and Vec3.y is provided as an argument.
-     * @param y - The y value of the new Vec3 instance.
-     * @returns A new Vec3 instance.
-     */
-    public in3DSpace(y: number = 0): Vec3 {
-        return new Vec3(this.x, y, this.y);
-    }
-
-    /**
-     * Determines if this Vec2 instance is near the target Vec2.
-     * maxDistance is the maximum distance between the two vectors within which they are considered `near`.
-     */
-    public isNear(v: Vector2, maxDistance: number = undefined): boolean {
-        if (!maxDistance) {
-            return this.equals(v);
-        }
-
-        return this.distanceTo(v) <= maxDistance;
-    }
-
-    /**
-     * Returns the angle between this vector and positive x-axis, the return value is between 0 and 2PI
-     */
-    public signedAngle(): number {
-        const signed_angle = Math.atan2(this.y, this.x) - Math.atan2(0, 1);
-        return normalizeAngleRadians(signed_angle);
-    }
-
-    /**
-     * check if the angle between the two vectors is close enough to 0 or 180 degrees (same or opposite direction) within the given tolerance
-     * @param other Vector2
-     * @param toleranceRadians number angle tolerance in radians
-     */
-    public parallelTo(other: Vector2, toleranceRadians: number = 0): boolean {
-        const v1 = this.clone().normalize(); // Normalize both vectors to remove magnitude influence
-        const v2 = other.clone().normalize();
-
-        const dotProduct = v1.dot(v2); // Calculate the dot product to find the cosine of the angle between the vectors
-
-        // Calculate the angle in radians
-        const angle = Math.acos(dotProduct);
-
-        // Check if the angle is within the tolerance of 0 or 180 degrees (Math.PI)
-        return Math.abs(angle) <= toleranceRadians || Math.abs(angle - Math.PI) <= toleranceRadians;
-    }
+import { Vector2 } from "three";
+import { Vec3 } from "./Vec3";
+import { Point2 } from "./Point2";
+import { normalizeAngleRadians } from "./normalizeAngleRadians";
+
+/**
+ * Vec2 represents a 2D vector. It extends `Vector2` from the `threejs` library.
+ */
+export class Vec2 extends Vector2 {
+
+    /**
+     * Creates a new Vec2 instance from an {x, y} object.
+     * @param point - The {x, y} instance.
+     * @returns A new Vec2 instance.
+     */
+    public static fromPoint(point: Point2): Vec2 {
+        return new Vec2(point?.x, point?.y);
+    }
+
+    /**
+     * Creates a new Vec2[] array from arguments of {x, y} objects.
+      * @param points - The ...{x, y} instances.
+     */
+    public static fromPoints(...points: Point2[]): Vec2[] {
+        return points?.map(p => Vec2.fromPoint(p)) ?? [];
+    }
+
+    /**
+     * Moves this Vec2 instance towards the target Vec2 by the given amount.
+     * @param target - The target Vec2.
+     * @param amount - The distance to move.
+     * @returns This Vec2 instance.
+     */
+    public moveTowards(target: Vector2, amount: number): this {
+        const move = target.clone().sub(this).normalize().multiplyScalar(amount);
+        this.add(move);
+        return this;
+    }
+
+    /**
+     * Adds y amount to this Vec3 instance and return this
+     * @param y
+     */
+    public addY(y: number): this {
+        this.y += y;
+        return this;
+    }
+
+    /**
+     * Adds x amount to this Vec3 instance and return this
+     * @param x
+     */
+    public addX(x: number): this {
+        this.x += x;
+        return this;
+    }
+
+    /**
+     * Rounds the x and y values of this Vec2 instance if they are close to an integer value.
+     * @param max - The maximum difference between the value and the nearest integer.
+     * @returns This Vec2 instance.
+     */
+    public roundIfCloseToInteger(max: number = 0.000000000001): this {
+        if (Math.abs(this.x - Math.round(this.x)) < max) {
+            this.x = Math.round(this.x);
+        }
+        if (Math.abs(this.y - Math.round(this.y)) < max) {
+            this.y = Math.round(this.y);
+        }
+        if (Object.is(this.x, -0)) {
+            this.x = 0;
+        }
+        if (Object.is(this.y, -0)) {
+            this.y = 0;
+        }
+        return this;
+    }
+
+    /**
+     * Projects this Vec2 instance to a Vec3 instance in 3D space. Vec2.y becomes Vec3.z. and Vec3.y is provided as an argument.
+     * @param y - The y value of the new Vec3 instance.
+     * @returns A new Vec3 instance.
+     */
+    public in3DSpace(y: number = 0): Vec3 {
+        return new Vec3(this.x, y, this.y);
+    }
+
+    /**
+     * Determines if this Vec2 instance is near the target Vec2.
+     * maxDistance is the maximum distance between the two vectors within which they are considered `near`.
+     */
+    public isNear(v: Vector2, maxDistance: number = undefined): boolean {
+        if (!maxDistance) {
+            return this.equals(v);
+        }
+
+        return this.distanceTo(v) <= maxDistance;
+    }
+
+    /**
+     * Returns the angle between this vector and positive x-axis, the return value is between 0 and 2PI
+     */
+    public signedAngle(): number {
+        const signed_angle = Math.atan2(this.y, this.x) - Math.atan2(0, 1);
+        return normalizeAngleRadians(signed_angle);
+    }
+
+    /**
+     * check if the angle between the two vectors is close enough to 0 or 180 degrees (same or opposite direction) within the given tolerance
+     * @param other Vector2
+     * @param toleranceRadians number angle tolerance in radians
+     */
+    public parallelTo(other: Vector2, toleranceRadians: number = 0): boolean {
+        const v1 = this.clone().normalize(); // Normalize both vectors to remove magnitude influence
+        const v2 = other.clone().normalize();
+
+        const dotProduct = v1.dot(v2); // Calculate the dot product to find the cosine of the angle between the vectors
+
+        // Calculate the angle in radians
+        const angle = Math.acos(dotProduct);
+
+        // Check if the angle is within the tolerance of 0 or 180 degrees (Math.PI)
+        return Math.abs(angle) <= toleranceRadians || Math.abs(angle - Math.PI) <= toleranceRadians;
+    }
 }