@realsee/dnalogel 2.1.0-alpha.13 → 2.1.0-alpha.15

package/libs/src/ModelRoomLabelPlugin/typings.d.ts

@@ -0,0 +1,35 @@
+export interface ModelRoomLabelPluginData {
+    model_room_labels: Readonly<{
+        id: string;
+        name: string;
+        longitude: number;
+        pano_index: number;
+        floor_index: number;
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }>[];
+}
+export interface RoomLabel {
+    /** 房屋 ID */
+    readonly id: string;
+    /** 房屋名 */
+    readonly name: string;
+    /** 走到对应 panoIndex 时 five 的水平角度 */
+    readonly longitude: number;
+    /** 点击标签会走到的 panoIndex */
+    readonly panoIndex: number;
+    /** 所处楼层 */
+    readonly floorIndex: number;
+    /** 引导标签的三维坐标，一般是房屋中心点 */
+    readonly position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    zIndex: number;
+    visible: boolean;
+    transform: string;
+}

package/libs/src/ModelRoomLabelPlugin/typings.js

@@ -0,0 +1 @@
+export {};

package/libs/src/ModelRoomLabelPlugin/utils/parseData.d.ts

@@ -0,0 +1,3 @@
+import type { ModelRoomLabelPluginData, RoomLabel } from '../typings';
+/** @description 下划线转驼峰 */
+export declare function parseModelRoomLabelPluginData(data: ModelRoomLabelPluginData): RoomLabel[];

package/libs/src/ModelRoomLabelPlugin/utils/parseData.js

@@ -0,0 +1,14 @@
+/** @description 下划线转驼峰 */
+export function parseModelRoomLabelPluginData(data) {
+    return data.model_room_labels.map(({ id, pano_index, floor_index, name, position, longitude }) => ({
+        id,
+        name,
+        position,
+        longitude,
+        panoIndex: pano_index,
+        floorIndex: floor_index,
+        zIndex: 0,
+        visible: false,
+        transform: '',
+    }));
+}

package/libs/src/ModelTVVideoPlugin/Plugin.d.ts

@@ -0,0 +1,4 @@
+import type { FivePlugin } from '@realsee/five';
+import type { ModelTVVideoPluginExportType, ModelTVVideoPluginParameterType } from "./typings";
+export declare const ModelTVVideoPlugin: FivePlugin<ModelTVVideoPluginParameterType, ModelTVVideoPluginExportType>;
+export default ModelTVVideoPlugin;

package/libs/src/ModelTVVideoPlugin/Plugin.js

