@aibee/owlly 1.0.25

package/src/owlly/element/path-group.ts

@@ -0,0 +1,212 @@
+import { Externals, NS_THREE } 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, GroundParameters } from './floor-model';
+import { PathUtils } from '../utils/path-utils';
+// import { PathUtils } from '../utils/path-utils';
+
+/** 楼层模型元素
+ * @noInheritDoc */
+class PathGroup extends Element {
+  private pathInitialized: boolean;
+
+  private pathReloaded: boolean;
+
+  private paths: Path[];
+
+  private floorModel: FloorModel|undefined;
+
+  private groundParams: GroundParameters|undefined;
+
+  private eventListeners: { onFloorModelLoaded: Function };
+
+  private dynamicPathEnabled: boolean;
+
+  /**
+   * @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;
+    //   gradientDistance?: number;
+      dynamicPathEnabled?: boolean;
+      width?: number;
+    }) {
+    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: Element): void => {
+        if (e !== this.floorModel) return;
+        this.pathReloaded = true;
+      },
+    };
+    EventHub.on(OwllyEvents.ELEMENT_LOADED, this.eventListeners.onFloorModelLoaded);
+  }
+
+  /**
+   * 加载多条路线
+   * @param paths 路线数据
+   */
+  public load(
+    paths: {x: number; y: number}[][],
+    options?: {
+      groundParams?: GroundParameters;
+      floorModel?: FloorModel;
+      arrowImageURL?: string;
+      color?: string;
+      viewDistance?: number;
+      // gradientDistance?: number;
+      dynamicPathEnabled?: boolean;
+      width?: number;
+    },
+  ): void {
+    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;
+  }
+
+  public updatePathZ(path: Path): void {
+    const { pathMesh, arrowMeshes } = path;
+    const { THREE } = Externals.getInstance();
+    const geometry = pathMesh.geometry as NS_THREE.BufferGeometry;
+    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 as number[])[j + 2] = z;
+    }
+    (geometry.attributes.position as NS_THREE.BufferAttribute).needsUpdate = true;
+    arrowMeshes.forEach((arrowMesh: NS_THREE.Mesh) => {
+      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);
+        }
+      }
+    });
+  }
+
+  public updatePathsZ(): void {
+    this.paths.forEach((path: Path) => {
+      this.updatePathZ(path);
+    });
+  }
+
+  /** @ignore */
+  public setPathSettings(camera: NS_THREE.Camera, viewDistance: number, dynamicPathEnabled: boolean): void {
+    this.paths.forEach((path: Path) => {
+      path.setPathSettings(camera, viewDistance, dynamicPathEnabled);
+    });
+    this.dynamicPathEnabled = dynamicPathEnabled;
+  }
+
+  /** @ignore */
+  public update(): ElementFrameContext {
+    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) => {
+        path.update();
+      });
+    }
+    if (this.pathInitialized && !this.parent) {
+      frameContext.shouldPlaceElement = true;
+    }
+    return frameContext;
+  }
+
+  public dispose(): void {
+    super.dispose();
+    this.paths.forEach((p) => {
+      this.remove(p);
+      p.dispose();
+    });
+    this.paths = [];
+    EventHub.off(OwllyEvents.ELEMENT_LOADED, this.eventListeners.onFloorModelLoaded);
+  }
+}
+
+export { PathGroup };