@aibee/owlly 1.0.25

package/src/owlly/overlay/path-overlay2.ts

@@ -0,0 +1,149 @@
+/* eslint-disable */
+import { Externals, NS_THREE } from '../stage/externals';
+import { Overlay } from './overlay';
+import { View } from '../view/view';
+import { MeshLine2D, ElementFrameContext} from '../element';
+/**
+ * POI覆盖层, 画线用
+ * @example
+ * ```typescript
+ * const PathOverlay2 = new PathOverlay2();
+ * // 任意View
+ * view.addOverlay(PathOverlay2);
+ * ```
+ */
+class PathOverlay2 extends Overlay {
+  private parent: View;
+
+  private renderThisFrame: boolean;
+
+  private pathMap: Map<string, Set<MeshLine2D>>;
+
+  private enabled: boolean;
+
+  static instanceId: number;
+
+  public camera: NS_THREE.Camera;
+
+  public scene: NS_THREE.Scene;
+  public renderer: NS_THREE.Renderer;
+  constructor() {
+    super();
+    this.pathMap = new Map();
+    this.renderThisFrame = true;
+    PathOverlay2.instanceId = 0;
+  }
+
+  init(parent: View): void {
+    const { THREE } = Externals.getInstance();
+    this.parent = parent;
+    this.scene = new THREE.Scene();
+    this.camera = this.parent.camera as NS_THREE.Camera;
+    this.renderer = this.parent.renderer as NS_THREE.Renderer;
+    this.pathMap = new Map();
+    this.enabled = true;
+    this.renderThisFrame = true;
+  }
+
+  update(): boolean {
+    let paths:any = [];
+    Array.from(this.pathMap).forEach(([name, pathGroup]) => {
+      paths = [...paths, ...Array.from(pathGroup)]
+    })
+    const pathNeedUpdate = paths.reduce(
+      (tf: boolean, e: MeshLine2D) => (this.handleElementUpdate(e.update()) || tf),
+      false,
+    )
+    if (this.renderThisFrame || pathNeedUpdate) {
+      this.renderThisFrame = false;
+      return true;
+    }
+    return false;
+  }
+
+  private handleElementUpdate(context: ElementFrameContext): boolean {
+    return context.needUpdate;
+  }
+
+
+  render(): void {
+    if (!this.enabled) return;
+    this.resize(this.parent.getViewWidth(), this.parent.getViewHeight());
+    (this.renderer as NS_THREE.WebGL1Renderer).clearDepth();
+    this.renderer.render(this.scene, this.camera);
+  }
+
+  public resize(containerWidth: number, containerHeight: number): void {
+    this.pathMap.forEach((pathGroup) => {
+      for (let path of pathGroup) {
+        path.resize(containerWidth, containerHeight);
+      }
+    });
+
+  }
+
+  public setEnabled(value: boolean): void {
+    this.enabled = value;
+  }
+
+  public createPath(points: [number, number, number][], options:any, ifClear = false): Set<MeshLine2D>{
+    if (ifClear) {
+      this.clearPaths();
+    }
+    if (!this.scene) throw Error('pathOverlay need bind a view, use view.addOverlay()');
+    const pathGroup:Set<MeshLine2D> = new Set();
+    this.renderThisFrame = true;
+    PathOverlay2.instanceId++;
+    if (options.strokeWidth && options.strokeColor) {
+      const borPath = new MeshLine2D(points, {...options, strokeWidth: 0, width: (options.width + options.strokeWidth * 2), color: options.strokeColor, renderPixelLine: true});
+      const borName = `border_${PathOverlay2.instanceId}`;
+      borPath.name = borName;
+      pathGroup.add(borPath);
+      this.scene.add(borPath);
+    }
+    const path = new MeshLine2D(points, {...options,strokeWidth:0, renderPixelLine: true});
+    const pathId = PathOverlay2.instanceId;
+    const name = pathId+'';
+    path.name = name;
+    pathGroup.add(path);
+    this.scene.add(path);
+    // // console.log('path.testLines.', path.testLines)
+    // path.testLines.forEach((v: any) => {
+    //   this.scene.add(v);
+    // })
+    this.pathMap.set(name, pathGroup as Set<MeshLine2D>);
+    return pathGroup;
+  }
+
+  public removePath(path: MeshLine2D): void {
+    const name = path.name;
+    const curPathGroup = this.pathMap.get(name);
+    if (curPathGroup) {
+      for (let path of curPathGroup) {
+        this.scene.remove(path);
+        path.dispose();
+      }
+      this.pathMap.delete(name);
+      this.renderThisFrame = true;
+    }
+  }
+
+  public clearPaths(): void {
+    this.pathMap.forEach((pathGroup) => {
+      for (let path of pathGroup) {
+        this.scene.remove(path);
+        path.dispose();
+      }
+    });
+    this.pathMap.clear();
+    this.renderThisFrame = true;
+  }
+
+  public dispose(): void {
+    this.clearPaths();
+  }
+}
+
+export {
+  PathOverlay2
+}