@@ -0,0 +1,254 @@
+import * as THREE from 'three';
+import { parseModelTVVideoPoints } from "./utils/parseData";
+export const ModelTVVideoPlugin = (five, { videoElement }) => {
+    const state = {
+        videoMeshes: [],
+        videoTextureEnabled: false,
+        videoSource: '',
+        rectPoints: [],
+        enabled: false,
+        videoElement: videoElement,
+    };
+    const setMuted = (muted) => {
+        if (state.videoTexture) {
+            state.videoTexture.image.muted = muted;
+            state.videoTexture.image.play();
+        }
+    };
+    const getMuted = () => {
+        if (state.videoTexture)
+            return state.videoTexture.image.muted;
+        else
+            return true;
+    };
+    const enable = () => {
+        if (state.enabled)
+            return;
+        if (!state.videoTexture)
+            return;
+        state.enabled = true;
+        state.videoMeshes = createPanoVideoMeshes();
+        console.log('state.videoMeshes', state.videoMeshes);
+        state.videoMeshes.forEach((mesh) => five.scene.add(mesh));
+        const play = () => {
+            console.log('play', state.videoTexture);
+            if (!state.videoTexture)
+                return;
+            const timeupdate = () => {
+                var _a;
+                if (!state.videoTexture)
+                    return;
+                (_a = state.videoTexture) === null || _a === void 0 ? void 0 : _a.image.removeEventListener('timeupdate', timeupdate);
+                state.videoTextureEnabled = true;
+                state.videoMeshes.forEach((mesh) => {
+                    if (mesh.material.map !== state.videoTexture)
+                        mesh.material.map = state.videoTexture;
+                });
+                five.needsRender = true;
+            };
+            state.videoTexture.image.addEventListener('timeupdate', timeupdate);
+            if (state.videoTexture && state.videoMeshes.length) {
+                state.videoTexture.image.play();
+            }
+        };
+        if (five.model.loaded)
+            play();
+        else {
+            return five.once('modelLoaded', () => play());
+        }
+    };
+    const disable = () => {
+        if (!state.enabled)
+            return;
+        state.enabled = false;
+        state.videoMeshes.forEach((mesh) => {
+            mesh.geometry.dispose();
+            mesh.material.dispose();
+            five.scene.remove(mesh);
+            if (state.videoTexture)
+                state.videoTexture.image.pause();
+        });
+        state.videoMeshes = [];
+        five.needsRender = true;
+    };
+    const createPanoVideoMeshes = () => {
+        return state.rectPoints.map((points, index) => {
+            const geometry = new THREE.BufferGeometry();
+            const segments = 128;
+            const verticesArray = [];
+            verticesArray.push(points[0].x, points[0].y, points[0].z);
+            for (let i = 1; i < segments; i++) {
+                verticesArray.push(points[0].x + ((points[1].x - points[0].x) * i) / segments, points[0].y + ((points[1].y - points[0].y) * i) / segments, points[0].z + ((points[1].z - points[0].z) * i) / segments);
+            }
+            verticesArray.push(points[1].x, points[1].y, points[1].z);
+            verticesArray.push(points[2].x, points[2].y, points[2].z);
+            for (let i = 1; i < segments; i++) {
+                verticesArray.push(points[2].x + ((points[3].x - points[2].x) * i) / segments, points[2].y + ((points[3].y - points[2].y) * i) / segments, points[2].z + ((points[3].z - points[2].z) * i) / segments);
+            }
+            verticesArray.push(points[3].x, points[3].y, points[3].z);
+            const uvArray = [];
+            uvArray.push(0, 1);
+            for (let i = 1; i < segments; i++) {
+                uvArray.push(0, 1 - i / segments);
+            }
+            uvArray.push(0, 0);
+            uvArray.push(1, 0);
+            for (let i = 1; i < segments; i++) {
+                uvArray.push(1, i / segments);
+            }
+            uvArray.push(1, 1);
+            const indicesArray = [];
+            for (let i = 0; i < segments; i++) {
+                indicesArray.push(i, i + 1, segments * 2 - i, i, segments * 2 - i, segments * 2 + 1 - i);
+            }
+            geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(verticesArray), 3));
+            geometry.setAttribute('uv', new THREE.BufferAttribute(new Float32Array(uvArray), 2));
+            geometry.setIndex(new THREE.BufferAttribute(new Uint32Array(indicesArray), 1));
+            const material = new THREE.MeshBasicMaterial({
+                map: state.videoTextureEnabled ? state.videoTexture : state.imageTexture,
+                side: THREE.DoubleSide,
+            });
+            const mesh = new THREE.Mesh(geometry, material);
+            mesh.renderOrder = 1;
+            mesh.name = `ModelTVVideoPlugin-${index}-${performance.now()}`;
+            return mesh;
+        });
+    };
+    const getImageTexture = (source) => {
+        const texture = new THREE.TextureLoader().load(source);
+        texture.minFilter = THREE.LinearFilter;
+        texture.magFilter = THREE.LinearFilter;
+        texture.format = THREE.RGBFormat;
+        return texture;
+    };
+    const getVideoTexture = (source, video) => {
+        return new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            xhr.onreadystatechange = () => {
+                if (xhr.readyState == 4) {
+                    if (xhr.status == 200) {
+                        const url = window.URL || window.webkitURL;
+                        video = video || document.createElement('video');
+                        video.crossOrigin = 'anonymous';
+                        video.autoplay = true;
+                        video.muted = true;
+                        video.loop = true;
+                        video.playsInline = true;
+                        video.src = url.createObjectURL(xhr.response);
+                        const texture = new THREE.VideoTexture(video);
+                        texture.minFilter = THREE.LinearFilter;
+                        texture.magFilter = THREE.LinearFilter;
+                        texture.format = THREE.RGBFormat;
+                        resolve(Object.assign(texture, { videoSource: source }));
+                    }
+                    else {
+                        reject(new Error('Video download Error: ' + xhr.status));
+                    }
+                }
+            };
+            xhr.onerror = (error) => reject(error);
+            xhr.open('GET', source);
+            xhr.responseType = 'blob';
+            xhr.send();
+        });
+    };
+    const load = async (data, videoElement) => {
+        const { video_src, video_poster_src, points } = data;
+        state.videoSource = video_src;
+        // TODO 存疑，先处理多一次遍历 o(2n)
+        state.rectPoints = parseModelTVVideoPoints(points)
+            .map((items) => items.map(({ x, y, z }) => new THREE.Vector3(x, y, z)));
+        state.imageTexture = getImageTexture(video_poster_src);
+        if (videoElement) {
+            state.videoElement = videoElement;
+        }
+        state.videoTexture = await getVideoTexture(state.videoSource, state.videoElement);
+        state.enabled = !!data.enable;
+        if (state.enabled)
+            enable();
+    };
+    const dispose = () => {
+        disable();
+        state.videoTexture = undefined;
+        five.off('modeChange', () => setMuted(true));
+        five.off('wantsTapGesture', (raycaster) => {
+            if (!state.enabled)
+                return;
+            const [intersect] = raycaster.intersectObjects(five.scene.children, true);
+            if (!!intersect && /^video/.test(intersect.object.name)) {
+                if (state.videoTexture)
+                    setMuted(!state.videoTexture.image.muted);
+                return false;
+            }
+        });
+        five.off('panoArrived', () => {
+            if (!state.enabled)
+                return;
+            if (getMuted())
+                return;
+            const cameraPosition = five.camera.position;
+            const visible = state.rectPoints.find((points) => {
+                const centerVector = points.reduce((total, curr) => new THREE.Vector3(total.x + curr.x / points.length, total.y + curr.y / points.length, total.z + curr.z / points.length), new THREE.Vector3());
+                return (points.map((point) => new THREE.Vector3((point.x + centerVector.x) / 2, (point.y + centerVector.y) / 2, (point.z + centerVector.z) / 2)).filter((vector) => {
+                    vector = vector.clone().sub(cameraPosition).normalize();
+                    const raycaster = new THREE.Raycaster(cameraPosition, vector);
+                    const [intersect] = raycaster.intersectObjects(five.scene.children, true);
+                    return !!intersect && /^video/.test(intersect.object.name);
+                }).length >= 2);
+            });
+            if (!visible)
+                setMuted(true);
+        });
+        five.off('renderFrame', () => {
+            // console.log('renderFrame', state.videoMeshes)
+            state.videoMeshes.forEach((meshes) => {
+                if (meshes)
+                    //@ts-ignore
+                    meshes.needsRender = true;
+            });
+        });
+    };
+    five.on('modeChange', () => setMuted(true));
+    five.on('wantsTapGesture', (raycaster) => {
+        if (!state.enabled)
+            return;
+        const targetMesh = five.scene.children.filter(item => /^ModelTVVideoPlugin/.test(item.name));
+        if (!targetMesh)
+            return;
+        const intersectObjects = raycaster.intersectObjects(targetMesh);
+        if (intersectObjects.length === 0)
+            return;
+        if (state.videoTexture)
+            setMuted(!state.videoTexture.image.muted); // TODO  toggle video play
+        return false;
+    });
+    five.on('panoArrived', () => {
+        if (!state.enabled)
+            return;
+        if (getMuted())
+            return;
+        const cameraPosition = five.camera.position;
+        const visible = state.rectPoints.find((points) => {
+            const centerVector = points.reduce((total, curr) => new THREE.Vector3(total.x + curr.x / points.length, total.y + curr.y / points.length, total.z + curr.z / points.length), new THREE.Vector3());
+            return (points.map((point) => new THREE.Vector3((point.x + centerVector.x) / 2, (point.y + centerVector.y) / 2, (point.z + centerVector.z) / 2)).filter((vector) => {
+                vector = vector.clone().sub(cameraPosition).normalize();
+                const raycaster = new THREE.Raycaster(cameraPosition, vector);
+                const [intersect] = raycaster.intersectObjects(five.scene.children, true);
+                return !!intersect && /^video/.test(intersect.object.name);
+            }).length >= 2);
+        });
+        if (!visible)
+            setMuted(true);
+    });
+    five.on('renderFrame', () => {
+        // console.log('renderFrame', state.videoMeshes)
+        state.videoMeshes.forEach((meshes) => {
+            if (meshes)
+                //@ts-ignore
+                meshes.needsRender = true;
+        });
+    });
+    Object.assign(window, { $state: state });
+    return { enable, disable, load, dispose };
+};
+export default ModelTVVideoPlugin;

