@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/math/navigation/Navi3DFunnel.js

@@ -1,254 +0,0 @@
-import { PlaneClassification } from "../PlaneClassification";
-import { Vector3 } from "../Vector3";
-import { Navi3DConst } from "./Navi3DConst";
-import { Navi3DPointFat } from "./Navi3DPointFat";
-import { Navi3DRouter } from "./Navi3DRouter";
-export class Navi3DFunnel {
-    static { this.CROSS_TEST_DIRECTION = new Vector3(); }
-    constructor() {
-        this._aiRadius = 0;
-        this._tempPublicEdgeList = new Array();
-        this._tempSamePlaneList = new Array();
-        this._router = new Navi3DRouter();
-    }
-    searchPath(startPt, endPt, triangleList, radius = 0) {
-        if (radius <= 0)
-            radius = 1;
-        this._aiRadius = radius * 1.5;
-        //
-        //起点终点判断
-        if (!this.searchEnable(startPt, endPt, triangleList))
-            return false;
-        this.search(startPt, endPt, triangleList);
-        return true;
-    }
-    get path() {
-        return this._result;
-    }
-    searchEnable(startPt, endPt, triangleList) {
-        if (startPt == null || endPt == null || triangleList == null)
-            return false;
-        if (triangleList[0].plane.classifyPoint(startPt, Navi3DConst.EPSILON) !=
-            PlaneClassification.INTERSECT) {
-            return false;
-        }
-        if (triangleList[triangleList.length - 1].plane.classifyPoint(endPt, Navi3DConst.EPSILON) != PlaneClassification.INTERSECT) {
-            return false;
-        }
-        return true;
-    }
-    search(startPt, endPt, triangleList) {
-        this._tempPublicEdgeList.length = 0;
-        this._tempSamePlaneList.length = 0;
-        var i = 0;
-        var crossedEdgeCount = triangleList.length - 1;
-        var tr;
-        var curEdge;
-        var pt;
-        var plane;
-        var crossPoint;
-        for (i = 0; i < crossedEdgeCount; i++) {
-            curEdge = triangleList[i].getPublicEdge(triangleList[i + 1]);
-            curEdge.crossPoint = null;
-            curEdge.initFatPoints(this._aiRadius);
-            this._tempPublicEdgeList.push(curEdge);
-            tr = triangleList[i];
-            plane = tr.plane;
-            tr = triangleList[i + 1];
-            pt = tr.getEdgeAgainstPoint(curEdge);
-            this._tempSamePlaneList.push(plane.classifyPoint(pt, Navi3DConst.EPSILON) ==
-                PlaneClassification.INTERSECT);
-        }
-        this._router.continuePass(startPt, endPt, this._tempPublicEdgeList[0]);
-        crossedEdgeCount = this._tempPublicEdgeList.length;
-        var cornerPoint;
-        var cornerEdge;
-        var continuePass;
-        var lastEdge;
-        for (i = 0; i < crossedEdgeCount; i++) {
-            curEdge = this._tempPublicEdgeList[i];
-            tr = triangleList[i + 1];
-            lastEdge = i == crossedEdgeCount - 1;
-            if (lastEdge) {
-                pt = endPt;
-            }
-            else {
-                pt = tr.getEdgeAgainstPoint(curEdge);
-            }
-            continuePass = this._router.passEdge(curEdge, this._tempPublicEdgeList[i + 1], pt, lastEdge);
-            if (!continuePass) {
-                cornerPoint = this._router.cornerPoint;
-                cornerEdge = this._router.cornerEdge;
-                i = this._tempPublicEdgeList.indexOf(cornerEdge);
-                this._router.continuePass(cornerPoint, endPt, this._tempPublicEdgeList[i + 1]);
-            }
-        }
-        this.pushAllPathPoint2(startPt, endPt);
-        if (this._result.length >= 3) {
-            this.optimusTerminusFat();
-            this.optimusByRadius();
-        }
-        //copy result
-        let list = [];
-        for (let point of this._result) {
-            list.push(new Vector3().copyFrom(point));
-        }
-        this._result = list;
-    }
-    optimusTerminusFat() {
-        var startFat;
-        var endFat;
-        var pt;
-        pt = this._result[1];
-        if (pt instanceof Navi3DPointFat) {
-            startFat = pt;
-        }
-        pt = this._result[this._result.length - 2];
-        if (pt instanceof Navi3DPointFat) {
-            endFat = pt;
-        }
-        if (startFat) {
-            this._result[1] = startFat.scalePoint();
-        }
-        if (endFat && startFat != endFat) {
-            this._result[this._result.length - 2] = endFat.scalePoint();
-        }
-    }
-    pushAllPathPoint2(startPt, endPt) {
-        var crossedEdgeCount = this._tempPublicEdgeList.length;
-        var curEdge;
-        var curEdgeJ;
-        this._result = new Array();
-        this._result.push(startPt);
-        var fromPoint = startPt;
-        var toPoint;
-        var fatPoint;
-        var crossPoint;
-        for (var i = 0; i < crossedEdgeCount; i++) {
-            curEdge = this._tempPublicEdgeList[i];
-            fatPoint = null;
-            if (curEdge.crossPoint) {
-                fatPoint = this.getFatPoint(curEdge, curEdge.crossPoint);
-                if (fatPoint) {
-                    this._result.push(fatPoint);
-                }
-                else {
-                    this._result.push(curEdge.crossPoint);
-                }
-                fromPoint = curEdge.crossPoint;
-            }
-            else {
-                curEdgeJ = null;
-                toPoint = null;
-                //找到下一个点
-                for (var j = i + 1; j < crossedEdgeCount; j++) {
-                    curEdgeJ = this._tempPublicEdgeList[j];
-                    toPoint = curEdgeJ.crossPoint;
-                    if (toPoint) {
-                        break;
-                    }
-                }
-                if (toPoint == null) {
-                    toPoint = endPt;
-                }
-                fatPoint = this.getFatPoint(curEdge, toPoint);
-                if (fatPoint) {
-                    this._result.push(fatPoint);
-                }
-                else {
-                    if (toPoint == fromPoint) {
-                        crossPoint = toPoint.clone();
-                    }
-                    else {
-                        Navi3DFunnel.CROSS_TEST_DIRECTION.setTo(toPoint.x - fromPoint.x, 0, toPoint.z - fromPoint.z);
-                        crossPoint = this._router.calcCrossEdge(curEdge, fromPoint, Navi3DFunnel.CROSS_TEST_DIRECTION);
-                    }
-                    this._result.push(crossPoint);
-                }
-            }
-        }
-        this._result.push(endPt);
-    }
-    optimusByRadius() {
-        var optimusResult = new Array();
-        optimusResult.length = this._result.length;
-        var count = this._result.length - 2;
-        var pt0;
-        var pt1;
-        var pt2;
-        var fatPt0;
-        var fatPt1;
-        var fatPt2;
-        var edgePt0;
-        var edgePt1;
-        var edgePt2;
-        var centerEdge;
-        var checkEnable;
-        var optimusPoint;
-        var i;
-        for (i = 0; i < count; i++) {
-            edgePt0 = edgePt1 = edgePt2 = null;
-            fatPt0 = fatPt1 = fatPt2 = null;
-            checkEnable = false;
-            optimusPoint = null;
-            pt0 = this._result[i];
-            pt1 = this._result[i + 1];
-            pt2 = this._result[i + 2];
-            if (pt0 instanceof Navi3DPointFat) {
-                fatPt0 = pt0;
-            }
-            if (pt1 instanceof Navi3DPointFat) {
-                fatPt1 = pt1;
-            }
-            if (pt2 instanceof Navi3DPointFat) {
-                fatPt2 = pt2;
-            }
-            if (fatPt0) {
-                edgePt0 = fatPt0.ownerPoint;
-            }
-            if (fatPt1) {
-                edgePt1 = fatPt1.ownerPoint;
-            }
-            if (fatPt2) {
-                edgePt2 = fatPt2.ownerPoint;
-            }
-            if (edgePt0 && edgePt1 && edgePt0 == edgePt1 && edgePt1 != edgePt2) {
-                checkEnable = true;
-            }
-            if (edgePt2 && edgePt1 && edgePt2 == edgePt1 && edgePt0 != edgePt1) {
-                checkEnable = true;
-            }
-            if (checkEnable) {
-                Navi3DFunnel.CROSS_TEST_DIRECTION.copyFrom(pt0);
-                Navi3DFunnel.CROSS_TEST_DIRECTION.decrementBy(pt2);
-                centerEdge = fatPt1.ownerEdge;
-                checkEnable = this._router.hasCrossPoint(centerEdge.pointA, centerEdge.pointB, pt2, Navi3DFunnel.CROSS_TEST_DIRECTION);
-                if (checkEnable) {
-                    optimusPoint = this._router.calcCrossPointOut(edgePt1, pt1, pt2, Navi3DFunnel.CROSS_TEST_DIRECTION);
-                }
-                if (optimusPoint) {
-                    optimusResult[i + 1] = optimusPoint;
-                }
-            }
-        }
-    }
-    getFatPoint(edge, target) {
-        if (edge == null)
-            return null;
-        var fatPoint;
-        if (target instanceof Navi3DPointFat) {
-            fatPoint = target;
-        }
-        var edgePoint;
-        if (fatPoint) {
-            edgePoint = fatPoint.ownerPoint;
-        }
-        else {
-            edgePoint = edge.getEqualPoint(target);
-        }
-        if (edgePoint == null)
-            return null;
-        fatPoint = edge.getFatPoint(edgePoint);
-        return fatPoint;
-    }
-}

