@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,254 @@
+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

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

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

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

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,122 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,29 @@
+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;
+}