@immugio/three-math-extensions 0.0.4 → 0.0.5

package/types/Line3D.d.ts

@@ -0,0 +1,151 @@
+import { Line3, Vector3 } from "three";
+import { Vec3 } from "./Vec3";
+import { Point3 } from "./Point3";
+import { Line2D } from "./Line2D";
+export declare class Line3D extends Line3 {
+    #private;
+    start: Vec3;
+    end: Vec3;
+    constructor(start: Vec3, end: Vec3);
+    static fromPoints(start: Point3, end: Point3): Line3D;
+    /**
+     * Creates a polygon formed by an array of lines from points provided.
+     * The polygon will only be closed if either
+     * 1) the first and last points are the same or 2) `forceClosedPolygon` is true.
+     */
+    static fromPolygon(polygon: Point3[], forceClosedPolygon?: boolean): Line3D[];
+    /**
+     * Returns lines that are the result of clipping this line by the @other line.
+     * Clips must be parallel to this line.
+     * Clones the line, does not modify this.
+     * @param other
+     * @param parallelTolerance
+     */
+    clipLine(other: Line3D, parallelTolerance?: number): Line3D[];
+    /**
+     * Returns lines that are the result of clipping this line by the @clips.
+     * Clips must be parallel to this line.
+     * Clones the line, does not modify this.
+     * @param clips
+     * @param distanceTolerance
+     * @param parallelTolerance
+     */
+    clipLines(clips: Line3D[], distanceTolerance?: number, parallelTolerance?: number): Line3D[];
+    /**
+     * Joins a copy of this line with the @other line.
+     * Other must be parallel to this line.
+     * Returns null if there is no overlap
+     * Clones the line, does not modify this.
+     * @param other
+     * @param distanceTolerance
+     * @param parallelTolerance
+     */
+    joinLine(other: Line3D, distanceTolerance?: number, parallelTolerance?: number): Line3D;
+    /**
+     * Joins provided lines into several joined lines.
+     * Lines must be parallel for joining.
+     * @param lines
+     * @param distanceTolerance
+     * @param parallelTolerance
+     */
+    static joinLines(lines: Line3D[], distanceTolerance?: number, parallelTolerance?: number): Line3D[];
+    /**
+     * Returns true if this line section completely overlaps the @other line section.
+     * @param other
+     * @param tolerance
+     */
+    covers(other: Line3D, tolerance?: number): boolean;
+    /**
+     * Returns true if there is any overlap between this line and the @other line section.
+     * @param other
+     * @param distanceTolerance
+     * @param parallelTolerance
+     */
+    overlaps(other: Line3D, distanceTolerance?: number, parallelTolerance?: number): boolean;
+    /**
+     * Returns this line's length.
+     */
+    get length(): number;
+    /**
+     * Set the length of this line. Center and direction remain unchanged.
+     * @param length
+     */
+    setLength(length: number): this;
+    /**
+     * Returns the direction of this line.
+     */
+    get direction(): Vec3;
+    /**
+     * Returns the center of this line
+     */
+    get center(): Vec3;
+    /**
+     * Set the center of the line to the provided point. Length and direction remain unchanged.
+     * @param value
+     */
+    setCenter(value: Vector3): this;
+    /** Returns the start and end points of the line as an array. */
+    get endpoints(): Vec3[];
+    /**
+     * Check that this line section contains provided point.
+     * @param p
+     * @param tolerance
+     */
+    containsPoint(p: Vector3, tolerance?: number): boolean;
+    /**
+     * Distance from this line to provided point.
+     * @param p
+     * @param clampToLine
+     */
+    distanceToPoint(p: Vector3, clampToLine?: boolean): number;
+    /**
+     * Returns a copy of @other line, the direction of @other is reversed if needed.
+     * Returns null if lines are not parallel.
+     * @param other
+     * @param tolerance
+     */
+    getParallelLineInTheSameDirection(other: Line3D, tolerance?: number): Line3D;
+    /**
+     * Check if @other is parallel to this line.
+     * @param other
+     * @param tolerance
+     */
+    isParallelTo(other: Line3D, tolerance?: number): boolean;
+    resize(amount: number): this;
+    moveStartPoint(amount: number): Line3D;
+    moveEndPoint(amount: number): Line3D;
+    /**
+     * Returns a new line that is the projection of this line onto @other. Uses `closestPointToPoint` to find the projection.
+     * @param other
+     * @param clampToLine
+     */
+    projectOn(other: Line3D, clampToLine: boolean): Line3D;
+    /**
+     * Divides the Line3D into a number of segments of the given length.
+     * @param maxSegmentLength number
+     */
+    chunk(maxSegmentLength: number): Line3D[];
+    /**
+     * Note that this works well for moving the endpoints as it's currently used
+     * If it were to be made public, it would need to handle the situation where the point to move is in the center of the line which would require a different approach
+     */
+    private movePointOnThisLine;
+    /**
+     * Move this line by the given vector.
+     * @param p
+     */
+    translate(p: Vector3): this;
+    /**
+     * Project the line to 2D space, Y value is dropped
+     */
+    onPlan(): Line2D;
+    /**
+     * Equals with tolerance
+     */
+    equals(other: Line3D, tolerance?: number): boolean;
+    /**
+     * Deep clone of this line
+     */
+    clone(): this;
+    toString(): string;
+}