package/dist/src/math/navigation/Navi3DMaskType.d.ts

@@ -1,3 +0,0 @@
-export declare class Navi3DMaskType {
-    static WalkAble: number;
-}

package/dist/src/math/navigation/Navi3DMaskType.js

@@ -1,3 +0,0 @@
-export class Navi3DMaskType {
-    static { this.WalkAble = 1; }
-}

package/dist/src/math/navigation/Navi3DMesh.d.ts

@@ -1,27 +0,0 @@
-import { IQuadNode } from "../../core/tree/quad/IQuadNode";
-import { Vector3 } from "../Vector3";
-import { Navi3DEdge } from "./Navi3DEdge";
-import { Navi3DPoint } from "./Navi3DPoint";
-import { Navi3DTriangle } from "./Navi3DTriangle";
-export declare class Navi3DMesh {
-    private _nav3dPoints;
-    private _nav3dEdges;
-    private _nav3dTriangles;
-    private _path;
-    private _edgesDict;
-    private _nav3dAstar;
-    private _nav3dFunnel;
-    private _terrainQuad;
-    private _triangleList;
-    get edges(): Array<Navi3DEdge>;
-    get points(): Array<Navi3DPoint>;
-    get path(): Array<Vector3>;
-    get triangles(): Array<Navi3DTriangle>;
-    constructor(pointList: Array<Vector3>, triangleIndexList: Array<Array<number>>);
-    getTriangleAtPoint(point: Vector3, threshold?: number): IQuadNode;
-    findPath(startPt: Vector3, endPt: Vector3, aiRadius?: number): boolean;
-    private initPoints;
-    private initEdgesAndTriangles;
-    private tryCreateEdge;
-    private createConnections;
-}

