@aibee/owlly 1.0.25 → 1.0.29

package/lib/owlly/element/path-group.d.ts

@@ -0,0 +1,69 @@
+import { NS_THREE } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { Path } from './path';
+import { FloorModel, GroundParameters } from './floor-model';
+/** 楼层模型元素
+ * @noInheritDoc */
+declare class PathGroup extends Element {
+    private pathInitialized;
+    private pathReloaded;
+    private paths;
+    private floorModel;
+    private groundParams;
+    private eventListeners;
+    private dynamicPathEnabled;
+    /**
+     * @param paths 路线数据, 二维数组, 数组内每个元素为一条路径数据,
+     *  每个元素是一个数组, 数组包含的子元素为x, y坐标. 默认z高度为0.
+     * @example
+     * ```typescript
+     * const paths = new PathGroup([[
+     *   { x: -3.0271134856048567, y: -8.9271859189251 },
+     *   { x: 4.224184307967123, y: -9.642908272680536 },
+     *   { x: 2.224184307967123, y: -1.642908272680536 },
+     * ]]);
+     * stage.bindElement(paths);
+     * // 重新载入新路线组
+     * paths.load([
+     *   [{ x: 0, y: 0 }, { x: 4.224184307967123, y: -39.642908272680536 }],
+     *   ...
+     * ])
+     * ```
+     */
+    constructor(paths?: {
+        x: number;
+        y: number;
+    }[][], options?: {
+        groundParams?: GroundParameters;
+        floorModel?: FloorModel;
+        arrowImageURL?: string;
+        color?: string;
+        viewDistance?: number;
+        dynamicPathEnabled?: boolean;
+        width?: number;
+    });
+    /**
+     * 加载多条路线
+     * @param paths 路线数据
+     */
+    load(paths: {
+        x: number;
+        y: number;
+    }[][], options?: {
+        groundParams?: GroundParameters;
+        floorModel?: FloorModel;
+        arrowImageURL?: string;
+        color?: string;
+        viewDistance?: number;
+        dynamicPathEnabled?: boolean;
+        width?: number;
+    }): void;
+    updatePathZ(path: Path): void;
+    updatePathsZ(): void;
+    /** @ignore */
+    setPathSettings(camera: NS_THREE.Camera, viewDistance: number, dynamicPathEnabled: boolean): void;
+    /** @ignore */
+    update(): ElementFrameContext;
+    dispose(): void;
+}
+export { PathGroup };

package/lib/owlly/element/path-group.js

