@aibee/owlly 1.0.26 → 1.0.29

package/lib/owlly/utils/basic-calc.js

@@ -0,0 +1,129 @@
+/* eslint-disable @typescript-eslint/camelcase */
+class BasicCalcTool {
+    static getLineCross(line1_p1, line1_p2, line2_p1, line2_p2) {
+        // step1 利用投影快速排斥
+        const ifL2R = Math.min(line2_p1.x, line2_p2.x) > Math.max(line1_p1.x, line1_p2.x);
+        const ifL2T = Math.min(line2_p1.y, line2_p2.y) > Math.max(line1_p1.y, line1_p2.y);
+        const ifL1R = Math.min(line1_p1.x, line1_p2.x) > Math.max(line2_p1.x, line2_p2.x);
+        const ifL1T = Math.min(line1_p1.y, line1_p2.y) > Math.max(line2_p1.y, line2_p2.y);
+        if (ifL2R || ifL2T || ifL1R || ifL1T)
+            return false;
+        // step2 投影快速排斥不成立 证明两个点分别在一条直线的两边
+        const crossMul = (v1, v2) => v1.x * v2.y - v1.y * v2.x;
+        // eslint-disable-next-line no-shadow
+        const checkCross = (line1_p1, line1_p2, line2_p1, line2_p2) => {
+            let v1 = { x: line1_p1.x - line2_p1.x, y: line2_p1.y - line1_p1.y };
+            let v2 = { x: line1_p2.x - line2_p1.x, y: line1_p2.y - line2_p1.y };
+            let v3 = { x: line2_p2.x - line2_p1.x, y: line2_p2.y - line2_p1.y };
+            const v = crossMul(v1, v3) * crossMul(v2, v3);
+            v1 = { x: line2_p1.x - line1_p1.x, y: line2_p1.y - line1_p1.y };
+            v2 = { x: line2_p2.x - line1_p1.x, y: line2_p2.y - line1_p1.y };
+            v3 = { x: line1_p2.x - line1_p1.x, y: line1_p2.y - line1_p1.y };
+            return !!((v <= 0 && crossMul(v1, v3) * crossMul(v2, v3) <= 0));
+        };
+        const ifCross = checkCross(line1_p1, line1_p2, line2_p1, line2_p2);
+        return ifCross;
+    }
+    // 拐角范围内的判定为 [2, 20] [340, 358] 平滑后的路径角度在此范围内, 未经平滑的路径返回 []
+    static calcTurning(linePoints, turningStandard = [2, 20]) {
+        const len = linePoints.length;
+        if (len < 2)
+            return [];
+        const crds = [];
+        const getAngle = (p1, p2) => {
+            const { x: x1, y: y1 } = p1;
+            const { x: x2, y: y2 } = p2;
+            const dot = x1 * x2 + y1 * y2;
+            const det = x1 * y2 - y1 * x2;
+            const angle = Math.atan2(det, dot) / Math.PI * 180;
+            return Math.round(angle + 360) % 360;
+        };
+        let isCrossing = false;
+        let curAngle = 0;
+        let curPoint = [0, 0];
+        let startTPoint = [0, 0];
+        let endTPoint = [0, 0];
+        let startIndex = 0;
+        let endIndex = 0;
+        // 经过平滑处理的线, 一个夹角90度可能由n个小夹角组成
+        for (let i = 1; i < len - 1; i++) {
+            const prev = linePoints[i - 1];
+            const cur = linePoints[i];
+            const next = linePoints[i + 1];
+            const angle = getAngle({
+                x: next[0] - cur[0],
+                y: next[1] - cur[1],
+            }, {
+                x: cur[0] - prev[0],
+                y: cur[1] - prev[1],
+            });
+            const isAngleWithinStand = (angle >= turningStandard[0] && angle <= turningStandard[1])
+                || (angle >= (360 - turningStandard[1]) && angle <= (360 - turningStandard[0]));
+            if (!isCrossing && isAngleWithinStand) { // 首次进入夹角
+                isCrossing = true;
+                startTPoint = cur;
+                curAngle += angle;
+                startIndex = i;
+            }
+            else if (isCrossing && isAngleWithinStand) { // 夹角中并夹角依然在增大
+                curAngle += angle;
+            }
+            else if (isCrossing && !isAngleWithinStand) { // 夹角中并夹角停止增大趋势
+                curAngle += angle;
+                endIndex = i;
+                endTPoint = cur;
+                // curPoint 取 夹角范围内最靠近中心的点
+                curPoint = [
+                    (startTPoint[0] + endTPoint[0]) / 2,
+                    (startTPoint[1] + endTPoint[1]) / 2,
+                ];
+                crds.push({
+                    point: curPoint,
+                    angle: curAngle % 360,
+                    startTPoint,
+                    endTPoint,
+                    startIndex,
+                    endIndex,
+                });
+                isCrossing = false;
+            }
+            else if (!isCrossing && !isAngleWithinStand) { // 直行中
+                startIndex = endIndex = 0;
+                curAngle = 0;
+                curPoint = [0, 0];
+                startTPoint = [0, 0];
+                endTPoint = [0, 0];
+            }
+        }
+        // 最后一个点依然在拐角内
+        if (isCrossing) {
+            endTPoint = linePoints[len - 1];
+            curPoint = [
+                (startTPoint[0] + endTPoint[0]) / 2,
+                (startTPoint[1] + endTPoint[1]) / 2,
+            ];
+            crds.push({
+                point: curPoint,
+                angle: curAngle % 360,
+                startTPoint,
+                endTPoint,
+                startIndex,
+                endIndex,
+            });
+            isCrossing = false;
+        }
+        return crds;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static chunk(items, size) {
+        if (items.length <= 0 || size <= 0) {
+            return items;
+        }
+        const chunks = [];
+        for (let i = 0; i < items.length; i += size) {
+            chunks.push(items.slice(i, i + size));
+        }
+        return chunks;
+    }
+}
+export { BasicCalcTool };

package/lib/owlly/utils/basic-tools.d.ts

@@ -0,0 +1,71 @@
+import { NS_THREE } from '../stage/externals';
+import { Element } from '../element/element';
+import { View } from '../view/view';
+declare class BasicTools {
+    /**
+     * 销毁工具
+     * @param o 对象
+     * @param recursive 递归销毁
+     */
+    static dispose(o: NS_THREE.Object3D, recursive?: boolean): void;
+    /**
+     * 鼠标碰撞工具函数
+     * @param objects 需要检测碰撞的 Element
+     * @param param1 鼠标点击坐标
+     * @param camera 使用的相机
+     * @param candidates 候选者, candidate 存在于 object 中
+     * @param maxWorldDistance 世界中点击时的距离
+     * @returns 碰撞对象
+     */
+    static getMouseIntersection(objects: Element[], { x, y }: {
+        x: number;
+        y: number;
+    }, camera: NS_THREE.Camera, candidates?: Element[], maxWorldDistance?: number): NS_THREE.Intersection | null;
+    /**
+     * 获取屏幕空间的点击碰撞
+     * @param objects 需要检查的对象
+     * @param param1 点击坐标
+     * @param param2 屏幕尺寸
+     * @param maxDistance 最大检测距离
+     * @param camera 相机
+     * @param candidates 候选对象, 可能在 object 内
+     * @param maxWorldDistance 最大世界空间坐标检测距离
+     * @param boundingBoxes 候选的碰撞盒, 可选
+     * @returns 碰撞到的对象
+     */
+    static getMouseIntersectionOnScreen(objects: NS_THREE.Object3D[] | Element[], { x, y }: {
+        x: number;
+        y: number;
+    }, { screenWidth, screenHeight }: {
+        screenWidth: number;
+        screenHeight: number;
+    }, maxDistance: number, camera: NS_THREE.Camera, candidates?: NS_THREE.Object3D[] | Element[], maxWorldDistance?: number, boundingBoxes?: Map<NS_THREE.Object3D | Element, [number, number]>): NS_THREE.Object3D | Element | null;
+    /**
+     * 转换俯视图屏幕坐标为三维坐标
+     * @param {x, y} 屏幕坐标
+     * @param view 视图
+     * @param camera 相机
+     */
+    static getHorizontalPlaneCoordinate({ x, y }: {
+        x: number;
+        y: number;
+    }, view: View, camera: NS_THREE.Camera | undefined): NS_THREE.Vector2 | null;
+    static getHorizontalPlaneCoordinate3({ x, y }: {
+        x: number;
+        y: number;
+    }, view: View, camera: NS_THREE.Camera | undefined): NS_THREE.Vector3 | null;
+    /**
+     * 将坐标投影到屏幕空间
+     * @param position 世界坐标
+     * @param view 视图
+     * @param camera 相机
+     * @returns 转换后的屏幕坐标
+     */
+    static projectToScreenCoordinate(position: NS_THREE.Vector3, view: View, camera: NS_THREE.Camera | undefined): {
+        x: number;
+        y: number;
+    } | null;
+    private static getMesh;
+    static debounce(fn: Function, delay: number): Function;
+}
+export { BasicTools };

package/lib/owlly/utils/basic-tools.js

@@ -0,0 +1,235 @@
+import { Externals } from '../stage/externals';
+import { Element } from '../element/element';
+class BasicTools {
+    /**
+     * 销毁工具
+     * @param o 对象
+     * @param recursive 递归销毁
+     */
+    static dispose(o, recursive) {
+        if (recursive && o.children && o.children.length) {
+            o.children.forEach((child) => {
+                BasicTools.dispose(child, recursive);
+            });
+        }
+        if (o.isMesh) {
+            const m = o;
+            if (m.geometry)
+                m.geometry.dispose();
+            if (m.material) {
+                if (Array.isArray(m.material)) {
+                    m.material.forEach((mat) => {
+                        mat.dispose();
+                    });
+                }
+                else {
+                    m.material.dispose();
+                }
+            }
+        }
+    }
+    /**
+     * 鼠标碰撞工具函数
+     * @param objects 需要检测碰撞的 Element
+     * @param param1 鼠标点击坐标
+     * @param camera 使用的相机
+     * @param candidates 候选者, candidate 存在于 object 中
+     * @param maxWorldDistance 世界中点击时的距离
+     * @returns 碰撞对象
+     */
+    static getMouseIntersection(objects, { x, y }, camera, candidates, maxWorldDistance = -1) {
+        const { THREE } = Externals.getInstance();
+        const maxWorldDistanceSquared = maxWorldDistance < 0 ? Number.MAX_SAFE_INTEGER : Math.pow(maxWorldDistance, 2);
+        const rayCaster = new THREE.Raycaster();
+        rayCaster.setFromCamera({ x, y }, camera);
+        const cameraPosition = camera.position.clone();
+        const filteredObjects = objects.filter((o) => o.visible
+            && cameraPosition.distanceToSquared(o.getWorldPosition(new THREE.Vector3())) < maxWorldDistanceSquared);
+        const intersections = rayCaster.intersectObjects(filteredObjects, true).filter((i) => (!!i.face));
+        const candidateSet = new Set(candidates);
+        for (let i = 0; i < intersections.length; i++) {
+            let target = intersections[i].object;
+            const parentElements = [];
+            while (!(target instanceof Element) && target.parent)
+                target = target.parent;
+            while (target) {
+                if (target instanceof Element) {
+                    parentElements.push(target);
+                }
+                if (!target.parent)
+                    break;
+                target = target.parent;
+            }
+            for (let j = 0; j < parentElements.length; j++) {
+                if (parentElements[j] instanceof Element) {
+                    if (candidates) {
+                        if (candidateSet.has(parentElements[j])) {
+                            const ret = intersections[i];
+                            ret.object = parentElements[j];
+                            return ret;
+                        }
+                    }
+                    else {
+                        const ret = intersections[i];
+                        ret.object = parentElements[j];
+                        return ret;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * 获取屏幕空间的点击碰撞
+     * @param objects 需要检查的对象
+     * @param param1 点击坐标
+     * @param param2 屏幕尺寸
+     * @param maxDistance 最大检测距离
+     * @param camera 相机
+     * @param candidates 候选对象, 可能在 object 内
+     * @param maxWorldDistance 最大世界空间坐标检测距离
+     * @param boundingBoxes 候选的碰撞盒, 可选
+     * @returns 碰撞到的对象
+     */
+    static getMouseIntersectionOnScreen(objects, { x, y }, { screenWidth, screenHeight }, maxDistance, camera, candidates, maxWorldDistance = 13, boundingBoxes) {
+        const { THREE } = Externals.getInstance();
+        const intersections = [];
+        const screenPoint = new THREE.Vector2(x, y);
+        const frustum = new THREE.Frustum();
+        frustum.setFromProjectionMatrix(new THREE.Matrix4().multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse));
+        const cameraPos = camera.position.clone();
+        const maxWorldDistanceSquared = maxWorldDistance < 0 ? Number.MAX_SAFE_INTEGER : Math.pow(maxWorldDistance, 2);
+        objects.forEach((obj) => {
+            const v3 = obj.position.clone().project(camera);
+            const dist = new THREE.Vector2((v3.x + 1) / 2 * screenWidth, (1 - v3.y) / 2 * screenHeight).distanceTo(screenPoint);
+            const mesh = this.getMesh(obj);
+            if (!mesh)
+                return;
+            let hasBoundingBox = false;
+            let bboxCollision = false;
+            if (boundingBoxes) {
+                const value = boundingBoxes.get(obj);
+                if (value) {
+                    hasBoundingBox = true;
+                    const center = new THREE.Vector2((v3.x + 1) / 2 * screenWidth, (1 - v3.y) / 2 * screenHeight);
+                    const leftX = center.x - value[0] / 2;
+                    const rightX = center.x + value[0] / 2;
+                    const topY = center.y - value[1] / 2;
+                    const bottomY = center.y + value[1] / 2;
+                    if (Math.abs(v3.z) <= 1
+                        && screenPoint.x <= rightX && screenPoint.x >= leftX
+                        && screenPoint.y >= topY && screenPoint.y <= bottomY) {
+                        bboxCollision = true;
+                    }
+                }
+            }
+            if ((hasBoundingBox ? bboxCollision : dist <= maxDistance)
+                && cameraPos.distanceToSquared(mesh.getWorldPosition(new THREE.Vector3())) < maxWorldDistanceSquared
+                && frustum.intersectsObject(mesh)
+                && mesh.visible
+                && obj.visible) {
+                intersections.push({
+                    e: obj,
+                    d: dist,
+                });
+            }
+        });
+        intersections.sort((a, b) => a.d - b.d);
+        const candidateSet = new Set(candidates);
+        for (let i = 0; i < intersections.length; i++) {
+            const target = intersections[i].e;
+            if (candidates) {
+                if (candidateSet.has(target))
+                    return target;
+            }
+            else
+                return target;
+        }
+        return null;
+    }
+    /**
+     * 转换俯视图屏幕坐标为三维坐标
+     * @param {x, y} 屏幕坐标
+     * @param view 视图
+     * @param camera 相机
+     */
+    static getHorizontalPlaneCoordinate({ x, y }, view, camera) {
+        if (!camera) {
+            return null;
+        }
+        const { THREE } = Externals.getInstance();
+        const { clientWidth, clientHeight } = view.renderer.domElement;
+        if (clientWidth <= 0 || clientHeight <= 0) {
+            return null;
+        }
+        const nx = x / clientWidth * 2 - 1;
+        const ny = 1 - y / clientHeight * 2;
+        const v = new THREE.Vector3(nx, ny, 0);
+        const coordinate3 = v.unproject(camera);
+        return new THREE.Vector2(coordinate3.x, coordinate3.y);
+    }
+    static getHorizontalPlaneCoordinate3({ x, y }, view, camera) {
+        if (!camera) {
+            return null;
+        }
+        const { THREE } = Externals.getInstance();
+        const { clientWidth, clientHeight } = view.renderer.domElement;
+        if (clientWidth <= 0 || clientHeight <= 0) {
+            return null;
+        }
+        const nx = x / clientWidth * 2 - 1;
+        const ny = 1 - y / clientHeight * 2;
+        const v = new THREE.Vector3(nx, ny, 0);
+        const coordinate3 = v.unproject(camera);
+        return coordinate3;
+    }
+    /**
+     * 将坐标投影到屏幕空间
+     * @param position 世界坐标
+     * @param view 视图
+     * @param camera 相机
+     * @returns 转换后的屏幕坐标
+     */
+    static projectToScreenCoordinate(position, view, camera) {
+        if (!camera) {
+            return null;
+        }
+        const { clientWidth, clientHeight } = view.renderer.domElement;
+        if (clientWidth <= 0 || clientHeight <= 0) {
+            return null;
+        }
+        const coordinate2 = position.clone().project(camera);
+        const x = (coordinate2.x + 1) * 0.5 * clientWidth;
+        const y = (1 - coordinate2.y) * 0.5 * clientHeight;
+        return { x, y };
+    }
+    static getMesh(obj) {
+        const { THREE } = Externals.getInstance();
+        const target = obj instanceof THREE.Mesh ? obj : null;
+        if (!target && obj.children.length) {
+            for (let i = 0; i < obj.children.length; i += 1) {
+                const t = this.getMesh(obj.children[i]);
+                if (t)
+                    return t;
+            }
+        }
+        return target;
+    }
+    static debounce(fn, delay) {
+        let timer;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return function debounceFn(force, ...args) {
+            if (force) {
+                fn.bind(null, ...args);
+            }
+            if (timer) {
+                clearTimeout(timer);
+                timer = setTimeout(fn.bind(null, ...args), delay);
+            }
+            else {
+                timer = setTimeout(fn.bind(null, ...args), delay);
+            }
+        };
+    }
+}
+export { BasicTools };

package/lib/owlly/utils/bvh-tree.d.ts

@@ -0,0 +1,105 @@
+/**
+ * bvh-tree
+ * A Bounding Volume Hierarchy data structure implementation.
+ * https://github.com/benraziel/bvh-tree
+ *
+ * 该文件是外部引入的类, 用于创建 FloorModel 的 BVH 树
+ *
+ * @author Ben Raziel
+  * @ignore
+ */
+import { NS_THREE } from '../stage/externals';
+interface IntersectResult {
+    triangle?: NS_THREE.Vector3[];
+    triangleIndex?: number;
+    intersectionPoint: NS_THREE.Vector3;
+}
+/**
+ * A node in the [[BVHTree]] structure
+ *
+ */
+declare class BVHNode {
+    extentsMin: NS_THREE.Vector3;
+    extentsMax: NS_THREE.Vector3;
+    startIndex: number;
+    endIndex: number;
+    level: number;
+    node0: BVHNode | null;
+    node1: BVHNode | null;
+    /**
+      * Constructor of BVHNode
+      * @param {Point} extentsMin the min coords of this node's bounding box ({x,y,z})
+      * @param {Point} extentsMax the max coords of this node's bounding box ({x,y,z})
+      * @param {number} startIndex an index in the bbox array, where the first element of this node is located
+      * @param {number} endIndex an index in the bbox array, where the last of this node is located,
+      * plus 1 (meaning that its non-inclusive).
+      * @param {number} the distance of this node from the root for the bvh tree. root node has level=0,
+      * its children have level=1 etc.
+      */
+    constructor(extentsMin: NS_THREE.Vector3, extentsMax: NS_THREE.Vector3, startIndex: number, endIndex: number, level: number);
+    elementCount(): number;
+    centerX(): number;
+    centerY(): number;
+    centerZ(): number;
+    clearShapes(): void;
+    calcBoundingSphereRadius(extentsMin: NS_THREE.Vector3, extentsMax: NS_THREE.Vector3): number;
+}
+/**
+ * BVH树
+ */
+declare class BVHTree {
+    private static EPSILON;
+    private trianglesArray;
+    private maxTrianglesPerNode;
+    private bboxArray;
+    private bboxHelper;
+    private rootNode;
+    private nodesToSplit;
+    /**
+     * 创建BVH树对象
+     * @param {Vector3[][]} triangles 三角形数组，BVH树基于此构建
+     * @param {number} maxTrianglesPerNode 每个树结点包含的最多三角形数量
+     */
+    constructor(triangles: NS_THREE.Vector3[][], maxTrianglesPerNode: number);
+    private vector3SetFromArray;
+    /**
+     * Returns a list of all the triangles in the BVH which interected a specific node.
+     * We use the BVH node structure to first cull out nodes which do not intereset the ray.
+     * For rays that did intersect, we test intersection of the ray with each triangle
+     * @param {Vector3} rayOrigin the origin position of the ray.
+     * @param {Vector3} rayDirection the direction vector of the ray.
+     * @param {boolean} backfaceCulling if 'true', only intersections with front-faces of the mesh will be performed.
+     * @return {{}[]} IntersectionResult an array of intersection result, one for each triangle which intersected the BVH，
+     * each item in the form of:
+     * {
+     *  triangle: Vector3[];
+     *  triangleIndex: number;
+     *  intersectionPoint: Vector3;
+     * }
+    */
+    intersectRay(rayOrigin: NS_THREE.Vector3, rayDirection: NS_THREE.Vector3, backfaceCulling?: boolean): IntersectResult[];
+    /**
+     * 获得与指定射线方向相交的最接近射线起点的相交结果
+     * @param rayOrigin 射线起点
+     * @param rayDirection 射线方向
+     * @param backfaceCulling 可选，是否忽略背面
+     */
+    nearestIntersection(rayOrigin: NS_THREE.Vector3, rayDirection: NS_THREE.Vector3, backfaceCulling?: boolean): IntersectResult | null;
+    private calcBoundingBoxes;
+    private setBox;
+    private copyBox;
+    private calcExtents;
+    private splitNode;
+    private calcTValues;
+    private intersectNodeBox;
+    private intersectRayTriangle;
+    private static addTriangles;
+    /**
+    * 构建bvhtree
+    * @ignore
+    * @param {Object3D} threeObj 需要创建BVH树的Object3D根对象
+    * @returns {BVHTree}
+    */
+    static createBVHTree(threeObj: NS_THREE.Object3D): BVHTree;
+}
+export { BVHTree, BVHNode, IntersectResult };