package/dist/src/math/navigation/Navi3DMesh.js

@@ -1,122 +0,0 @@
-import { QuadRoot } from "../../core/tree/quad/QuadRoot";
-import { DoubleArray } from "./DoubleArray";
-import { Navi3DAstar } from "./Navi3DAstar";
-import { Navi3DEdge } from "./Navi3DEdge";
-import { Navi3DFunnel } from "./Navi3DFunnel";
-import { Navi3DPoint } from "./Navi3DPoint";
-import { Navi3DTriangle } from "./Navi3DTriangle";
-export class Navi3DMesh {
-    get edges() {
-        return this._nav3dEdges;
-    }
-    get points() {
-        return this._nav3dPoints;
-    }
-    get path() {
-        return this._path;
-    }
-    get triangles() {
-        return this._nav3dTriangles;
-    }
-    constructor(pointList, triangleIndexList) {
-        this._nav3dPoints = new Array();
-        this._nav3dEdges = new Array();
-        this._nav3dTriangles = new Array();
-        this._edgesDict = new DoubleArray();
-        this.initPoints(pointList);
-        this.initEdgesAndTriangles(triangleIndexList);
-        this.createConnections();
-        this._nav3dAstar = new Navi3DAstar();
-        this._nav3dFunnel = new Navi3DFunnel();
-        this._terrainQuad = new QuadRoot(8, 128);
-        this._terrainQuad.createQuadTree(this._nav3dTriangles);
-    }
-    getTriangleAtPoint(point, threshold = 5) {
-        return this._terrainQuad.getTriangleAtPoint(point, threshold);
-    }
-    findPath(startPt, endPt, aiRadius = 5) {
-        this._path = null;
-        this._triangleList = null;
-        var startNode = this.getTriangleAtPoint(startPt, 10);
-        var endNode = this.getTriangleAtPoint(endPt, 10);
-        var success = this._nav3dAstar.findPath(this, startNode, endNode);
-        if (success) {
-            this._triangleList = this._nav3dAstar.channel;
-            success = this._nav3dFunnel.searchPath(startPt, endPt, this._triangleList, aiRadius);
-            this._path = this._nav3dFunnel.path;
-            return success;
-        }
-        return false;
-    }
-    initPoints(pointList) {
-        var point;
-        var nevPoint;
-        var count = pointList.length;
-        for (var i = 0; i < count; i++) {
-            point = pointList[i];
-            nevPoint = new Navi3DPoint(i, point.x, point.y, point.z);
-            this._nav3dPoints.push(nevPoint);
-        }
-    }
-    initEdgesAndTriangles(triangleIndexList) {
-        var indexOrderList;
-        var edge0;
-        var edge1;
-        var edge2;
-        var triangle;
-        var count = triangleIndexList.length;
-        for (var i = 0; i < count; i++) {
-            indexOrderList = triangleIndexList[i];
-            edge0 = this.tryCreateEdge(indexOrderList[0], indexOrderList[1]);
-            edge1 = this.tryCreateEdge(indexOrderList[1], indexOrderList[2]);
-            edge2 = this.tryCreateEdge(indexOrderList[2], indexOrderList[0]);
-            if (edge0 == null || edge1 == null || edge2 == null)
-                continue;
-            triangle = new Navi3DTriangle(i, edge0, edge1, edge2);
-            this._nav3dTriangles.push(triangle);
-        }
-    }
-    tryCreateEdge(pointAId, pointBId) {
-        if (pointAId == pointBId) {
-            throw new Error("edge point index error!!!");
-        }
-        if (pointAId > pointBId) {
-            var tempId = pointAId;
-            pointAId = pointBId;
-            pointBId = tempId;
-        }
-        var edge = this._edgesDict.getValueByKey(pointAId + "_" + pointBId);
-        if (edge == null) {
-            edge = new Navi3DEdge(this._nav3dPoints[pointAId], this._nav3dPoints[pointBId]);
-            this._nav3dEdges.push(edge);
-            this._edgesDict.put(pointAId + "_" + pointBId, edge);
-        }
-        return edge;
-    }
-    createConnections() {
-        var triangleACount = this._nav3dTriangles.length;
-        var triangleBCount = this._nav3dTriangles.length;
-        var triangleA;
-        var triangleB;
-        var edge;
-        var publicEdge;
-        for (var i = 0; i < triangleACount; i++) {
-            //边上面记录拥有这条边的三角形
-            triangleA = this._nav3dTriangles[i];
-            for (edge of triangleA.edges) {
-                edge.addTriangleOwners(triangleA);
-            }
-            for (var j = 0; j < triangleBCount; j++) {
-                //三角形相邻关系
-                triangleB = this._nav3dTriangles[j];
-                if (triangleA == triangleB)
-                    continue;
-                publicEdge = triangleA.loopPublicEdge(triangleB);
-                if (publicEdge) {
-                    triangleA.addNeibour(publicEdge, triangleB);
-                    triangleB.addNeibour(publicEdge, triangleA);
-                }
-            }
-        }
-    }
-}

