@aibee/owlly 1.0.25

package/src/owlly/element/floor-model.ts

@@ -0,0 +1,290 @@
+import { GLTFLoader, GLTF } from '../../external/loaders/gltf-loader';
+import { Externals, NS_THREE } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { BasicTools } from '../utils/basic-tools';
+import { View } from '../view/view';
+import { Events } from '../utils/events';
+import { BVHTree, IntersectResult } from '../utils/bvh-tree';
+
+interface FloorModelViewConfiguration {
+  targetView: View;
+  visible: boolean;
+  meshMaterial?: NS_THREE.Material | NS_THREE.Material[];
+}
+
+/**
+ * 地面参数
+ */
+interface GroundParameters {
+  /** 铅垂方向向量(必须) */
+  downDirection: NS_THREE.Vector3;
+  /** 地面平面系数(可选): a * x + b * y + c * z + d = 0 */
+  groundPlane?: {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+  };
+}
+
+/**
+ * 楼层模型元素
+ * @noInheritDoc
+ */
+class FloorModel extends Element {
+  private modelInitialized: boolean;
+
+  private modelLoaded: boolean;
+
+  private mesh: NS_THREE.Mesh;
+
+  private bvh: BVHTree;
+
+  private raycaster: NS_THREE.Raycaster;
+
+  private groundParams: GroundParameters;
+
+  private meshMaterial: NS_THREE.Material | NS_THREE.Material[];
+
+  // private eventListeners: { onCurrentViewChanged: Function };
+
+  private viewConfigurations: Map<View, FloorModelViewConfiguration>;
+
+  private globalScale: number;
+
+  boundingBoxMesh: NS_THREE.Mesh;
+
+  private reloadTimes = 3;
+
+  /**
+   * @param url Mesh模型地址
+   */
+  constructor(url: string, useBVH = true, globalScale = 1) {
+    super();
+    const { THREE } = Externals.getInstance();
+    this.modelInitialized = false;
+    this.modelLoaded = false;
+    this.globalScale = globalScale;
+    this.setGroundParameters({ downDirection: new THREE.Vector3(0, 0, -1) });
+    this.viewConfigurations = new Map<View, FloorModelViewConfiguration>();
+    // this.eventListeners = {
+    //   onCurrentViewChanged: (view: View): void => {
+    //     let conf = {
+    //       visible: true,
+    //     } as FloorModelViewConfiguration;
+    //     if (this.viewConfigurations.has(view)) conf = this.viewConfigurations.get(view)!;
+    //     this.visible = conf.visible;
+    //     if (this.mesh) {
+    //       this.mesh.material = conf.meshMaterial || this.meshMaterial;
+    //     }
+    //   },
+    // };
+    // EventHub.on(OwllyEvents.RENDERING_VIEW_CHANGED, this.eventListeners.onCurrentViewChanged);
+    this.boundingBoxMesh = new THREE.Mesh();
+    this.boundingBoxMesh.visible = false;
+    this.add(this.boundingBoxMesh);
+    if (url) this.load(url, useBVH);
+  }
+
+  /**
+   * 设置地面参数
+   * @param params 地面参数
+   */
+  public setGroundParameters(params: GroundParameters): void {
+    this.groundParams = params;
+  }
+
+  /**
+   * 读取Mesh模型
+   * @param url Mesh模型地址
+   */
+  public load(url: string, useBVH = true, index = 0): void {
+    this.modelInitialized = false;
+    this.modelLoaded = false;
+    const { THREE } = Externals.getInstance();
+    const loader = new GLTFLoader();
+    loader.load(url, (gltf: GLTF): void => {
+      // this.modelNode = gltf.scene;
+      this.add(gltf.scene);
+      this.modelLoaded = true;
+      // this.needUpdate = true;
+      gltf.scene.traverse((obj) => {
+        if (obj instanceof THREE.Mesh) {
+          this.mesh = obj as THREE.Mesh;
+          this.meshMaterial = (obj as THREE.Mesh).material;
+          obj.geometry.scale(this.globalScale, this.globalScale, this.globalScale);
+        }
+      });
+      if (useBVH) {
+        this.bvh = BVHTree.createBVHTree(gltf.scene);
+      } else {
+        this.raycaster = new THREE.Raycaster();
+      }
+      const box = new THREE.Box3().setFromObject(gltf.scene);
+      const { max, min } = box;
+      this.boundingBoxMesh.geometry = new THREE.BoxBufferGeometry(max.x - min.x, max.y - min.y, max.z - min.z);
+      this.boundingBoxMesh.position.copy(max.clone().add(min.clone()).multiplyScalar(0.5));
+      this.emit(Events.ELEMENT_LOADED, this);
+    }, undefined, (error: ErrorEvent): void => {
+      const nextIndex = index + 1;
+      if (nextIndex > this.reloadTimes) {
+        this.emit(Events.ELEMENT_LOADED_ERROR, this, error);
+      } else {
+        this.load(url, useBVH, nextIndex);
+      }
+    });
+  }
+
+  public isModelLoaded(): boolean {
+    return this.modelLoaded;
+  }
+
+  /** @ignore */
+  public update(): ElementFrameContext {
+    const frameContext = new ElementFrameContext(this);
+    if (!this.modelInitialized && this.modelLoaded) {
+      this.modelInitialized = true;
+      frameContext.needUpdate = true;
+    }
+    if (this.modelInitialized && !this.parent) {
+      frameContext.shouldPlaceElement = true;
+    }
+    return frameContext;
+  }
+
+  // renderingViewChanged(view: View): void {
+  //   let conf = {
+  //     visible: true,
+  //   } as FloorModelViewConfiguration;
+  //   if (this.viewConfigurations.has(view)) conf = this.viewConfigurations.get(view)!;
+  //   this.visible = conf.visible;
+  //   if (this.mesh) {
+  //     this.mesh.material = conf.meshMaterial || this.meshMaterial;
+  //   }
+  // }
+
+  public render(): void{
+    if (this.mesh) {
+      if (this.meshMaterial !== this.mesh.material) {
+        const last = this.mesh.material;
+        this.mesh.material = this.meshMaterial;
+        if (last instanceof Array) {
+          last.forEach((l) => {
+            l.dispose();
+          });
+        } else {
+          last.dispose();
+        }
+      }
+    }
+  }
+
+  /**
+   * 配置在不同view中的显示状态
+   * @param configuration 配置
+   */
+  public addViewConfiguration(configuration: FloorModelViewConfiguration): void {
+    const prevConfig = this.viewConfigurations.get(configuration.targetView);
+    if (!configuration.meshMaterial && prevConfig) {
+      configuration.meshMaterial = prevConfig.meshMaterial;
+    }
+    this.viewConfigurations.set(configuration.targetView, configuration);
+  }
+
+  public addMeshMaterial(meshMaterial: NS_THREE.Material|NS_THREE.Material[]): void{
+    this.meshMaterial = meshMaterial;
+  }
+
+  public dispose(): void {
+    super.dispose();
+    BasicTools.dispose(this, true);
+    // EventHub.off(OwllyEvents.RENDERING_VIEW_CHANGED, this.eventListeners.onCurrentViewChanged);
+  }
+
+  public getBVHTree(): BVHTree {
+    return this.bvh;
+  }
+
+  /**
+   * 给定射线与模型的相交测试结果
+   * @param rayOrigin 射线起点
+   * @param rayDirection 射线方向
+   * @param backfaceCulling 是否忽略背面
+   */
+  public intersectRay(rayOrigin: NS_THREE.Vector3, rayDirection: NS_THREE.Vector3, backfaceCulling: boolean):
+    IntersectResult[] | null {
+    if (!this.bvh) {
+      return null;
+    }
+    const results = this.bvh.intersectRay(rayOrigin, rayDirection, backfaceCulling);
+    return results;
+  }
+
+  public static intersectWithGroundPlane(p: NS_THREE.Vector3, groundParams: GroundParameters): NS_THREE.Vector3 | null {
+    const direction = groundParams.downDirection;
+    const { THREE } = Externals.getInstance();
+    if (groundParams.groundPlane) {
+      // a * x + b * y + c * z + d = 0
+      const {
+        a, b, c, d,
+      } = groundParams.groundPlane;
+      const den = a * direction.x + b * direction.y + c * direction.z;
+      const num = -a * p.x - b * p.y - c * p.z - d;
+      const t = num / den;
+      if (!Number.isNaN(t) && Number.isFinite(t)) {
+        const intersection = new THREE.Vector3(
+          p.x + t * direction.x,
+          p.y + t * direction.y,
+          p.z + t * direction.z,
+        );
+        if (intersection.clone().sub(p).dot(direction) >= 0) {
+          return intersection;
+        }
+      }
+    }
+    return null;
+  }
+
+  private nearestIntersectionWithRaycaster(rayOrigin: NS_THREE.Vector3, rayDirection: NS_THREE.Vector3):
+    NS_THREE.Vector3 | null {
+    this.raycaster.set(rayOrigin, rayDirection);
+    const intersection = this.raycaster.intersectObject(this.children[0], true);
+    if (intersection.length === 0) return null;
+    let ret = null;
+    let minDist = Number.MAX_VALUE;
+    for (let i = 0; i < intersection.length; i += 1) {
+      const item = intersection[i];
+      const dist = item.distance;
+      if (dist >= 0.0 && dist < minDist) {
+        ret = item.point.clone();
+        minDist = dist;
+      }
+    }
+    return ret;
+  }
+
+  /**
+   * 给定参考点处对应的模型地面上的点
+   * 如果有地面参数则进行简化计算，否则使用射线求交点
+   * @param p 参考点
+   */
+  public intersectGround(p: NS_THREE.Vector3): NS_THREE.Vector3 | null {
+    let ret = FloorModel.intersectWithGroundPlane(p, this.groundParams);
+    if (ret) return ret;
+    if (this.bvh) {
+      const intersection = this.bvh.nearestIntersection(p, this.groundParams.downDirection);
+      if (intersection) {
+        ret = intersection.intersectionPoint;
+      }
+    } else if (this.raycaster) {
+      ret = this.nearestIntersectionWithRaycaster(p, this.groundParams.downDirection);
+    }
+    return ret;
+  }
+
+  public getMeshMaterial(): NS_THREE.Material | NS_THREE.Material[] {
+    return this.mesh.material;
+  }
+}
+
+export { FloorModel, FloorModelViewConfiguration, GroundParameters };