@realsee/dnalogel 2.0.0-alpha.12 → 2.0.0-alpha.15

package/libs/ModelItemLabelPlugin/index.js

@@ -3,6 +3,7 @@ import ItemLabelComponent from './ItemLabelComponent';
 import { DISPLAY_STRATEGY_TYPE } from "./typings";
 import { parseModelItemLabelPluginData } from "./utils/parseData";
 export const ModelItemLabelPlugin = (five, params) => {
+    var _a, _b;
     const pluginState = {
         container: document.createElement('div'),
         data: null,
@@ -12,8 +13,8 @@ export const ModelItemLabelPlugin = (five, params) => {
         wrapper: null,
         app: undefined,
         hooks: new Subscribe(),
-        modelOcclusionEnable: params?.modelOcclusionEnable ?? true,
-        displayStrategyType: params?.displayStrategyType ?? DISPLAY_STRATEGY_TYPE.SMALL
+        modelOcclusionEnable: (_a = params === null || params === void 0 ? void 0 : params.modelOcclusionEnable) !== null && _a !== void 0 ? _a : true,
+        displayStrategyType: (_b = params === null || params === void 0 ? void 0 : params.displayStrategyType) !== null && _b !== void 0 ? _b : DISPLAY_STRATEGY_TYPE.SMALL,
     };
     pluginState.container.setAttribute('class', 'model-item-label-plugin-container');
     pluginState.container.style.cssText = `
@@ -22,8 +23,8 @@ export const ModelItemLabelPlugin = (five, params) => {
         top: 0;
         width: 100%;
         height: 100%;
-        pointerEvents: none;
     `;
+    pluginState.container.style.pointerEvents = 'none'; // 写到 cssText 里不生效
     const appendTo = (wrapper) => {
         pluginState.wrapper = wrapper;
         wrapper.appendChild(pluginState.container);
@@ -31,7 +32,6 @@ export const ModelItemLabelPlugin = (five, params) => {
         return true;
     };
     const load = (data) => {
-        console.log('🐶--当前标签总条数： ', data.model_item_labels.length);
         pluginState.itemLabels = parseModelItemLabelPluginData(data);
         render();
     };
@@ -53,46 +53,13 @@ export const ModelItemLabelPlugin = (five, params) => {
         removeListener4Five();
         pluginState.container.remove();
     };
-    const handleRerender = () => {
-        if (!pluginState.enabled || !pluginState.fiveModeEnabled)
-            return;
-        disable();
-    };
-    const rerender = (a, b, c) => {
-        if (!pluginState.fiveModeEnabled)
-            return;
-        if (!c)
-            return;
-        enable();
-        render();
-    };
-    const handleInteriaPanRerender = (a, b) => {
-        if (!pluginState.fiveModeEnabled)
-            return;
-        if (!b)
-            return;
-        enable();
-        render();
-    };
-    const handleWantsPanGesture = (pose, final) => {
-        if (pose) {
-            handleRerender();
-        }
-    };
-    const handlePanGesture = (pose, final) => {
-        if (!pluginState.fiveModeEnabled)
-            return;
-        if (!final)
-            return;
-        enable();
-        render();
-    };
     const render = () => {
+        var _a;
         if (!pluginState.wrapper)
             return;
         // 只要不可展示，销毁容器
         if (!pluginState.enabled || !pluginState.fiveModeEnabled) {
-            pluginState.app?.$destroy();
+            (_a = pluginState.app) === null || _a === void 0 ? void 0 : _a.$destroy();
             pluginState.app = undefined;
             return;
         }
@@ -121,32 +88,14 @@ export const ModelItemLabelPlugin = (five, params) => {
     const addListener4Five = () => {
         five.on('modeChange', onFiveModeChange);
         five.once('dispose', dispose);
-        // five.on('wantsGesture', handleRerender)
-        // five.on('gesture', rerender)
-        five.on('wantsMouseWheel', handleRerender);
-        five.on('mouseWheel', rerender);
-        five.on('wantsInteriaPan', handleRerender);
-        five.on('interiaPan', handleInteriaPanRerender);
-        five.on('wantsPanGesture', handleWantsPanGesture);
-        five.on('panGesture', handlePanGesture);
-        five.on('wantsPinchGesture', handleRerender);
-        five.on('pinchGesture', rerender);
     };
     // 取消 five 监听
     const removeListener4Five = () => {
         five.off('modeChange', onFiveModeChange);
-        // five.off('wantsGesture', handleRerender)
-        // five.off('gesture', rerender)
-        five.off('wantsMouseWheel', handleRerender);
-        five.off('mouseWheel', rerender);
-        five.off('wantsInteriaPan', handleRerender);
-        five.off('interiaPan', handleInteriaPanRerender);
-        five.off('wantsPanGesture', handleWantsPanGesture);
-        five.off('panGesture', handlePanGesture);
-        five.off('wantsPinchGesture', handleRerender);
-        five.off('pinchGesture', rerender);
     };
     const onFiveModeChange = (mode) => {
+        if (!pluginState.enabled)
+            return;
         if (mode !== Five.Mode.Floorplan) {
             pluginState.fiveModeEnabled = false;
             render();

package/libs/ModelItemLabelPlugin/utils/parseData.js

@@ -1,7 +1,4 @@
 /** @description 转成内部所需数据 */
 export function parseModelItemLabelPluginData(data) {
-    return data.model_item_labels.map(label => ({
-        modelPosition: [label.position[0], label.position[1] + label.size[1], label.position[2]],
-        ...label
-    }));
+    return data.model_item_labels.map(label => (Object.assign({ modelPosition: [label.position[0], label.position[1] + label.size[1], label.position[2]] }, label)));
 }

package/libs/ModelRoomLabelPlugin/Controller.js

@@ -1,14 +1,69 @@
 import RoomLabelItems from './RoomLabelItems';
 import { parseModelRoomLabelPluginData } from './utils/parseData';
 export class ModelRoomLabelController {
-    five;
-    enabled = true;
-    fiveModeEnabled;
-    app = undefined;
-    wrapper;
-    roomLabels = [];
-    container = document.createElement('div');
     constructor(five) {
+        Object.defineProperty(this, "five", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "enabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "fiveModeEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "app", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "wrapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "roomLabels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "container", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: document.createElement('div')
+        });
+        /** 监听 Five Mode 变化
+         * @description
+         * Mode 不符合要求时，立刻消失，满足要求时，需要等待动画结束再展示
+         */
+        Object.defineProperty(this, "onFiveModeChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (mode) => {
+                if (mode !== 'Floorplan') {
+                    this.fiveModeEnabled = false;
+                    this.render();
+                    return;
+                }
+                this.five.once('initAnimationEnded', () => {
+                    this.fiveModeEnabled = this.five.currentMode === 'Floorplan';
+                    this.render();
+                });
+            }
+        });
         this.five = five;
         this.fiveModeEnabled = this.five.currentMode === 'Floorplan';
         // init container style
@@ -61,26 +116,12 @@ export class ModelRoomLabelController {
         this.render();
         return this;
     }
-    /** 监听 Five Mode 变化
-     * @description
-     * Mode 不符合要求时，立刻消失，满足要求时，需要等待动画结束再展示
-     */
-    onFiveModeChange = (mode) => {
-        if (mode !== 'Floorplan') {
-            this.fiveModeEnabled = false;
-            this.render();
-            return;
-        }
-        this.five.once('initAnimationEnded', () => {
-            this.fiveModeEnabled = this.five.currentMode === 'Floorplan';
-            this.render();
-        });
-    };
     render() {
+        var _a;
         if (!this.wrapper)
             return;
         if (!this.enabled || !this.fiveModeEnabled) {
-            this.app?.$destroy();
+            (_a = this.app) === null || _a === void 0 ? void 0 : _a.$destroy();
             this.app = undefined;
             return;
         }

package/libs/ModelRoomLabelPlugin/RoomLabelItems.js

@@ -194,12 +194,12 @@ function instance($$self, $$props, $$invalidate) {
 			// 计算是否可见，如果不可见，不会更新位置
 			const visible = getLabelVisible(five, roomLabelItem);
 
-			if (!visible) return { ...roomLabelItem, visible };
+			if (!visible) return Object.assign(Object.assign({}, roomLabelItem), { visible });
 
 			// 更新位置
 			const transform = getLabelTransform(five, roomLabelItem);
 
-			return { ...roomLabelItem, visible, transform };
+			return Object.assign(Object.assign({}, roomLabelItem), { visible, transform });
 		});
 
 		const sortedRoomLabelItems = newLabels.filter(({ visible }) => visible).map(roomLabelItem => ({
@@ -209,7 +209,7 @@ function instance($$self, $$props, $$invalidate) {
 
 		return newLabels.map(roomLabelItem => {
 			const sortIndex = sortedRoomLabelItems.findIndex(item => item.roomLabelItem.id === roomLabelItem.id);
-			if (sortIndex !== undefined) return { ...roomLabelItem, zIndex: sortIndex * 10 };
+			if (sortIndex !== undefined) return Object.assign(Object.assign({}, roomLabelItem), { zIndex: sortIndex * 10 });
 			return roomLabelItem;
 		});
 	}

package/libs/ModelTVVideoPlugin/index.d.ts

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

package/libs/ModelTVVideoPlugin/index.js

@@ -0,0 +1,263 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 = (data, videoElement) => __awaiter(void 0, void 0, void 0, function* () {
+        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 = yield 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 };
+};
+export default ModelTVVideoPlugin;

package/libs/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/ModelTVVideoPlugin/typings.js

@@ -0,0 +1,7 @@
+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/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/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;
+}