@shapediver/viewer.shared.math 3.3.4 → 3.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapediver/viewer.shared.math",
-  "version": "3.3.4",
+  "version": "3.3.7",
   "description": "",
   "keywords": [],
   "author": "Michael Oppitz <michael@shapediver.com>",
@@ -10,11 +10,10 @@
     "test": "__tests__"
   },
   "files": [
-    "dist",
-    "src",
     "package.json",
+    "dist/",
     "README.md",
-    "tsconfig.json"
+    "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
@@ -39,8 +38,8 @@
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@shapediver/viewer.shared.services": "3.3.4",
+    "@shapediver/viewer.shared.services": "3.3.7",
     "gl-matrix": "3.3.0"
   },
-  "gitHead": "8193da527b4e3fc4d90181018bd60d6ac70be3e8"
+  "gitHead": "112787d5c5226cca5e89d08102d0b1a3dd4a1d71"
 }

package/src/implementation/Box.ts

@@ -1,200 +0,0 @@
-import { mat4, vec3, vec4 } from 'gl-matrix'
-import { Sphere } from '..';
-import { IBox } from '../interfaces/IBox';
-import { ISphere } from '../interfaces/ISphere';
-
-
-export class Box implements IBox {
-    // #region Properties (2)
-
-    private _boundingSphere: ISphere = new Sphere();
-    private _boundingSphereState: { min: vec3, max: vec3 } = {
-        min: vec3.create(), max: vec3.create()
-    }
-
-    // #endregion Properties (2)
-
-    // #region Constructors (1)
-    constructor(
-        private _min: vec3 = vec3.fromValues(Infinity, Infinity, Infinity),
-        private _max: vec3 = vec3.fromValues(-Infinity, -Infinity, -Infinity)
-    ) { }
-
-    // #endregion Constructors (1)
-
-    // #region Public Accessors (5)
-
-    public intersect(origin: vec3, direction: vec3): number | null {
-        let tmin, tmax, txmin, txmax, tymin, tymax, tzmin, tzmax;
-
-        const invdirx = 1 / direction[0],
-            invdiry = 1 / direction[1],
-            invdirz = 1 / direction[2];
-
-        txmin = invdirx >= 0 ? (this.min[0] - origin[0]) * invdirx : (this.max[0] - origin[0]) * invdirx;
-        txmax = invdirx >= 0 ? (this.max[0] - origin[0]) * invdirx : (this.min[0] - origin[0]) * invdirx;
-        tmin = txmin;
-        tmax = txmax;
-
-        tymin = invdiry >= 0 ? (this.min[1] - origin[1]) * invdiry : (this.max[1] - origin[1]) * invdiry;
-        tymax = invdiry >= 0 ? (this.max[1] - origin[1]) * invdiry : (this.min[1] - origin[1]) * invdiry;
-
-        if ((tmin > tymax) || (tymin > tmax)) return null;
-
-        // These lines also handle the case where tmin or tmax is NaN
-        // (result of 0 * Infinity). x !== x returns true if x is NaN
-
-        if (tymin > tmin || tmin !== tmin) tmin = tymin;
-        if (tymax < tmax || tmax !== tmax) tmax = tymax;
-
-        tzmin = invdirz >= 0 ? (this.min[2] - origin[2]) * invdirz : (this.max[2] - origin[2]) * invdirz;
-        tzmax = invdirz >= 0 ? (this.max[2] - origin[2]) * invdirz : (this.min[2] - origin[2]) * invdirz;
-
-        if ((tmin > tzmax) || (tzmin > tmax)) return null;
-        if (tzmin > tmin || tmin !== tmin) tmin = tzmin;
-        if (tzmax < tmax || tmax !== tmax) tmax = tzmax;
-
-        //return point closest to the ray (positive side)
-        if (tmax < 0) return null;
-        return tmin >= 0 ? tmin : tmax;
-    };
-
-    public intersects(origin: vec3, direction: vec3): boolean {
-        return this.intersect(origin, direction) === null ? false : true;
-    };
-
-    public get boundingSphere(): ISphere {
-        if (!(this._boundingSphereState.min[0] === this.min[0] && this._boundingSphereState.min[1] === this.min[1] && this._boundingSphereState.min[2] === this.min[2] &&
-            this._boundingSphereState.max[0] === this.max[0] && this._boundingSphereState.max[1] === this.max[1] && this._boundingSphereState.max[2] === this.max[2])) {
-            this._boundingSphere.setFromBox(this);
-            this._boundingSphereState = {
-                min: vec3.clone(this.min),
-                max: vec3.clone(this.max)
-            };
-        }
-        return this._boundingSphere;
-    }
-
-    public get max(): vec3 {
-        return this._max;
-    }
-
-    public set max(value: vec3) {
-        this._max = value;
-    }
-
-    public get min(): vec3 {
-        return this._min;
-    }
-
-    public set min(value: vec3) {
-        this._min = value;
-    }
-
-    // #endregion Public Accessors (5)
-
-    // #region Public Methods (5)
-
-    public applyMatrix(matrix: mat4): Box {
-        const points: vec3[] = [];
-        points.push(vec3.transformMat4(vec3.create(), vec3.fromValues(this.min[0], this.min[1], this.min[2]), matrix));
-        points.push(vec3.transformMat4(vec3.create(), vec3.fromValues(this.min[0], this.min[1], this.max[2]), matrix));
-        points.push(vec3.transformMat4(vec3.create(), vec3.fromValues(this.min[0], this.max[1], this.min[2]), matrix));
-        points.push(vec3.transformMat4(vec3.create(), vec3.fromValues(this.min[0], this.max[1], this.max[2]), matrix));
-        points.push(vec3.transformMat4(vec3.create(), vec3.fromValues(this.max[0], this.min[1], this.min[2]), matrix));
-        points.push(vec3.transformMat4(vec3.create(), vec3.fromValues(this.max[0], this.min[1], this.max[2]), matrix));
-        points.push(vec3.transformMat4(vec3.create(), vec3.fromValues(this.max[0], this.max[1], this.min[2]), matrix));
-        points.push(vec3.transformMat4(vec3.create(), vec3.fromValues(this.max[0], this.max[1], this.max[2]), matrix));
-
-        this.min = vec3.fromValues(Infinity, Infinity, Infinity);
-        this.max = vec3.fromValues(-Infinity, -Infinity, -Infinity);
-
-		for ( let i = 0, il = points.length; i < il; i ++ ) {
-            this.min = vec3.fromValues(Math.min(this.min[0], points[i][0]), Math.min(this.min[1], points[i][1]), Math.min(this.min[2], points[i][2]));
-            this.max = vec3.fromValues(Math.max(this.max[0], points[i][0]), Math.max(this.max[1], points[i][1]), Math.max(this.max[2], points[i][2]));
-		}
-        return this;
-    }
-
-    public clone(): IBox {
-        return new Box(vec3.clone(this.min), vec3.clone(this.max))
-    }
-
-    public containsPoint(point: vec3): boolean {
-        return point[0] < this.min[0] || point[0] > this.max[0] ||
-            point[1] < this.min[1] || point[1] > this.max[1] ||
-            point[2] < this.min[2] || point[2] > this.max[2] ? false : true;
-    }
-
-    public clampPoint(point: vec3): vec3 {
-        point[0] = Math.max(this.min[0], Math.min(this.max[0], point[0]));
-        point[1] = Math.max(this.min[1], Math.min(this.max[1], point[1]));
-        point[2] = Math.max(this.min[2], Math.min(this.max[2], point[2]));
-        return point;
-    }
-
-    public setFromAttributeArray(array: Int8Array | Uint8Array | Int16Array | Uint16Array | Uint32Array | Float32Array, stride?: number, bytes?: number, matrix?: mat4): IBox {
-        const length = (Math.floor(array.length / 3) * 3);
-        const byteStride = (stride && stride !== bytes) ? +stride : 3;
-
-        const min = [Infinity, Infinity, Infinity];
-        const max = [-Infinity, -Infinity, -Infinity];
-
-        let x, y, z;
-        const point = vec4.create();
-        for (let i = 0; i < length; i += byteStride) {
-            if(matrix) {
-                vec4.transformMat4(point, [array[i], array[i + 1], array[i + 2], 1], matrix);
-                x = point[0] / point[3];
-                y = point[1] / point[3];
-                z = point[2] / point[3];
-            } else {
-                x = array[i];
-                y = array[i + 1];
-                z = array[i + 2];
-            }
-
-            min[0] = Math.min(min[0], x);
-            min[1] = Math.min(min[1], y);
-            min[2] = Math.min(min[2], z);
-
-            max[0] = Math.max(max[0], x);
-            max[1] = Math.max(max[1], y);
-            max[2] = Math.max(max[2], z);
-        }
-
-        this.min = vec3.fromValues(min[0], min[1], min[2]);
-        this.max = vec3.fromValues(max[0], max[1], max[2]);
-        
-        return this;
-    }
-
-    public union(box: IBox): IBox {
-        if (box.min[0] < this.min[0]) this.min[0] = box.min[0];
-        if (box.min[1] < this.min[1]) this.min[1] = box.min[1];
-        if (box.min[2] < this.min[2]) this.min[2] = box.min[2];
-
-        if (box.max[0] > this.max[0]) this.max[0] = box.max[0];
-        if (box.max[1] > this.max[1]) this.max[1] = box.max[1];
-        if (box.max[2] > this.max[2]) this.max[2] = box.max[2];
-        return this;
-    }
-
-    public isEmpty(): boolean {
-        return this.min[0] === Infinity && this.min[1] === Infinity && this.min[2] === Infinity && 
-            this.max[0] === -Infinity && this.max[1] === -Infinity && this.max[2] === -Infinity;
-    }
-
-    public reset(): void {
-        vec3.zero(this._boundingSphere.center)
-        this._boundingSphere.radius = 0;
-
-        vec3.zero(this._boundingSphereState.min);
-        vec3.zero(this._boundingSphereState.max);
-
-        vec3.set(this._min, Infinity, Infinity, Infinity);
-        vec3.set(this._max, -Infinity, -Infinity, -Infinity);
-    }
-
-    // #endregion Public Methods (5)
-}

