@realsee/dnalogel 2.0.2 → 2.1.0-alpha.10

package/libs/floorplan/ModelFloorplanPlugin/typing.d.ts

@@ -1 +1,107 @@
-export * from '../typings';
+import type { FLOOR_PLAN_ATTACHED_TO } from '../constant';
+import type * as BasePlugin from '../../base/BasePluginWithData';
+import type { FloorplanServerData } from '../typings/floorplanServerData';
+import type { FloorplanData, FloorplanRoomItem } from '../typings/floorplanData';
+export interface State extends BasePlugin.State {
+    visible: boolean;
+    config: Config;
+}
+export interface Config {
+    /** 指北针的显示文案，默认为 '北' */
+    northDesc: string;
+    /** 户型图展示时，模型的透明度，默认为 1 */
+    modelOpacity: number;
+    /** 鼠标放置在分间上时，是否要自动高亮分间，默认为 true */
+    hoverEnable: boolean;
+    /** 是否要启用指北针功能，默认为 true */
+    compassEnable: boolean;
+    /** Five 切换到 Topview Mode 时，是否自动展示户型图，默认为 true */
+    autoShowEnable: boolean;
+    /** 是否要启用户型图分间标尺功能，默认为 true */
+    ruleLabelsEnable: boolean;
+    /** 是否要启用户型图分间标签功能，默认为 true */
+    roomLabelsEnable: boolean;
+    /** 自定义「雷达」图标 */
+    cameraImageUrl: string;
+    /** 计算户型图大小时，以模型的哪个高度为依据，默认为 BOUNDING_CENTER
+     * - FLOOR_PLAN_ATTACHED_TO.FLOOR: 户型图大小与模型的地板进行贴合
+     * - FLOOR_PLAN_ATTACHED_TO.CEILING: 户型图大小与模型的天花板进行贴合
+     * - FLOOR_PLAN_ATTACHED_TO.BOUNDING_CENTER: 户型图大小与模型的中心进行贴合
+     */
+    attachedTo: FLOOR_PLAN_ATTACHED_TO;
+    /** 分间标签的自定义函数，通过返回自定义 DOM 替换对应分间的标签 */
+    getLabelElement: undefined | ((room: FloorplanRoomItem) => Element | null);
+    /** 是否支持房屋标签自适应展示，默认为 true
+     * @description
+     * * 标签边框超过房间边框时，自动隐藏；不超过时自动展示。
+     * * 鼠标 hover 时，自动展示。
+     * */
+    adaptiveRoomLabelVisibleEnable: boolean;
+}
+export interface Parameters extends Partial<Config> {
+    selector?: string | Element;
+    scale?: number;
+}
+export interface ViewEvent {
+    /** 是否是用户滑动模型导致的户型图自动展示/消失 */
+    auto: boolean;
+    /** 是否是用户操作 */
+    userAction: boolean;
+}
+export interface EventMap extends BasePlugin.EventMap<State, FloorplanData> {
+    /**
+     * 展示结束的回调
+     * @param event.auto 是否是自动操作
+     * @param event.userAction 是否是用户操作
+     */
+    showAnimationEnded: (event: ViewEvent) => void;
+    /** visible 从 false 到 true 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    show: (event: ViewEvent) => void;
+    /** visible 从 true 到 false 的回调
+     * @param event.auto 是否是自动操作
+     * @param event.userAction 是否是用户操作
+     */
+    hide: (event: ViewEvent) => void;
+    /** enabled 从 false 到 true 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    enable: (event: {
+        userAction: boolean;
+    }) => void;
+    /** enabled 从 true 到 false 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    disable: (event: {
+        userAction: boolean;
+    }) => void;
+    /**
+     * 点击户型图的回调
+     * @return 当返回 false 时，会阻止默认行为
+     */
+    click: () => boolean | void;
+}
+export interface PluginServerData extends BasePlugin.ServerData {
+    version: number;
+    data: FloorplanServerData;
+}
+export interface ShowOptions {
+    /** 展示户型图时，希望到达的楼层数 */
+    floorIndex: number;
+    /** 是否自动展示 */
+    isAutoShow: boolean;
+    /** 展示户型图时，模型透明度 */
+    modelOpacity: number;
+    /** 是否需要 opacity 动画 */
+    immediately: boolean;
+    /** 是否是用户操作 */
+    userAction: boolean;
+}
+export interface HideOptions {
+    /** 是否自动隐藏 */
+    isAutoHide: boolean;
+    /** 是否是用户操作 */
+    userAction: boolean;
+}
+export { FloorplanData as PluginData };