@@ -0,0 +1,171 @@
+import { Externals } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { Path } from './path';
+import { EventHub } from '../utils/event-hub';
+import { OwllyEvents } from '../utils/events';
+import { FloorModel } from './floor-model';
+import { PathUtils } from '../utils/path-utils';
+// import { PathUtils } from '../utils/path-utils';
+/** 楼层模型元素
+ * @noInheritDoc */
+class PathGroup extends Element {
+    /**
+     * @param paths 路线数据, 二维数组, 数组内每个元素为一条路径数据,
+     *  每个元素是一个数组, 数组包含的子元素为x, y坐标. 默认z高度为0.
+     * @example
+     * ```typescript
+     * const paths = new PathGroup([[
+     *   { x: -3.0271134856048567, y: -8.9271859189251 },
+     *   { x: 4.224184307967123, y: -9.642908272680536 },
+     *   { x: 2.224184307967123, y: -1.642908272680536 },
+     * ]]);
+     * stage.bindElement(paths);
+     * // 重新载入新路线组
+     * paths.load([
+     *   [{ x: 0, y: 0 }, { x: 4.224184307967123, y: -39.642908272680536 }],
+     *   ...
+     * ])
+     * ```
+     */
+    constructor(paths, options) {
+        super();
+        this.pathInitialized = false;
+        this.pathReloaded = false;
+        this.paths = [];
+        const params = options || {};
+        this.floorModel = params.floorModel;
+        this.groundParams = params.groundParams;
+        if (paths)
+            this.load(paths, options);
+        if (this.floorModel) {
+            if (this.floorModel.isModelLoaded()) {
+                this.pathReloaded = true;
+            }
+        }
+        this.eventListeners = {
+            onFloorModelLoaded: (e) => {
+                if (e !== this.floorModel)
+                    return;
+                this.pathReloaded = true;
+            },
+        };
+        EventHub.on(OwllyEvents.ELEMENT_LOADED, this.eventListeners.onFloorModelLoaded);
+    }
+    /**
+     * 加载多条路线
+     * @param paths 路线数据
+     */
+    load(paths, options) {
+        this.pathReloaded = false;
+        if (this.paths && this.paths.length) {
+            this.paths.forEach((p) => {
+                this.remove(p);
+                p.dispose();
+            });
+            this.emit(OwllyEvents.DISPOSE_ELEMENT, this.paths);
+        }
+        const params = options || {};
+        if (params.groundParams) {
+            this.groundParams = params.groundParams;
+        }
+        if (params.floorModel) {
+            this.floorModel = params.floorModel;
+        }
+        this.paths = paths.map((path) => {
+            const newPath = new Path(path, options);
+            this.add(newPath);
+            return newPath;
+        });
+        this.pathReloaded = true;
+    }
+    updatePathZ(path) {
+        const { pathMesh, arrowMeshes } = path;
+        const { THREE } = Externals.getInstance();
+        const geometry = pathMesh.geometry;
+        if (!geometry)
+            return;
+        const { array, count } = geometry.attributes.position;
+        // const { index: indices } = geometry;
+        for (let i = 0, j = 0; i < count; i += 1, j += 3) {
+            const x = array[j];
+            const y = array[j + 1];
+            let z = 0.5;
+            if (this.groundParams) {
+                const groundPoint = FloorModel.intersectWithGroundPlane(new THREE.Vector3(x, y, z), this.groundParams);
+                if (groundPoint) {
+                    z = groundPoint.z + PathUtils.PathMeshOffsetZ;
+                }
+            }
+            else if (this.floorModel) {
+                const groundPoint = this.floorModel.intersectGround(new THREE.Vector3(x, y, z));
+                // console.info('#PathArrow# groundPoint:', groundPoint);
+                if (groundPoint) {
+                    z = groundPoint.z + PathUtils.PathMeshOffsetZ;
+                }
+            }
+            array[j + 2] = z;
+        }
+        geometry.attributes.position.needsUpdate = true;
+        arrowMeshes.forEach((arrowMesh) => {
+            const { position } = arrowMesh;
+            if (this.groundParams) {
+                const groundPoint = FloorModel.intersectWithGroundPlane(position, this.groundParams);
+                if (groundPoint) {
+                    groundPoint.z += PathUtils.ArrowMeshOffsetZ;
+                    arrowMesh.position.copy(groundPoint);
+                }
+            }
+            else if (this.floorModel) {
+                const groundPoint = this.floorModel.intersectGround(position);
+                // console.info('#PathArrow# groundPoint:', groundPoint);
+                if (groundPoint) {
+                    groundPoint.z += PathUtils.ArrowMeshOffsetZ;
+                    arrowMesh.position.copy(groundPoint);
+                }
+            }
+        });
+    }
+    updatePathsZ() {
+        this.paths.forEach((path) => {
+            this.updatePathZ(path);
+        });
+    }
+    /** @ignore */
+    setPathSettings(camera, viewDistance, dynamicPathEnabled) {
+        this.paths.forEach((path) => {
+            path.setPathSettings(camera, viewDistance, dynamicPathEnabled);
+        });
+        this.dynamicPathEnabled = dynamicPathEnabled;
+    }
+    /** @ignore */
+    update() {
+        const frameContext = new ElementFrameContext(this);
+        if (!this.pathInitialized && this.pathReloaded) {
+            this.pathInitialized = true;
+        }
+        if (this.pathReloaded) {
+            this.updatePathsZ();
+            frameContext.needUpdate = true;
+            this.pathReloaded = false;
+        }
+        if (this.dynamicPathEnabled) {
+            this.paths.forEach((path) => {
+                path.update();
+            });
+        }
+        if (this.pathInitialized && !this.parent) {
+            frameContext.shouldPlaceElement = true;
+        }
+        return frameContext;
+    }
+    dispose() {
+        super.dispose();
+        this.paths.forEach((p) => {
+            this.remove(p);
+            p.dispose();
+        });
+        this.paths = [];
+        EventHub.off(OwllyEvents.ELEMENT_LOADED, this.eventListeners.onFloorModelLoaded);
+    }
+}
+export { PathGroup };

