@immugio/three-math-extensions 0.0.11 → 0.0.13

package/src/Point2.ts

@@ -1,4 +1,4 @@
-export interface Point2 {
-    x: number,
-    y: number,
+export interface Point2 {
+    x: number,
+    y: number,
 }

package/src/Point3.ts

@@ -1,6 +1,6 @@
-export interface Point3 {
-    x: number,
-    y: number,
-    z: number
-}
-
+export interface Point3 {
+    x: number,
+    y: number,
+    z: number
+}
+

package/src/Vec2.ts

@@ -1,38 +1,66 @@
-import { Vector2 } from "three";
-import { Vec3 } from "./Vec3";
-import { Point2 } from "./Point2";
-
-export class Vec2 extends Vector2 {
-
-    public static fromPoint(point: Point2): Vec2 {
-        return new Vec2(point.x, point.y);
-    }
-
-    public moveTowards(target: Vector2, amount: number): Vec2 {
-        const move = target.clone().sub(this).normalize().multiplyScalar(amount);
-        this.add(move);
-        return this;
-    }
-
-    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);
-        }
-        return this;
-    }
-
-    public in3DSpace(z: number = 0): Vec3 {
-        return new Vec3(this.x, z, this.y);
-    }
-
-    public isNear(v: Vector2, maxDistance: number = undefined): boolean {
-        if (!maxDistance) {
-            return this.equals(v);
-        }
-
-        return this.distanceTo(v) <= maxDistance;
-    }
+import { Vector2 } from "three";
+import { Vec3 } from "./Vec3";
+import { Point2 } from "./Point2";
+
+/**
+ * Vec2 represents a 2D vector. It extends `Vector2` from the `three` 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);
+    }
+
+    /**
+     * 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): Vec2 {
+        const move = target.clone().sub(this).normalize().multiplyScalar(amount);
+        this.add(move);
+        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);
+        }
+        return this;
+    }
+
+    /**
+     * Projects this Vec2 instance to a Vec3 instance in 3D space.
+     * @param z - The z value of the new Vec3 instance.
+     * @returns A new Vec3 instance.
+     */
+    public in3DSpace(z: number = 0): Vec3 {
+        return new Vec3(this.x, z, 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;
+    }
 }

package/src/Vec3.ts

@@ -1,78 +1,78 @@
-import { Vector3 } from "three";
-import { Vec2 } from "./Vec2";
-import { Point3 } from "./Point3";
-
-export class Vec3 extends Vector3 {
-
-    #target: Vector3;
-
-    public static fromPoint(point: Point3): Vec3 {
-        return new Vec3(point.x, point.y, point.z);
-    }
-
-    public moveTowards(target: Vector3, amount: number): Vec3 {
-        if (this.#target === undefined) {
-            this.#target = new Vector3();
-        }
-
-        this.#target.copy(target);
-        this.add(this.#target.sub(this).normalize().multiplyScalar(amount));
-
-        return this;
-    }
-
-    public centerTowards(target: Vector3): Vec3 {
-        if (this.#target === undefined) {
-            this.#target = new Vector3();
-        }
-
-        return this.moveTowards(target, this.distanceTo(target) / 2);
-    }
-
-    public addY(y: number): Vec3 {
-        this.y += y;
-        return this;
-    }
-
-    public addX(x: number): Vec3 {
-        this.x += x;
-        return this;
-    }
-
-    public scale(p: Vector3): Vec3 {
-        this.x *= p.x;
-        this.y *= p.y;
-        this.z *= p.z;
-        return this;
-    }
-
-    public closest(...points: Vector3[]): Vec3 {
-        const withDistances = points.map(p => ({ point: p, distance: this.distanceTo(p) }));
-        const closest = withDistances.reduce((a, b) => a.distance < b.distance ? a : b);
-        return Vec3.fromPoint(closest.point);
-    }
-
-    public toPointWithFlippedYZ(): Vec3 {
-        return new Vec3(this.x, this.z, this.y);
-    }
-
-    public onPlan(): Vec2 {
-        return new Vec2(this.x, this.z);
-    }
-
-    public horizontalDistanceTo(point: Vector3): number {
-        return new Vector3(this.x, 0, this.z).distanceTo(new Vector3(point.x, 0, point.z));
-    }
-
-    public isNear(v: Vector3, maxDistance: number = undefined): boolean {
-        if (maxDistance === undefined) {
-            return this.equals(v);
-        }
-
-        return this.distanceTo(v) <= maxDistance;
-    }
-
-    public clone(): this {
-        return super.clone();
-    }
+import { Vector3 } from "three";
+import { Vec2 } from "./Vec2";
+import { Point3 } from "./Point3";
+
+export class Vec3 extends Vector3 {
+
+    #target: Vector3;
+
+    public static fromPoint(point: Point3): Vec3 {
+        return new Vec3(point.x, point.y, point.z);
+    }
+
+    public moveTowards(target: Vector3, amount: number): Vec3 {
+        if (this.#target === undefined) {
+            this.#target = new Vector3();
+        }
+
+        this.#target.copy(target);
+        this.add(this.#target.sub(this).normalize().multiplyScalar(amount));
+
+        return this;
+    }
+
+    public centerTowards(target: Vector3): Vec3 {
+        if (this.#target === undefined) {
+            this.#target = new Vector3();
+        }
+
+        return this.moveTowards(target, this.distanceTo(target) / 2);
+    }
+
+    public addY(y: number): Vec3 {
+        this.y += y;
+        return this;
+    }
+
+    public addX(x: number): Vec3 {
+        this.x += x;
+        return this;
+    }
+
+    public scale(p: Vector3): Vec3 {
+        this.x *= p.x;
+        this.y *= p.y;
+        this.z *= p.z;
+        return this;
+    }
+
+    public closest(...points: Vector3[]): Vec3 {
+        const withDistances = points.map(p => ({ point: p, distance: this.distanceTo(p) }));
+        const closest = withDistances.reduce((a, b) => a.distance < b.distance ? a : b);
+        return Vec3.fromPoint(closest.point);
+    }
+
+    public toPointWithFlippedYZ(): Vec3 {
+        return new Vec3(this.x, this.z, this.y);
+    }
+
+    public onPlan(): Vec2 {
+        return new Vec2(this.x, this.z);
+    }
+
+    public horizontalDistanceTo(point: Vector3): number {
+        return new Vector3(this.x, 0, this.z).distanceTo(new Vector3(point.x, 0, point.z));
+    }
+
+    public isNear(v: Vector3, maxDistance: number = undefined): boolean {
+        if (maxDistance === undefined) {
+            return this.equals(v);
+        }
+
+        return this.distanceTo(v) <= maxDistance;
+    }
+
+    public clone(): this {
+        return super.clone();
+    }
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-export { Vec2 } from "./Vec2";
-export { Vec3 } from "./Vec3";
-export { Line2D } from "./Line2D";
+export { Vec2 } from "./Vec2";
+export { Vec3 } from "./Vec3";
+export { Line2D } from "./Line2D";
 export { Line3D } from "./Line3D";