package/types/Point2.d.ts

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

package/types/Point3.d.ts

@@ -0,0 +1,5 @@
+export interface Point3 {
+    x: number;
+    y: number;
+    z: number;
+}

package/types/Vec2.d.ts

@@ -0,0 +1,8 @@
+import { Vector2 } from "three";
+import { Vec3 } from "./Vec3";
+import { Point2 } from "./Point2";
+export declare class Vec2 extends Vector2 {
+    static fromPoint(point: Point2): Vec2;
+    roundIfCloseToInteger(max?: number): this;
+    in3DSpace(z?: number): Vec3;
+}

package/types/Vec3.d.ts

@@ -0,0 +1,17 @@
+import { Vector3 } from "three";
+import { Vec2 } from "./Vec2";
+import { Point3 } from "./Point3";
+export declare class Vec3 extends Vector3 {
+    #private;
+    static fromPoint(point: Point3): Vec3;
+    moveTowards(target: Vector3, amount: number): Vec3;
+    centerTowards(target: Vector3): Vec3;
+    addY(y: number): Vec3;
+    addX(x: number): Vec3;
+    scale(p: Vector3): Vec3;
+    closest(...points: Vector3[]): Vec3;
+    toPointWithFlippedYZ(): Vec3;
+    onPlan(): Vec2;
+    horizontalDistanceTo(point: Vector3): number;
+    clone(): this;
+}

package/types/index.d.ts

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

package/.github/workflows/build.yml

@@ -1,28 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [16.x]
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-
-        with:
-          node-version: ${{ matrix.node-version }}
-      - run: npm ci
-      - run: npm run build --if-present
-      - run: npm test

package/.github/workflows/publish.yml

@@ -1,51 +0,0 @@
-name: Publish to NPM
-
-on:
-  push:
-    tags:
-      - '[0-9]+.[0-9]+.[0-9]+'
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [16.x]
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v1
-        with:
-          node-version: ${{ matrix.node-version }}
-      - uses: actions/cache@v2
-        with:
-          path: node_modules
-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
-
-      - name: Install Dependencies
-        run: npm install
-
-      - name: Building
-        run: npm run build
-
-      - name: Publish to NPM
-        run: |
-          npm config set //registry.npmjs.org/:_authToken=$NODE_AUTH_TOKEN
-          npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}
-      - name: Package lib
-        run: npm pack
-
-      - name: Release
-        uses: docker://antonyurchenko/git-release:v3
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          ALLOW_EMPTY_CHANGELOG: "false"
-          ALLOW_TAG_PREFIX: "true"
-        with:
-          args: |
-            three-math-extensions-*.tgz