package/src/implementation/Plane.ts

@@ -1,86 +0,0 @@
-import { IPlane } from '../interfaces/IPlane';
-import { mat3, mat4, vec3 } from 'gl-matrix';
-
-export class Plane implements IPlane {
-    // #region Constructors (1)
-
-    constructor(private _normal: vec3 = vec3.fromValues(1, 0, 0), private _constant: number = 0) { }
-
-    // #endregion Constructors (1)
-
-    // #region Public Getters And Setters (4)
-
-    public get constant(): number {
-        return this._constant;
-    }
-
-    public set constant(value: number) {
-        this._constant = value;
-    }
-
-    public get normal(): vec3 {
-        return this._normal;
-    }
-
-    public set normal(value: vec3) {
-        this._normal = value;
-    }
-
-    // #endregion Public Getters And Setters (4)
-
-    // #region Public Methods (8)
-
-    public applyMatrix(matrix: mat4): IPlane {
-        let inverse = mat3.invert(mat3.create(), mat3.fromMat4(mat3.create(), matrix));
-        if (!inverse) inverse = mat3.create();
-        const normalMatrix = mat3.transpose(mat3.create(), inverse);
-        const p = vec3.transformMat4(vec3.create(), vec3.multiply(vec3.create(), vec3.clone(this.normal), vec3.fromValues(this._constant, this._constant, this._constant)), matrix);
-        this._normal = vec3.normalize(vec3.create(), vec3.transformMat3(vec3.create(), this._normal, normalMatrix));
-        this.constant = -vec3.dot(p, this._normal);
-        return this;
-    }
-
-    public clampPoint(point: vec3): vec3 {
-        const d = -this.distanceToPoint(point);
-        return vec3.add(vec3.create(), vec3.multiply(vec3.create(), this.normal, vec3.fromValues(d, d, d)), point);
-    }
-
-    public clone(): IPlane {
-        return new Plane(this._normal, this._constant);
-    }
-
-    public containsPoint(point: vec3): boolean {
-        return this.distanceToPoint(point) === 0;
-    }
-
-    public distanceToPoint(point: vec3): number {
-        return vec3.dot(this.normal, point) + this.constant;
-    }
-
-    public intersect(origin: vec3, direction: vec3): number | null {
-        const denominator = vec3.dot(this.normal, direction);
-        if (denominator === 0) {
-            // line is coplanar, return origin
-            if (this.distanceToPoint(origin) === 0) return 0;
-            // Null is preferable to undefined since undefined means.... it is undefined
-            return null;
-        }
-        const t = - (vec3.dot(origin, this.normal) + this.constant) / denominator;
-        if (t < 0) return null;
-
-        return t; //vec3.add(vec3.create(), vec3.multiply(vec3.create(), direction, vec3.fromValues(t,t,t)), origin);
-    }
-
-    public reset() {
-        this._normal = vec3.fromValues(1, 0, 0);
-        this._constant = 0;
-    }
-
-    public setFromNormalAndCoplanarPoint(normal: vec3, point: vec3): IPlane {
-        vec3.copy(this.normal, normal);
-        this.constant = -vec3.dot(point, this.normal);
-        return this;
-    }
-
-    // #endregion Public Methods (8)
-}