package/dist/src/math/navigation/Navi3DPoint.d.ts

@@ -1,13 +0,0 @@
-import { Vector3 } from "../Vector3";
-export declare class Navi3DPoint extends Vector3 {
-    static CALC_VECTOR3D1: Vector3;
-    static CALC_VECTOR3D2: Vector3;
-    static CALC_VECTOR3D3: Vector3;
-    static CALC_VECTOR3D4: Vector3;
-    static CALC_VECTOR3D5: Vector3;
-    private _pointId;
-    constructor(id: number, X: number, Y: number, Z: number);
-    get id(): number;
-    static equalPoint(p1: Vector3, p2: Vector3): boolean;
-    static calcDistance(pt1: Vector3, pt2: Vector3): number;
-}

package/dist/src/math/navigation/Navi3DPoint.js

@@ -1,27 +0,0 @@
-import { Vector3 } from "../Vector3";
-import { Navi3DConst } from "./Navi3DConst";
-export class Navi3DPoint extends Vector3 {
-    static { this.CALC_VECTOR3D1 = new Vector3(); }
-    static { this.CALC_VECTOR3D2 = new Vector3(); }
-    static { this.CALC_VECTOR3D3 = new Vector3(); }
-    static { this.CALC_VECTOR3D4 = new Vector3(); }
-    static { this.CALC_VECTOR3D5 = new Vector3(); }
-    constructor(id, X, Y, Z) {
-        super(X, Y, Z, 0);
-        this._pointId = 0;
-        this._pointId = id;
-    }
-    get id() {
-        return this._pointId;
-    }
-    static equalPoint(p1, p2) {
-        return ((p1.x - p2.x) * (p1.x - p2.x) +
-            (p1.y - p2.y) * (p1.y - p2.y) +
-            (p1.z - p2.z) * (p1.z - p2.z) <
-            Navi3DConst.POWER_EPSILON);
-    }
-    static calcDistance(pt1, pt2) {
-        Navi3DPoint.CALC_VECTOR3D3.setTo(pt1.x - pt2.x, pt1.y - pt2.y, pt1.z - pt2.z);
-        return Navi3DPoint.CALC_VECTOR3D3.length;
-    }
-}

