@realsee/dnalogel 2.0.0-alpha.26 → 2.0.0-alpha.28

package/libs/ModelTVVideoPlugin/index.js

@@ -1,254 +1,4 @@
-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.find(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 };
-};
+import ModelTVVideoPlugin from './Plugin';
+export { ModelTVVideoPlugin };
 export default ModelTVVideoPlugin;
+export { DIRECTION } from './typings';

package/libs/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/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) {
+            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 && 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/ModelViewPlugin/index.d.ts

@@ -1,17 +1,4 @@
-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>;
+import ModelViewPlugin from './Plugin';
+export { ModelViewPlugin };
 export default ModelViewPlugin;
+export type { ModelViewPluginExportType } from './Plugin';

package/libs/ModelViewPlugin/index.js

@@ -1,160 +1,3 @@
-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) {
-            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 && 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 };
-};
+import ModelViewPlugin from './Plugin';
+export { ModelViewPlugin };
 export default ModelViewPlugin;

package/libs/PanoCompassPlugin/Plugin.d.ts

@@ -0,0 +1,47 @@
+import type { Five, FivePlugin } from '@realsee/five';
+import type { FloorplanServerRoomItem } from '../floorplan/typings/floorplanServerData';
+export interface PanoCompassPluginParameterType {
+    compassImageUrl?: string;
+    entryDoorImageUrl?: string;
+}
+export interface PanoCompassPluginData {
+    north_rad: null | number;
+    entrance: null | undefined | {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    room_observers: undefined | {
+        index: number;
+        floor_index: number;
+        room: FloorplanServerRoomItem;
+    }[];
+}
+export declare type PanoCompassPluginExportType = PanoCompassController;
+export declare const PanoCompassPlugin: FivePlugin<PanoCompassPluginParameterType | undefined, PanoCompassController>;
+export default PanoCompassPlugin;
+declare class PanoCompassController {
+    five: Five;
+    data?: PanoCompassPluginData;
+    config?: PanoCompassPluginParameterType;
+    private group;
+    private modelLoaded;
+    private roomInfoInstance?;
+    private roomInfoWrapperInstance?;
+    private compassMeshTween?;
+    private compassMesh?;
+    private entryDoorMesh?;
+    constructor(five: Five, config?: PanoCompassPluginParameterType);
+    load(data: PanoCompassPluginData): void;
+    dispose: () => void;
+    private onFiveFistPanoLoaded;
+    private init;
+    private loadCompassMesh;
+    private loadEntryDoorMesh;
+    private loadRoomInfo;
+    private onFivePanoWillArrive;
+    private onFivePanoArrived;
+    private onFiveCameraDirectionUpdate;
+}