package/src/implementation/Sphere.ts

@@ -1,105 +0,0 @@
-import { mat4, vec3 } from 'gl-matrix'
-import { IBox } from '../interfaces/IBox';
-import { ISphere } from '../interfaces/ISphere';
-
-export class Sphere implements ISphere {
-    // #region Constructors (1)
-
-    constructor(
-        private _center: vec3 = vec3.create(),
-        private _radius: number = 0
-    ) { }
-
-    // #endregion Constructors (1)
-
-    // #region Public Accessors (4)
-
-    public get center(): vec3 {
-        return this._center;
-    }
-
-    public set center(value: vec3) {
-        this._center = value;
-    }
-
-    public get radius(): number {
-        return this._radius;
-    }
-
-    public set radius(value: number) {
-        this._radius = value;
-    }
-    
-    // #endregion Public Accessors (4)
-
-    // #region Public Methods (4)
-
-    public applyMatrix(matrix: mat4): Sphere {
-        this._center = vec3.transformMat4(vec3.create(), this._center, matrix);
-        const scaleXSq = matrix[0] * matrix[0] + matrix[1] * matrix[1] + matrix[2] * matrix[2];
-        const scaleYSq = matrix[4] * matrix[4] + matrix[5] * matrix[5] + matrix[6] * matrix[6];
-        const scaleZSq = matrix[8] * matrix[8] + matrix[9] * matrix[9] + matrix[10] * matrix[10];
-        const maxScaleOnAxis = Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq));
-        this.radius = this.radius * maxScaleOnAxis;
-        return this;
-    }
-
-    public clone(): ISphere {
-        return new Sphere(vec3.clone(this._center), this._radius);
-    }
-
-    public containsPoint(point: vec3): boolean {
-        return (vec3.squaredDistance(point, this.center) <= (this.radius * this.radius));
-    }
-
-    public clampPoint(point: vec3): vec3 {
-        return point;
-    }
-
-    public intersect(origin: vec3, direction: vec3): number | null {
-        // vector from ray origin to sphere center
-        const rayToSphere = vec3.sub(vec3.create(), this.center, origin);
-
-        // project rayToSphere onto direction
-        const projection = vec3.dot(rayToSphere, direction);
-
-        // distance from sphere center to projection
-        const distanceToProjection = vec3.squaredDistance(rayToSphere, vec3.multiply(vec3.create(), direction, vec3.fromValues(projection, projection, projection)));
-
-        // check if the distance to projection is less than the radius
-        if (distanceToProjection <= this.radius * this.radius) {
-            // calculate the distance from the origin to the intersection point
-            const distanceToIntersection = Math.sqrt(this.radius * this.radius - distanceToProjection);
-            return projection - distanceToIntersection;
-        }
-
-        // if there is no intersection, return null
-        return null;
-    }
-
-    public intersects(origin: vec3, direction: vec3): boolean {
-        // vector from ray origin to sphere center
-        const rayToSphere = vec3.sub(vec3.create(), this.center, origin);
-
-        // project rayToSphere onto direction
-        const projection = vec3.dot(rayToSphere, direction);
-
-        // distance from sphere center to projection
-        const distanceToProjection = vec3.squaredDistance(rayToSphere, vec3.multiply(vec3.create(), direction, vec3.fromValues(projection, projection, projection)));
-        return distanceToProjection <= this.radius * this.radius;
-    }
-
-    public setFromBox(box: IBox): ISphere {
-        vec3.add(this.center, box.min, box.max);
-        vec3.scale(this.center, this.center, 0.5);
-        this.radius = vec3.dist(box.min, box.max) * 0.5;
-        return this;
-    }
-
-    public reset() {
-        this._center = vec3.create();
-        this._radius = 0;
-    }
-
-    // #endregion Public Methods (4)
-}