package/dist/src/math/navigation/Navi3DPoint2D.d.ts

@@ -1,10 +0,0 @@
-export declare class Navi3DPoint2D {
-    x: number;
-    y: number;
-    setTo(X: number, Y: number): void;
-    equals(X: number, Y: number): boolean;
-    equalPoint(pt: Navi3DPoint2D): boolean;
-    get length(): number;
-    clone(): Navi3DPoint2D;
-    normalize(): void;
-}

package/dist/src/math/navigation/Navi3DPoint2D.js

@@ -1,26 +0,0 @@
-export class Navi3DPoint2D {
-    setTo(X, Y) {
-        this.x = X;
-        this.y = Y;
-    }
-    equals(X, Y) {
-        return X == this.x && Y == this.y;
-    }
-    equalPoint(pt) {
-        return this.equals(pt.x, pt.y);
-    }
-    get length() {
-        return Math.sqrt(this.x * this.x + this.y * this.y);
-    }
-    clone() {
-        var point = new Navi3DPoint2D();
-        point.setTo(this.x, this.y);
-        return point;
-    }
-    normalize() {
-        var size = length;
-        if (size == 0)
-            return;
-        this.setTo(this.x / size, this.y / size);
-    }
-}

package/dist/src/math/navigation/Navi3DPointFat.d.ts