package/libs/floorplan/ModelFloorplanPlugin/typing.js

@@ -1 +1 @@
-export * from '../typings';
+export {};

package/libs/floorplan/PanoFloorplanRadarPlugin/Components/Camera.js

@@ -18,7 +18,7 @@ import { CAMERA_IMAGE } from '../../Assets/camera';
 import throttle from '../../../shared-utils/throttle';
 
 function add_css(target) {
-	append_styles(target, "svelte-1ty3s4p", ".plugin-radar__camera-wrapper.svelte-1ty3s4p{width:100%;height:100%;position:absolute;pointer-events:none}.plugin-radar__camera-position.svelte-1ty3s4p{position:absolute;left:0;top:0;width:0;height:0;transform:none;pointer-events:none;transition:transform 1s linear}.plugin-radar__camera-rotate.svelte-1ty3s4p{position:absolute;left:-0.78125rem;top:-0.78125rem;width:0.88542rem;height:0.88542rem;transform-origin:0.78125rem 0.78125rem;transform:rotate(45deg);background-repeat:no-repeat;background-size:100%}");
+	append_styles(target, "svelte-1nqrlxd", ".plugin-radar__camera-wrapper.svelte-1nqrlxd{width:100%;height:100%;position:absolute;pointer-events:none}.plugin-radar__camera-position.svelte-1nqrlxd{position:absolute;left:0;top:0;width:0;height:0;transform:none;pointer-events:none;transition:transform 1s linear}.plugin-radar__camera-rotate.svelte-1nqrlxd{position:absolute;left:-0.9375rem;top:-0.9375rem;width:1.0625rem;height:1.0625rem;transform-origin:0.9375rem 0.9375rem;transform:rotate(45deg);background-repeat:no-repeat;background-size:100%}");
 }
 
 function create_fragment(ctx) {
@@ -31,12 +31,12 @@ function create_fragment(ctx) {
 			div2 = element("div");
 			div1 = element("div");
 			div0 = element("div");
-			attr(div0, "class", "plugin-radar__camera-rotate svelte-1ty3s4p");
+			attr(div0, "class", "plugin-radar__camera-rotate svelte-1nqrlxd");
 			set_style(div0, "background-image", "url(" + (/*cameraImageUrl*/ ctx[0] || CAMERA_IMAGE) + ")");
 			set_style(div0, "transform", /*rotateTransform*/ ctx[1], false);
-			attr(div1, "class", "plugin-radar__camera-position svelte-1ty3s4p");
+			attr(div1, "class", "plugin-radar__camera-position svelte-1nqrlxd");
 			set_style(div1, "transform", /*positionTransform*/ ctx[2], false);
-			attr(div2, "class", "plugin-radar__camera-wrapper svelte-1ty3s4p");
+			attr(div2, "class", "plugin-radar__camera-wrapper svelte-1nqrlxd");
 		},
 		m(target, anchor) {
 			insert(target, div2, anchor);

package/libs/floorplan/TopviewFloorplanPlugin/Controller.d.ts

@@ -1,8 +1,7 @@
-import type { PartialDeep } from 'type-fest';
 import type { BaseOptions } from '../../base/BasePlugin';
 import type { Five } from '@realsee/five';
 import type { FloorplanServerData } from '../typings/floorplanServerData';
-import type { State, Config, EventMap, Parameters, PluginData, PluginServerData } from './typing';
+import type { State, EventMap, Parameters, PluginData, PluginServerData } from './typing';
 import * as BasePlugin from '../../base/BasePluginWithData';
 export declare class Controller extends BasePlugin.Controller<State, EventMap, PluginServerData, PluginData> {
     name: string;
@@ -39,8 +38,7 @@ export declare class Controller extends BasePlugin.Controller<State, EventMap, P
     /** 销毁插件 */
     dispose: () => void;
     /** 更改插件 State */
-    setState(state: PartialDeep<State>, options?: BaseOptions): void;
-    changeConfigs(config: Partial<Config>, userAction?: boolean): void;
+    setState(state: Partial<State>, options?: BaseOptions): void;
     protected formatData(serverData: PluginServerData): Promise<PluginData>;
     private _show;
     private _hide;

package/libs/floorplan/TopviewFloorplanPlugin/Controller.js

@@ -280,8 +280,6 @@ export class Controller extends BasePlugin.Controller {
             attachedTo: FLOOR_PLAN_ATTACHED_TO.BOUNDING_CENTER,
             getLabelElement: undefined,
             adaptiveRoomLabelVisibleEnable: true,
-            getRoomAreaText: (size) => (size / 1000000).toFixed(1) + '㎡',
-            getRuleDistanceText: (distance) => distance.toString()
         };
         const paramsConfig = params ? omit(params, ['selector', 'scale']) : {};
         const config = Object.assign(Object.assign({}, baseConfig), paramsConfig);
@@ -383,10 +381,6 @@ export class Controller extends BasePlugin.Controller {
             state.visible ? this._show(options) : this._hide(options);
         }
     }
-    changeConfigs(config, userAction = true) {
-        this.updateState({ config }, userAction);
-        this.render();
-    }
     async formatData(serverData) {
         return await formatData(serverData.data);
     }
@@ -395,7 +389,7 @@ export class Controller extends BasePlugin.Controller {
             return;
         this.isHiddenByHideFunc = false;
         const { userAction } = options;
-        this.hooks.emit('show', { userAction, auto: false });
+        this.hooks.emit('show', { userAction });
         if (this.five.getCurrentState().mode !== 'Topview') {
             await changeMode(this.five, ['Topview', undefined, undefined, userAction]);
         }
@@ -405,14 +399,14 @@ export class Controller extends BasePlugin.Controller {
         const renderDuration = 500;
         const modelOpacity = this.state.config.modelOpacity;
         changeModelCanvasOpacity(this.five, modelOpacity, renderDuration);
-        this.hooks.emit('showAnimationEnded', { userAction, auto: false });
+        this.hooks.emit('showAnimationEnded', { userAction });
         this.render();
     }
     async _hide(options) {
         if (!this.state.enabled)
             return;
         const { userAction } = options;
-        this.hooks.emit('hide', { userAction, auto: false });
+        this.hooks.emit('hide', { userAction });
         const modelOpacity = 1;
         const renderDuration = 0;
         changeModelCanvasOpacity(this.five, modelOpacity, renderDuration);
@@ -429,8 +423,7 @@ export class Controller extends BasePlugin.Controller {
     }
     updateState(state, userAction) {
         const prevState = this.state;
-        const config = state.config ? Object.assign(Object.assign({}, prevState.config), state.config) : prevState.config;
-        this.state = Object.assign(Object.assign(Object.assign({}, this.state), state), { config });
+        this.state = Object.assign(Object.assign({}, this.state), state);
         if (equal(this.state, prevState, { deep: true }))
             return;
         this.hooks.emit('stateChange', { state: this.state, prevState, userAction });

package/libs/floorplan/TopviewFloorplanPlugin/typing.d.ts

@@ -1,11 +1,86 @@
-import type * as FloorplanPlugin from '../typings';
-export * from '../typings';
-export interface Config extends FloorplanPlugin.Config {
+import type { FLOOR_PLAN_ATTACHED_TO } from '../constant';
+import type * as BasePlugin from '../../base/BasePluginWithData';
+import type { FloorplanServerData } from '../typings/floorplanServerData';
+import type { FloorplanData, FloorplanRoomItem } from '../typings/floorplanData';
+export interface Config {
+    /** 指北针的显示文案，默认为 '北' */
+    northDesc: string;
+    /** 户型图展示时，模型的透明度，默认为 1 */
+    modelOpacity: number;
+    /** 鼠标放置在分间上时，是否要自动高亮分间，默认为 true */
+    hoverEnable: boolean;
     /** 是否开启放大缩小和拖动功能，默认为 false */
     gestureEnable: boolean;
-    /** 点击房间时，是否阻止跳转到被点房间的全景态点位上，默认为 false */
+    /** 是否要启用指北针功能，默认为 true */
+    compassEnable: boolean;
+    /** Five 切换到 Topview Mode 时，是否自动展示户型图，默认为 true */
+    autoShowEnable: boolean;
+    /** 是否要启用户型图分间标尺功能，默认为 true */
+    ruleLabelsEnable: boolean;
+    /** 是否要启用户型图分间标签功能，默认为 true */
+    roomLabelsEnable: boolean;
+    /** 自定义「雷达」图标 */
+    cameraImageUrl: string;
+    /** 点击房间时，是否需要跳转到被点房间的全景态点位上，默认为 true */
     preventRoomClick?: boolean;
+    /** 计算户型图大小时，以模型的哪个高度为依据，默认为 BOUNDING_CENTER
+     * - FLOOR_PLAN_ATTACHED_TO.FLOOR: 户型图大小与模型的地板进行贴合
+     * - FLOOR_PLAN_ATTACHED_TO.CEILING: 户型图大小与模型的天花板进行贴合
+     * - FLOOR_PLAN_ATTACHED_TO.BOUNDING_CENTER: 户型图大小与模型的中心进行贴合
+     */
+    attachedTo: FLOOR_PLAN_ATTACHED_TO;
+    /** 分间标签的自定义函数，通过返回自定义 DOM 替换对应分间的标签 */
+    getLabelElement: undefined | ((room: FloorplanRoomItem) => Element | null);
+    /** 是否支持房屋标签自适应展示，默认为 true
+     * @description
+     * * 标签边框超过房间边框时，自动隐藏；不超过时自动展示。
+     * * 鼠标 hover 时，自动展示。
+     * */
+    adaptiveRoomLabelVisibleEnable: boolean;
 }
-export interface State extends FloorplanPlugin.State {
+export interface State extends BasePlugin.State {
+    visible: boolean;
     config: Config;
 }
+export interface EventMap extends BasePlugin.EventMap<State, FloorplanData> {
+    /** 展示结束的回调
+     * @param event.userAction 是否是用户操作
+     */
+    showAnimationEnded: (event: {
+        userAction: boolean;
+    }) => void;
+    /** visible 从 false 到 true 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    show: (event: {
+        userAction: boolean;
+    }) => void;
+    /** visible 从 true 到 false 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    hide: (event: {
+        userAction: boolean;
+    }) => void;
+    /** enabled 从 false 到 true 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    enable: (event: {
+        userAction: boolean;
+    }) => void;
+    /** enabled 从 true 到 false 的回调
+     * @param event.userAction 是否是用户操作
+     */
+    disable: (event: {
+        userAction: boolean;
+    }) => void;
+}
+/** 插件初始化参数 */
+export interface Parameters extends Partial<Config> {
+    selector?: string | Element;
+    scale?: number;
+}
+export interface PluginServerData extends BasePlugin.ServerData {
+    version: number;
+    data: FloorplanServerData;
+}
+export { FloorplanData as PluginData };

package/libs/floorplan/TopviewFloorplanPlugin/typing.js

@@ -1 +1 @@
-export * from '../typings';
+export {};

package/libs/index.d.ts

@@ -17,4 +17,6 @@ export * from './ItemLabelPlugin';
 export * from './PanoDoorLabelPlugin';
 export * from './GuideLinePlugin';
 export * from './CruisePlugin';
+export * from './PanoTagPlugin';
+export * from './Object3DHelperPlugin';
 export declare const DnalogelVersion = "2.0.0-alpha.58";

package/libs/index.js

@@ -32,4 +32,8 @@ export * from './PanoDoorLabelPlugin';
 export * from './GuideLinePlugin';
 // 漫游插件
 export * from './CruisePlugin';
+// 全景标签插件
+export * from './PanoTagPlugin';
+// 三维物体编辑插件
+export * from './Object3DHelperPlugin';
 export const DnalogelVersion = '2.0.0-alpha.58';

package/libs/shared-utils/Object3DHelper/Base/BaseController.d.ts

@@ -0,0 +1,48 @@
+import * as THREE from 'three';
+import { Subscribe } from '../../Subscribe';
+import type { HelperEventMap } from '../typings';
+import type { BaseHelper } from './BaseHelper';
+import DomEvents from '../utils/threex/domevents';
+export declare let originOpacity: {
+    opacity: number;
+} | null;
+export declare abstract class BaseController<T extends BaseHelper = BaseHelper, K extends THREE.Object3D = THREE.Object3D> {
+    hooks: Subscribe<HelperEventMap>;
+    helperObject3D: T;
+    originObject3D: K;
+    protected camera: THREE.Camera;
+    protected model: THREE.Object3D;
+    protected scene: THREE.Scene;
+    protected container: HTMLElement;
+    protected domEvents: DomEvents;
+    protected isDragging: boolean;
+    protected onRender: () => void;
+    protected enabled: boolean;
+    constructor(camera: THREE.Camera, model: THREE.Object3D, originObject3D: K, helperObject3D: T, container: HTMLElement, scene: THREE.Scene, onRender?: () => void);
+    initialHelperPosition(): void;
+    initialHelperQuaternion(): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    setOpacity(opacity: number): void;
+    restoreOpacity(): void;
+    setOriginOpacityProperty(): void;
+    updateHelperPosition(): void;
+    updateHelperQuaternion(): void;
+    applyHelperMatrix4(matrix4: THREE.Matrix4): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    applyHelperScaleMatrix4(matrix4: THREE.Matrix4, params?: {
+        origin?: THREE.Vector3;
+        helperOrigin?: THREE.Vector3;
+    }): void;
+    onWantsTapGesture: (raycaster: THREE.Raycaster) => false | void;
+    onWantsGesture(type: 'press' | 'pan' | string, pointers: {
+        x: number;
+        y: number;
+    }[], final: boolean): false | void;
+    protected render(): void;
+    protected hoverListener(object3D: THREE.Object3D | undefined | THREE.Group | (THREE.Object3D | undefined | THREE.Group)[], hoverColor?: THREE.Color | string | number, hoverOpacity?: number): () => void;
+    private getIntersectObject;
+}

package/libs/shared-utils/Object3DHelper/Base/BaseController.js

@@ -0,0 +1,271 @@
+import * as THREE from 'three';
+import { Subscribe } from '../../Subscribe';
+import DomEvents from '../utils/threex/domevents';
+import { notNil } from '../../isNil';
+import { CSS3DObjectPlus } from '../../../CSS3DRenderPlugin/utils/CSS3DObjectPlus';
+export let originOpacity = null;
+export class BaseController {
+    constructor(camera, model, originObject3D, helperObject3D, container, scene, onRender) {
+        Object.defineProperty(this, "hooks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Subscribe()
+        });
+        Object.defineProperty(this, "helperObject3D", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "originObject3D", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "camera", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scene", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "container", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "domEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isDragging", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "onRender", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "enabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "onWantsTapGesture", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (raycaster) => {
+                const selectedObject = this.getIntersectObject(raycaster);
+                if (selectedObject)
+                    return false;
+                return;
+            }
+        });
+        this.camera = camera;
+        this.model = model;
+        this.originObject3D = originObject3D;
+        this.helperObject3D = helperObject3D;
+        this.container = container;
+        this.scene = scene;
+        this.domEvents = new DomEvents(camera, container);
+        this.onRender = onRender !== null && onRender !== void 0 ? onRender : (() => { });
+        this.initialHelperPosition();
+        this.initialHelperQuaternion();
+        this.enable();
+    }
+    initialHelperPosition() {
+        this.helperObject3D.updatePosition();
+    }
+    initialHelperQuaternion() {
+        this.helperObject3D.updateQuaternion();
+    }
+    enable() {
+        if (this.enabled)
+            return;
+        this.enabled = true;
+        this.scene.add(this.helperObject3D);
+        this.render();
+    }
+    disable() {
+        if (!this.enabled)
+            return;
+        this.enabled = false;
+        this.scene.remove(this.helperObject3D);
+        this.render();
+    }
+    show() {
+        this.helperObject3D.show();
+        this.render();
+    }
+    hide() {
+        this.helperObject3D.hide();
+        this.render();
+    }
+    dispose() {
+        this.helperObject3D.dispose();
+        this.scene.remove(this.helperObject3D);
+        this.render();
+    }
+    setOpacity(opacity) {
+        this.setOriginOpacityProperty();
+        const originObject3D = this.originObject3D;
+        if (originObject3D instanceof THREE.Mesh) {
+            originObject3D.material.opacity = opacity;
+        }
+        if (originObject3D instanceof CSS3DObjectPlus) {
+            originObject3D.container.style.opacity = opacity;
+        }
+        this.render();
+    }
+    restoreOpacity() {
+        if (originOpacity === null)
+            return;
+        const originObject3D = this.originObject3D;
+        if (originObject3D instanceof THREE.Mesh) {
+            originObject3D.material.opacity = originOpacity.opacity;
+        }
+        if (originObject3D instanceof CSS3DObjectPlus) {
+            originObject3D.container.style.opacity = originOpacity.opacity;
+        }
+        this.render();
+    }
+    setOriginOpacityProperty() {
+        var _a;
+        if (originOpacity === null) {
+            const originObject3D = this.originObject3D;
+            if (originObject3D instanceof THREE.Mesh) {
+                originOpacity = {
+                    opacity: originObject3D.material.opacity,
+                };
+            }
+            if (originObject3D instanceof CSS3DObjectPlus) {
+                originOpacity = {
+                    opacity: (_a = originObject3D.container.style.opacity) !== null && _a !== void 0 ? _a : 1,
+                };
+            }
+        }
+    }
+    updateHelperPosition() {
+        this.helperObject3D.updatePosition();
+    }
+    updateHelperQuaternion() {
+        this.helperObject3D.updateQuaternion();
+    }
+    // public setHelperPosition(position: THREE.Vector3) {
+    //   this.helperObject3D.setPosition(position)
+    // }
+    applyHelperMatrix4(matrix4) {
+        this.helperObject3D.applyMatrix4(matrix4);
+    }
+    applyHelperQuaternion(quaternion, origin) {
+        this.helperObject3D.applyHelperQuaternion(quaternion, origin);
+    }
+    applyHelperScaleMatrix4(matrix4, params) {
+        this.helperObject3D.applyHelperScaleMatrix4(matrix4, params);
+    }
+    onWantsGesture(type, pointers, final) {
+        if (this.isDragging)
+            return false;
+    }
+    render() {
+        this.onRender();
+    }
+    hoverListener(object3D, hoverColor = 0xffffff, hoverOpacity = 1) {
+        const objects = (Array.isArray(object3D) ? object3D : [object3D]).filter(notNil);
+        const disposers = [];
+        for (const object of objects) {
+            if (object instanceof THREE.Mesh || object instanceof THREE.Group) {
+                const meshes = object instanceof THREE.Group ? object.children.filter((child) => child instanceof THREE.Mesh) : [object];
+                meshes.forEach((mesh) => {
+                    ;
+                    mesh['__originalColor__'] = mesh.material.color.clone();
+                    mesh['__originalOpacity__'] = mesh.material.opacity;
+                });
+                const setHoverColor = () => {
+                    meshes.forEach((mesh) => {
+                        mesh.material.color.set(hoverColor);
+                        mesh.material.opacity = hoverOpacity;
+                    });
+                    this.render();
+                };
+                const resetColor = () => {
+                    meshes.forEach((mesh) => {
+                        mesh.material.color.copy(mesh['__originalColor__']);
+                        mesh.material.opacity = mesh['__originalOpacity__'];
+                    });
+                    this.render();
+                };
+                const handleMouseover = () => {
+                    if (this.isDragging)
+                        return;
+                    setHoverColor();
+                };
+                const handleMouseout = () => {
+                    if (this.isDragging)
+                        return;
+                    resetColor();
+                };
+                for (const mesh of meshes) {
+                    this.domEvents.addEventListener(mesh, 'mouseover', handleMouseover);
+                    this.domEvents.addEventListener(mesh, 'mouseout', handleMouseout);
+                    this.hooks.on('moveStart', setHoverColor);
+                    this.hooks.on('moveEnd', resetColor);
+                    this.hooks.on('rotateEnd', resetColor);
+                    disposers.push(() => {
+                        this.domEvents.removeEventListener(mesh, 'mouseover', handleMouseover);
+                        this.domEvents.removeEventListener(mesh, 'mouseout', handleMouseout);
+                        this.hooks.off('moveStart', setHoverColor);
+                        this.hooks.off('moveEnd', resetColor);
+                        this.hooks.off('rotateEnd', resetColor);
+                    });
+                }
+            }
+        }
+        return () => disposers.forEach((disposer) => disposer === null || disposer === void 0 ? void 0 : disposer());
+    }
+    getIntersectObject(raycaster) {
+        const cameraPosition = this.camera.position;
+        const object = this.helperObject3D;
+        // 如果当前没有模型，则不存在模型被点击
+        if (!object)
+            return undefined;
+        // 如果存在模型，需要判断模型与射线的交点和 model 与射线的交点的远近
+        let objectIntersection;
+        const intersection = raycaster.intersectObject(object, true)[0];
+        if (!intersection)
+            return undefined;
+        objectIntersection = intersection;
+        objectIntersection.object = object;
+        if (!objectIntersection)
+            return undefined;
+        // 如果 five model intersection 更近，返回 undefined
+        if (this.model['intersectRaycaster']) {
+            const modelIntersection = this.model.intersectRaycaster(raycaster)[0];
+            if (modelIntersection && modelIntersection.point.distanceTo(cameraPosition) < objectIntersection.point.distanceTo(cameraPosition))
+                return undefined;
+        }
+        return objectIntersection.object;
+    }
+}