package/src/implementation/Spherical.ts

@@ -1,61 +0,0 @@
-import { vec3 } from 'gl-matrix'
-import { ISpherical } from '../interfaces/ISpherical';
-
-export class Spherical implements ISpherical {
-    constructor(
-        private _radius: number = 1,
-        private _phi: number = 0,
-        private _theta: number = 0,
-    ) { }
-
-
-    public get radius(): number {
-        return this._radius;
-    }
-
-    public set radius(value: number) {
-        this._radius = value;
-    }
-
-
-    public get phi(): number {
-        return this._phi;
-    }
-
-    public set phi(value: number) {
-        this._phi = value;
-    }
-
-
-    public get theta(): number {
-        return this._theta;
-    }
-
-    public set theta(value: number) {
-        this._theta = value;
-    }
-
-    public makeSafe() {
-        const EPS = 0.000001;
-        this.phi = Math.max( EPS, Math.min( Math.PI - EPS, this.phi ));
-        return this;
-    }
-
-    public fromVec3(p: vec3): ISpherical {
-        this.radius = Math.sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2]);
-
-        if (this.radius === 0) {
-            this.theta = 0;
-            this.phi = 0;
-        } else {
-            this.theta = Math.atan2(p[0], p[2]);
-            this.phi = Math.acos(Math.max(-1, Math.min(1, p[1] / this.radius)));
-        }
-        return this;
-    }
-
-    public toVec3(): vec3 {
-        const sinPhiRadius = Math.sin( this.phi ) * this.radius;
-        return vec3.fromValues(sinPhiRadius * Math.sin( this.theta ), Math.cos( this.phi ) * this.radius, sinPhiRadius * Math.cos( this.theta ));
-    }
-}