package/libs/src/ModelTVVideoPlugin/index.d.ts

@@ -0,0 +1,5 @@
+import ModelTVVideoPlugin from './Plugin';
+export { ModelTVVideoPlugin };
+export default ModelTVVideoPlugin;
+export type { ModelTVVideoPluginParameterType, ModelTVVideoPluginData, Point, ModelTVVideoPluginExportType } from './typings';
+export { DIRECTION } from './typings';

package/libs/src/ModelTVVideoPlugin/index.js

@@ -0,0 +1,4 @@
+import ModelTVVideoPlugin from './Plugin';
+export { ModelTVVideoPlugin };
+export default ModelTVVideoPlugin;
+export { DIRECTION } from './typings';

package/libs/src/ModelTVVideoPlugin/typings.d.ts

@@ -0,0 +1,25 @@
+export interface ModelTVVideoPluginParameterType {
+    videoElement?: HTMLVideoElement;
+}
+export declare enum DIRECTION {
+    TOP_LEFT = "topLeft",
+    TOP_RIGHT = "topRight",
+    BOTTOM_LEFT = "bottomLeft",
+    BOTTOM_RIGHT = "bottomRight"
+}
+export interface Point {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface ModelTVVideoPluginData {
+    enable?: boolean;
+    video_src: string;
+    video_poster_src: string;
+    points: Point[][] | Record<DIRECTION, Point>[];
+}
+export interface ModelTVVideoPluginExportType {
+    enable: () => void;
+    disable: () => void;
+    load: (data: ModelTVVideoPluginData, videoElement?: HTMLVideoElement) => Promise<void>;
+}

package/libs/src/ModelTVVideoPlugin/typings.js

@@ -0,0 +1,8 @@
+import "three";
+export var DIRECTION;
+(function (DIRECTION) {
+    DIRECTION["TOP_LEFT"] = "topLeft";
+    DIRECTION["TOP_RIGHT"] = "topRight";
+    DIRECTION["BOTTOM_LEFT"] = "bottomLeft";
+    DIRECTION["BOTTOM_RIGHT"] = "bottomRight";
+})(DIRECTION || (DIRECTION = {}));

package/libs/src/ModelTVVideoPlugin/utils/parseData.d.ts

@@ -0,0 +1,2 @@
+import { DIRECTION, Point } from "../typings";
+export declare function parseModelTVVideoPoints(points: Point[][] | Record<DIRECTION, Point>[]): Point[][];

package/libs/src/ModelTVVideoPlugin/utils/parseData.js

@@ -0,0 +1,13 @@
+import { DIRECTION } from "../typings";
+export function parseModelTVVideoPoints(points) {
+    if (points.length === 0)
+        return [];
+    if (Array.isArray(points[0]))
+        return points;
+    let newPoints = [];
+    points.map(point => {
+        const newPoint = [point[DIRECTION.TOP_LEFT], point[DIRECTION.BOTTOM_LEFT], point[DIRECTION.BOTTOM_RIGHT], point[DIRECTION.TOP_RIGHT]];
+        newPoints.push(newPoint);
+    });
+    return newPoints;
+}

package/libs/src/ModelViewPlugin/Plugin.d.ts

@@ -0,0 +1,17 @@
+import type { FivePlugin } from '@realsee/five';
+export interface ModelViewPluginExportType {
+    appendTo: (element: HTMLElement, size?: {
+        width?: number;
+        height?: number;
+    }) => void;
+    refresh: (size?: {
+        width?: number;
+        height?: number;
+    }) => void;
+}
+/**
+ * Five 模型插件
+ * @template ExportType 导出方法
+ */
+export declare const ModelViewPlugin: FivePlugin<void, ModelViewPluginExportType>;
+export default ModelViewPlugin;

package/libs/src/ModelViewPlugin/Plugin.js

@@ -0,0 +1,160 @@
+import * as THREE from 'three';
+/**
+ * Five 模型插件
+ * @template ExportType 导出方法
+ */
+export const ModelViewPlugin = (five) => {
+    let needsRender = true;
+    let renderer = null;
+    const scene = new THREE.Scene();
+    const camera = new THREE.PerspectiveCamera(60, 1, 0.1, 1000);
+    let model = new THREE.Object3D();
+    {
+        const light = new THREE.DirectionalLight(0xffffff, 0.5);
+        light.position.copy(new THREE.Vector3(1, 1, 1));
+        scene.add(light);
+    }
+    {
+        const light = new THREE.DirectionalLight(0xffffff, 0.3);
+        scene.add(light);
+    }
+    {
+        const light = new THREE.AmbientLight(0xffffff, 0.3);
+        scene.add(light);
+    }
+    scene.add(model);
+    const initRendererIfNeeds = () => {
+        if (!five.renderer)
+            return;
+        if (!renderer) {
+            renderer = new THREE.WebGLRenderer({ antialias: false, alpha: true });
+            renderer.setPixelRatio(five.renderer.getPixelRatio());
+            renderer.outputEncoding = THREE.sRGBEncoding;
+            renderer.setClearColor(0x181a1c, 0);
+            renderer.autoClear = true;
+        }
+        return renderer;
+    };
+    const handleModelWillLoad = () => {
+        model.traverse((object) => {
+            if (object instanceof THREE.Mesh) {
+                const materials = [].concat(object.material);
+                materials.forEach((material) => material.dispose());
+            }
+        });
+        scene.remove(model);
+        model = new THREE.Object3D();
+        scene.add(model);
+        update();
+    };
+    const handleModelLoaded = () => {
+        function cloneMaterial(_material) {
+            const material = _material.clone();
+            material.uniforms.modelAlpha.value = 1;
+            if (material.uniforms.map.value) {
+                material.uniforms.map.value.needsUpdate = true;
+            }
+            return material;
+        }
+        function cloneModel(model) {
+            if (model instanceof THREE.Mesh) {
+                const geometry = model.geometry;
+                const material = Array.isArray(model.material)
+                    ? model.material.map(cloneMaterial)
+                    : cloneMaterial(model.material);
+                return new THREE.Mesh(geometry, material);
+            }
+            else if (model instanceof THREE.Group) {
+                const group = new THREE.Group();
+                model.children.forEach((object) => group.add(cloneModel(object)));
+                return group;
+            }
+            else {
+                const object3D = new THREE.Object3D();
+                model.children.forEach((object) => object3D.add(cloneModel(object)));
+                return object3D;
+            }
+        }
+        scene.remove(model);
+        model = cloneModel(five.model);
+        scene.add(model);
+        update();
+    };
+    const appendTo = (element, size = {}) => {
+        const renderer = initRendererIfNeeds();
+        if (!renderer)
+            return;
+        element.appendChild(renderer.domElement);
+        refresh(size);
+        const positionType = window.getComputedStyle(element).position;
+        if (positionType !== 'relative' &&
+            positionType !== 'absolute' &&
+            positionType !== 'fixed' &&
+            positionType !== 'sticky')
+            element.style.position = 'relative';
+    };
+    const refresh = (size = {}) => {
+        if (!renderer)
+            return;
+        const element = renderer.domElement;
+        const container = element.parentNode;
+        if (container === null || container === void 0 ? void 0 : container.nodeName) {
+            const { width = container.offsetWidth, height = container.offsetHeight } = size;
+            renderer.setSize(width, height);
+            // 修改摄像机 aspect 比值
+            camera.aspect = width / height;
+            camera.updateProjectionMatrix();
+        }
+        update();
+    };
+    const cameraDistance = () => {
+        const bounding = five.model.bounding;
+        const { fov, aspect } = camera;
+        const radius = Math.sqrt(Math.pow(bounding.max.x - bounding.min.x + 2, 2) +
+            Math.pow(bounding.max.y - bounding.min.y + 2, 2) +
+            Math.pow(bounding.max.z - bounding.min.z + 2, 2));
+        // fit screen
+        let distance = radius / 2 / Math.tan((Math.PI * fov) / 360);
+        if (aspect < 1)
+            distance = distance / aspect;
+        return isNaN(distance) ? radius : distance;
+    };
+    const update = () => {
+        const { longitude, latitude } = five.getPose();
+        const distance = cameraDistance();
+        const lookAt = five.model.bounding.getCenter(new THREE.Vector3());
+        const longitudeDistance = distance * Math.cos(latitude);
+        const cameraPosition = new THREE.Vector3();
+        cameraPosition.x = Math.sin(longitude) * longitudeDistance + lookAt.x;
+        cameraPosition.z = Math.cos(longitude) * longitudeDistance + lookAt.z;
+        cameraPosition.y = Math.sin(latitude) * distance + lookAt.y;
+        camera.position.copy(cameraPosition);
+        camera.lookAt(lookAt);
+        needsRender = true;
+    };
+    const render = () => {
+        if (needsRender !== true)
+            return;
+        if (!renderer)
+            return;
+        if (!renderer.domElement.parentNode)
+            return;
+        const parentNode = renderer.domElement.parentNode;
+        if (parentNode.offsetWidth === 0)
+            return;
+        renderer.render(scene, camera);
+        needsRender = false;
+    };
+    const dispose = () => {
+        if (renderer)
+            renderer.dispose();
+        renderer = null;
+    };
+    five.on('modelLoaded', handleModelLoaded);
+    five.on('modelWillLoad', handleModelWillLoad);
+    five.on('cameraDirectionUpdate', update);
+    five.on('dispose', dispose);
+    five.on('renderFrame', render);
+    return { appendTo, refresh };
+};
+export default ModelViewPlugin;

package/libs/src/ModelViewPlugin/index.d.ts

@@ -0,0 +1,4 @@
+import ModelViewPlugin from './Plugin';
+export { ModelViewPlugin };
+export default ModelViewPlugin;
+export type { ModelViewPluginExportType } from './Plugin';

package/libs/src/ModelViewPlugin/index.js

@@ -0,0 +1,3 @@
+import ModelViewPlugin from './Plugin';
+export { ModelViewPlugin };
+export default ModelViewPlugin;

package/libs/src/Object3DHelperPlugin/Controller.d.ts

@@ -0,0 +1,65 @@
+import type { Five } from '@realsee/five';
+import * as BasePlugin from '../base/BasePlugin';
+import type * as THREE from 'three';
+import { Object3DHelper } from '../shared-utils/Object3DHelper';
+import type { Object3DHelperState } from '../shared-utils/Object3DHelper/typings';
+import type { Object3DHelperPluginEventMap, Object3DHelperPluginState } from './typings';
+export declare const VERSION = "v1.0.0";
+export declare const PLUGIN: string;
+export declare class Object3DHelperController extends BasePlugin.Controller<Object3DHelperPluginState, Object3DHelperPluginEventMap> {
+    version: string;
+    name: string;
+    state: Object3DHelperState;
+    objectHelperMap: Map<THREE.Object3D, Object3DHelper>;
+    constructor(five: Five);
+    /**
+     * @description Show guide line
+     */
+    show(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Hide guide line
+     */
+    hide(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Enable
+     */
+    enable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Disable
+     */
+    disable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Dispose
+     */
+    dispose(): void;
+    setState(state: Partial<Object3DHelperState>, options?: {
+        userAction?: boolean;
+    } & Record<string, any>): void;
+    getObject3DHelper(object3D: THREE.Object3D): Object3DHelper;
+    /**
+     * @description 添加 helper
+     * @param { THREE.Object3D } object3D       要添加helper的物体
+     * @param { boolean } config.moveHelper     位移helper
+     * @param { boolean } config.rotateHelper   旋转helper
+     * @param { boolean } config.scaleHelper    缩放helper
+     */
+    addObject3DHelper(object3D: THREE.Object3D, config?: {
+        moveHelper?: boolean;
+        rotateHelper?: boolean;
+        scaleHelper?: boolean;
+    }): void;
+    removeObject3DHelper(object3D: THREE.Object3D): void;
+    private handleEnable;
+    private handleVisible;
+    private handleDispose;
+    private everyHelperDo;
+    private actionIfStateIsEnabled;
+}