package/lib/owlly/element/path.d.ts

@@ -0,0 +1,99 @@
+import { NS_THREE } from '../stage/externals';
+import { ElementFrameContext, Element } from './element';
+import { FloorModel, GroundParameters } from './floor-model';
+/**
+ * 路径元素, 渲染路径箭头(暂未引入箭头Mesh)
+ * @noInheritDoc
+ */
+declare class Path extends Element {
+    private modelInitialized;
+    private gradientDistance;
+    pathMesh: NS_THREE.Mesh;
+    arrowMeshes: NS_THREE.Mesh[];
+    private pathMinX;
+    private pathMinY;
+    private pathDistance;
+    private pointMap;
+    private viewDistance;
+    private bindedCamera;
+    private dynamicPathEnabled;
+    private pathArrowMeshes;
+    /**
+     * @param path 路径
+     * @param options 可选参数集
+     * @param floorModel FloorModel对象，用于计算地面高度坐标
+     * @param groundParams GroundParameters对象，用于计算地面高度坐标
+     * @param color 路劲的颜色
+     * 当有groundParams时则优先使用它计算，忽略floorModel参数
+     */
+    constructor(path?: {
+        x: number;
+        y: number;
+    }[], options?: {
+        groundParams?: GroundParameters;
+        floorModel?: FloorModel;
+        arrowImageURL?: string;
+        color?: string;
+        viewDistance?: number;
+        dynamicPathEnabled?: boolean;
+        width?: number;
+    });
+    /**
+     *
+     * @param path 路径点二维坐标数组
+     * @param params 其它可选参数
+     * @param arrowImageRatio 箭头图像的宽高比，用于生成纹理坐标
+     * @param arrowImageURL 箭头图像URL
+     * @param floorModel FloorModel对象，用于计算地面高度坐标
+     * @param groundParams GroundParameters对象，用于计算地面高度坐标
+     * @param color 路劲的颜色
+     * 当存在groundParams时优先用它计算，忽略floorModel
+     */
+    static generatePathMesh(path: {
+        x: number;
+        y: number;
+    }[], params?: {
+        viewDistance?: number;
+        gradientDistance?: number;
+        arrowImageRatio?: number;
+        arrowImageURL?: string;
+        floorModel?: FloorModel;
+        groundParams?: GroundParameters;
+        color?: string;
+        dynamicPathEnabled?: boolean;
+        width?: number;
+    }): {
+        mesh: NS_THREE.Mesh;
+        arrowMeshes: {
+            arrowMesh: NS_THREE.Mesh;
+            index: number;
+        }[];
+        newPath: [number, number][];
+        pointMap: Map<string, Map<string, number[][]>>;
+        pathMinX: number;
+        pathMinY: number;
+        progressBuffer: Float32Array;
+        pathDistance: number[];
+    };
+    /**
+     * 载入路径
+     * @param path 路径
+     */
+    load(path: {
+        x: number;
+        y: number;
+    }[], options?: {
+        groundParams?: GroundParameters;
+        floorModel?: FloorModel;
+        arrowImageURL?: string;
+        color?: string;
+        viewDistance?: number;
+        dynamicPathEnabled?: boolean;
+        width?: number;
+    }): void;
+    /** @ignore */
+    update(): ElementFrameContext;
+    dispose(): void;
+    setPathSettings(camera: NS_THREE.Camera, viewDistance: number, dynamicPathEnabled: boolean): void;
+}
+export { Path };