package/src/implementation/Triangle.ts

@@ -1,51 +0,0 @@
-import { mat4, vec3 } from 'gl-matrix'
-import { ITriangle } from '../interfaces/ITriangle';
-
-
-export class Triangle implements ITriangle {
-    constructor(
-        private _v0: vec3 = vec3.create(),
-        private _v1: vec3 = vec3.create(),
-        private _v2: vec3 = vec3.create(),
-    ) { }
-
-    applyMatrix(matrix: mat4): ITriangle {
-        vec3.transformMat4(this._v0, this._v0, matrix);
-        vec3.transformMat4(this._v1, this._v1, matrix);
-        vec3.transformMat4(this._v2, this._v2, matrix);
-        return this;
-    }
-
-    clone(): ITriangle {
-        return new Triangle(vec3.clone(this._v0), vec3.clone(this._v1), vec3.clone(this._v2));
-    }
-
-    // Möller–Trumbore intersection algorithm
-    intersect(origin: vec3, direction: vec3): vec3 | null {
-        const EPSILON = 0.0000001;
-        const edge1 = vec3.sub(vec3.create(), this._v1, this._v0);
-        const edge2 = vec3.sub(vec3.create(), this._v2, this._v0);
-        const h = vec3.cross(vec3.create(), direction, edge2)
-        const a = vec3.dot(edge1, h);
-        if (a > -EPSILON && a < EPSILON)
-            return null;    // This ray is parallel to this triangle.
-        const f = 1.0 / a;
-        const s = vec3.sub(vec3.create(), origin, this._v0);
-        const u = f * vec3.dot(s, h);
-        if (u < 0.0 || u > 1.0)
-            return null;
-        const q = vec3.cross(vec3.create(), s, edge1);
-        const v = f * vec3.dot(direction, q);
-        if (v < 0.0 || u + v > 1.0)
-            return null;
-        // At this stage we can compute t to find out where the intersection point is on the line.
-        const t = f * vec3.dot(edge2, q);
-        return t > EPSILON ? vec3.add(vec3.create(), vec3.multiply(vec3.create(), direction, vec3.fromValues(t, t, t)), origin):null;
-    }
-
-    reset() {
-        this._v0 = vec3.create();
-        this._v1 = vec3.create();
-        this._v2 = vec3.create();    
-    }
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-import { Box } from './implementation/Box'
-import { Plane } from './implementation/Plane'
-import { Sphere } from './implementation/Sphere'
-import { Spherical } from './implementation/Spherical'
-import { Triangle } from './implementation/Triangle'
-import { IBox } from './interfaces/IBox'
-import { IGeometry } from './interfaces/IGeometry'
-import { IPlane } from './interfaces/IPlane'
-import { ISphere } from './interfaces/ISphere'
-import { ISpherical } from './interfaces/ISpherical'
-import { ITriangle } from './interfaces/ITriangle'
-
-export {
-    IBox, ISphere, ISpherical, IPlane, ITriangle, IGeometry,
-    Box, Sphere, Spherical, Plane, Triangle
-}

package/src/interfaces/IBox.ts

@@ -1,27 +0,0 @@
-import { mat4, vec3 } from "gl-matrix";
-import { IGeometry } from "./IGeometry";
-import { ISphere } from "./ISphere";
-
-export interface IBox extends IGeometry {
-    // #region Properties (3)
-
-    boundingSphere: ISphere;
-    max: vec3;
-    min: vec3;
-
-    // #endregion Properties (3)
-
-    // #region Public Methods (7)
-
-    applyMatrix(matrix: mat4): IBox;
-    clampPoint(point: vec3): vec3;
-    clone(): IBox;
-    containsPoint(point: vec3): boolean;
-    intersect(origin: vec3, direction: vec3): number | null;
-    intersects(origin: vec3, direction: vec3): boolean;
-    isEmpty(): boolean;
-    setFromAttributeArray(array: Int8Array | Uint8Array | Int16Array | Uint16Array | Uint32Array | Float32Array, stride?: number, bytes?: number, matrix?: mat4): IBox;
-    union(box: IBox): IBox;
-
-    // #endregion Public Methods (7)
-}

package/src/interfaces/IGeometry.ts

@@ -1,7 +0,0 @@
-import { mat4, vec3 } from 'gl-matrix'
-
-export interface IGeometry {
-    applyMatrix(matrix: mat4): IGeometry;
-    clone(): IGeometry;
-    reset(): void;
-}

package/src/interfaces/IPlane.ts

@@ -1,23 +0,0 @@
-import { mat4, vec3 } from "gl-matrix";
-import { IGeometry } from "./IGeometry";
-
-export interface IPlane extends IGeometry {
-    // #region Properties (2)
-
-    constant: number;
-    normal: vec3;
-
-    // #endregion Properties (2)
-
-    // #region Public Methods (6)
-
-    applyMatrix(matrix: mat4): IPlane;
-    clampPoint(point: vec3): vec3;
-    clone(): IPlane;
-    containsPoint(point: vec3): boolean;
-    distanceToPoint(point: vec3): number;
-    intersect(origin: vec3, direction: vec3): number | null;
-    setFromNormalAndCoplanarPoint(normal: vec3, point: vec3): IPlane;
-
-    // #endregion Public Methods (6)
-}

package/src/interfaces/ISphere.ts

@@ -1,24 +0,0 @@
-import { mat4, vec3 } from "gl-matrix";
-import { IBox } from "./IBox";
-import { IGeometry } from "./IGeometry";
-
-export interface ISphere extends IGeometry {
-    // #region Properties (2)
-
-    center: vec3;
-    radius: number;
-
-    // #endregion Properties (2)
-
-    // #region Public Methods (4)
-
-    applyMatrix(matrix: mat4): ISphere;
-    clampPoint(point: vec3): vec3;
-    clone(): ISphere;
-    intersect(origin: vec3, direction: vec3): number | null;
-    intersects(origin: vec3, direction: vec3): boolean;
-    containsPoint(point: vec3): boolean;
-    setFromBox(box: IBox): ISphere;
-
-    // #endregion Public Methods (4)
-}

package/src/interfaces/ISpherical.ts

@@ -1,19 +0,0 @@
-import { vec3 } from "gl-matrix";
-
-export interface ISpherical {
-    // #region Properties (3)
-
-    phi: number;
-    radius: number;
-    theta: number;
-
-    // #endregion Properties (3)
-
-    // #region Public Methods (3)
-
-    fromVec3(p: vec3): ISpherical;
-    makeSafe(): ISpherical;
-    toVec3(): vec3;
-
-    // #endregion Public Methods (3)
-}

package/src/interfaces/ITriangle.ts

@@ -1,12 +0,0 @@
-import { mat4, vec3 } from "gl-matrix";
-import { IGeometry } from "./IGeometry";
-
-export interface ITriangle extends IGeometry {
-    // #region Public Methods (2)
-
-    applyMatrix(matrix: mat4): IGeometry;
-    clone(): ITriangle;
-    intersect(origin: vec3, direction: vec3): vec3 | null;
-
-    // #endregion Public Methods (2)
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-    "extends": "../../tsconfig.json",
-    "include": [
-        "./**/*.ts"
-    ],
-    "compilerOptions": {
-        "rootDir": "src",
-        "outDir": "dist"
-    },
-    "exclude": [
-        "__tests__",
-        "node_modules",
-        "dist",
-        "dist-dev",
-        "dist-prod"
-    ]
-}