@@ -1,11 +0,0 @@
-import { Navi3DEdge } from "./Navi3DEdge";
-import { Navi3DPoint } from "./Navi3DPoint";
-export declare class Navi3DPointFat extends Navi3DPoint {
-    private _ownerPoint;
-    private _ownerEdge;
-    radius: number;
-    constructor(_point: Navi3DPoint, _edge: Navi3DEdge);
-    get ownerPoint(): Navi3DPoint;
-    get ownerEdge(): Navi3DEdge;
-    scalePoint(value?: number): Navi3DPointFat;
-}

package/dist/src/math/navigation/Navi3DPointFat.js

@@ -1,24 +0,0 @@
-import { Navi3DPoint } from "./Navi3DPoint";
-export class Navi3DPointFat extends Navi3DPoint {
-    constructor(_point, _edge) {
-        super(_point.id, 0, 0, 0);
-        this.radius = 0;
-        this._ownerEdge = _edge;
-        this._ownerPoint = _point;
-    }
-    get ownerPoint() {
-        return this._ownerPoint;
-    }
-    get ownerEdge() {
-        return this._ownerEdge;
-    }
-    scalePoint(value = 0.7) {
-        var point = new Navi3DPointFat(this._ownerPoint, this._ownerEdge);
-        point.copyFrom(this);
-        point.decrementBy(this._ownerPoint);
-        point.scaleBy(value);
-        point.radius = point.length;
-        point.incrementBy(this._ownerPoint);
-        return point;
-    }
-}

package/dist/src/math/navigation/Navi3DRouter.d.ts

@@ -1,29 +0,0 @@
-import { Vector3 } from "../Vector3";
-import { Navi3DEdge } from "./Navi3DEdge";
-import { Navi3DPoint } from "./Navi3DPoint";
-export declare class Navi3DRouter {
-    endPoint: Vector3;
-    curPoint: Vector3;
-    rayA: Vector3;
-    rayB: Vector3;
-    rayAPoint: Navi3DPoint;
-    rayBPoint: Navi3DPoint;
-    static RAY_1: Vector3;
-    static RAY_2: Vector3;
-    static TEST_RAY: Vector3;
-    static TEST_RAY_1: Vector3;
-    static TEST_RAY_2: Vector3;
-    private static CALC_CROSS_POINT;
-    private static CALC_CROSS_TEST;
-    cornerPoint: Navi3DPoint;
-    cornerEdge: Navi3DEdge;
-    continuePass(fromPt: Vector3, endPt: Vector3, fromEdge: Navi3DEdge): void;
-    passEdge(commonEdge: Navi3DEdge, nextCommonEdge: Navi3DEdge, targetPoint: Vector3, lastEdge: boolean): boolean;
-    private checkEndPoint;
-    calcCrossEdge(_edge: Navi3DEdge, linePoint: Vector3, lineDirection: Vector3): Vector3;
-    calcCrossPoint(segmentPt1: Vector3, segmentPt2: Vector3, linePoint: Vector3, lineDirection: Vector3): Vector3;
-    calcCrossPointOut(segmentPt1: Vector3, segmentPt2: Vector3, linePoint: Vector3, lineDirection: Vector3): Vector3;
-    hasCrossPoint(segmentPt1: Vector3, segmentPt2: Vector3, linePoint: Vector3, lineDirection: Vector3): boolean;
-    private isPointAtCenter;
-    resetData(): void;
-}