@realsee/dnalogel 2.0.0-alpha.9 → 2.0.0

package/dist/ModelTVVideoPlugin/floorplan/typings/floorplanData.d.ts

@@ -0,0 +1,137 @@
+/**
+ * @file 对输入到户型图相关插件内的数据做 format 之后的数据
+ * 1. 数据的下划线到驼峰的转换
+ * 2. svg url 到 svg content 的处理
+ */
+import type { RecordKeys, RecordValue } from './utility';
+/** 户型图坐标，坐标原点时户型图中心点，单位是户型图单位 */
+export interface FloorplanPosition {
+    x: number;
+    y: number;
+}
+/** 户型图图片坐标，坐标原点是图片左上角，取值范围是 [0, 1]，表示距离左上角的相对距离 */
+export interface FloorplanImagePosition {
+    x: number;
+    y: number;
+}
+/** 户型图线框图 */
+export interface FloorplanOutlineItem {
+    url: string;
+    index: number;
+    svgUrl?: string;
+    svgContent?: string;
+}
+/** 户型图入户门 */
+export interface FloorplanEntrance {
+    /** 入户门角度 */
+    rad: number;
+    /** 入户门所在的位置「户型图坐标系」 */
+    position: FloorplanPosition;
+    /** 入户门在户型图上相对坐标 */
+    positionInImage: FloorplanImagePosition;
+    /** 入户门与北的朝向 */
+    northRad: number;
+    /** 入户门所在房间 ID */
+    roomId: string;
+    /** 入户门所楼层 */
+    floorIndex: number;
+}
+/** 户型图 FloorplanBounding
+ * @description 坐标都是户型图坐标
+ */
+export interface FloorplanBounding {
+    /** 户型图在 X 和 Y 轴上的最大值 */
+    max: FloorplanPosition;
+    /** 户型图在 X 和 Y 轴上的最小值 */
+    min: FloorplanPosition;
+    /** 户型图的中心位置 */
+    origin: FloorplanPosition;
+}
+/** 户型图房屋标签 */
+export interface FloorplanRoomLabelItem {
+    /** 房间的中心点坐标 */
+    position: FloorplanPosition;
+    /** 房间的中心在户型图上的相对位置 */
+    positionInImage: FloorplanImagePosition;
+}
+/** 户型图房间数据 */
+export interface FloorplanRoomItem {
+    id: string;
+    /** 房间面积
+     * @description 单位是平方毫米
+     */
+    size: number;
+    name: string;
+    /** 围成房间区域的坐标路径
+     * @description 坐标类型是户型图坐标
+     */
+    path: FloorplanPosition[];
+    /** 房屋类型
+     * @description 对应关系参考上方 ROOM_TYPE_MAP
+     */
+    roomType: string;
+    /** 地板类型
+     * @description 对应关系参考上方 FLOOR_TYPE_MAP
+     */
+    floorType: number;
+    roomLabel: FloorplanRoomLabelItem;
+    /** 当前房间里的 observer 索引 */
+    observerIndexs: number[];
+}
+/** 户型图标尺 */
+export declare type FloorplanRuleLabels = Record<'top' | 'right' | 'bottom' | 'left', FloorplanPosition[][]>;
+export declare type RuleLabelsKey = RecordKeys<FloorplanRuleLabels>;
+export declare type RuleLabelsValue = RecordValue<FloorplanRuleLabels>;
+/** 当前楼层的数据 */
+export interface FloorplanFloorData {
+    floorName: string;
+    floorIndex: number;
+    rooms: FloorplanRoomItem[];
+    rules: FloorplanRuleLabels;
+}
+/** 对 observer 做一些样式上的计算
+ * @description 每一个 floorplanObserver 对应一个 observer
+ * @description floorplanObserver 和 observer 在自身数组中的索引坐标应该是相同的
+ */
+export interface FloorplanObserver {
+    index: number;
+    floorIndex: number;
+    position: FloorplanPosition;
+    positionInImage: FloorplanImagePosition;
+}
+/** 户型图内部使用的数据 */
+export interface FloorplanData {
+    outlines: FloorplanOutlineItem[];
+    floorDatas: FloorplanFloorData[];
+    entrance: FloorplanEntrance | null;
+    bounding: FloorplanBounding;
+    observers: FloorplanObserver[];
+}
+/** 能够映射到雷达图上的三维物体 */
+export interface FloorplanExtraObject3D {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    icon?: {
+        url: string;
+        width: number;
+        height: number;
+    };
+}
+/** 添加到户型图上的额外物体 */
+export interface FloorplanExtraObject {
+    id: string;
+    icon: {
+        url: string;
+        width: number;
+        height: number;
+    };
+    floorIndex: number;
+    /** 入户门所在的位置「户型图坐标系」 */
+    position: FloorplanPosition;
+    /** 入户门在户型图上相对坐标 */
+    positionInImage: FloorplanImagePosition;
+}

package/dist/ModelTVVideoPlugin/floorplan/typings/floorplanServerData.d.ts

@@ -0,0 +1,144 @@
+/** 房屋数据映射表 */
+export declare const ROOM_FETILE_TYPE_MAP: ({
+    type: number;
+    floorType: number;
+    roomType: string;
+    name: string;
+    onlySubArea?: undefined;
+} | {
+    type: number;
+    floorType: number;
+    roomType: string;
+    name: string;
+    onlySubArea: boolean;
+})[];
+/** 地板信息映射表 */
+export declare const FLOOR_TYPE_MAP: {
+    type: number;
+    description: string;
+}[];
+/** 房屋类型映射表 */
+export declare const ROOM_TYPE_MAP: {
+    roomType: string;
+    description: string;
+}[];
+/** 户型图坐标，坐标原点时户型图中心点，单位是户型图单位 */
+export interface FloorplanServerPosition {
+    x: number;
+    y: number;
+}
+/** 户型图图片坐标，坐标原点是图片左上角，取值范围是 [0, 1]，表示距离左上角的相对距离 */
+export interface FloorplanServerImagePosition {
+    x: number;
+    y: number;
+}
+/** 户型图线框图 */
+export interface FloorplanServerOutlineItem {
+    url: string;
+    index: number;
+    checksum?: string;
+    svg_url?: string;
+}
+/** 户型图入户门 */
+export interface FloorplanServerEntrance {
+    /** 入户门角度 */
+    rad: number;
+    /** 入户门所在的位置「户型图坐标系」 */
+    position: FloorplanServerPosition;
+    /** 入户门在户型图上相对坐标 */
+    position_in_image: FloorplanServerImagePosition;
+    /** 入户门与北的朝向 */
+    north_rad: number;
+    /** 入户门所在房间 ID */
+    room_id: string;
+    /** 入户门所楼层 */
+    floor_index: number;
+}
+/** 户型图 FloorplanServerBounding
+ * @description 坐标都是户型图坐标
+ */
+export interface FloorplanServerBounding {
+    /** 户型图在 X 和 Y 轴上的最大值 */
+    max: FloorplanServerPosition;
+    /** 户型图在 X 和 Y 轴上的最小值 */
+    min: FloorplanServerPosition;
+    /** 户型图的中心位置 */
+    origin: FloorplanServerPosition;
+}
+/** 户型图房屋标签 */
+export interface FloorplanServerRoomLabelItem {
+    /** 房间的中心点坐标 */
+    position: FloorplanServerPosition;
+    /** 房间的中心在户型图上的相对位置 */
+    position_in_image: FloorplanServerImagePosition;
+}
+/** 户型图房间数据 */
+export interface FloorplanServerRoomItem {
+    id: string;
+    /** 房间面积
+     * @description 单位是平方毫米
+     */
+    size: number;
+    /** 房屋类型
+     * @description 对应关系参考上方 ROOM_DETAILS_TYPE_MAP
+     */
+    type: number;
+    name: string;
+    /** 围成房间区域的坐标路径
+     * @description 坐标类型是户型图坐标
+     */
+    path: FloorplanServerPosition[];
+    /** 房屋类型
+     * @description 对应关系参考上方 ROOM_TYPE_MAP
+     */
+    room_type: string;
+    /** 地板类型
+     * @description 对应关系参考上方 FLOOR_TYPE_MAP
+     */
+    floor_type: number;
+    room_label: FloorplanServerRoomLabelItem;
+    /** 当前房间里的 observer 索引 */
+    observer_indexs: number[];
+}
+export declare type FloorplanServerRuleLabels = Record<'top' | 'right' | 'bottom' | 'left', FloorplanServerPosition[][]>;
+/** 当前楼层的数据 */
+export interface FloorplanServerFloorData {
+    floor_name: string;
+    floor_index: number;
+    rooms: FloorplanServerRoomItem[];
+    rules: FloorplanServerRuleLabels;
+}
+/** 对 observer 做一些样式上的计算
+ * @description 每一个 FloorplanServer_observer 对应一个 observer
+ * @description FloorplanServer_observer 和 observer 在自身数组中的索引坐标应该是相同的
+ */
+export interface FloorplanServerObserver {
+    index: number;
+    floor_index: number;
+    position: FloorplanServerPosition;
+    position_in_image: FloorplanServerImagePosition;
+}
+export interface FloorplanServerDoorPosition {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface FloorplanServerDoorItem {
+    id: string;
+    localName: string;
+    name: string;
+    position: FloorplanServerDoorPosition;
+    rad: number;
+}
+export interface FloorplanServerComputedData {
+    floor_datas: FloorplanServerFloorData[];
+    entrance: FloorplanServerEntrance | null;
+    bounding: FloorplanServerBounding;
+    observers: FloorplanServerObserver[];
+    doors: FloorplanServerDoorItem[];
+}
+/** 原始输入的户型图数据 */
+export interface FloorplanServerData {
+    outlines: FloorplanServerOutlineItem[];
+    computed_data: FloorplanServerComputedData;
+}

package/dist/ModelTVVideoPlugin/floorplan/typings/utility.d.ts

@@ -0,0 +1,2 @@
+export declare type RecordKeys<T> = T extends Record<infer P, any> ? P : any;
+export declare type RecordValue<T> = T extends Record<any, infer P> ? P : any;

package/dist/ModelTVVideoPlugin/floorplan/utils/constant.d.ts

@@ -0,0 +1,22 @@
+export declare const enum FloorplanErrorType {
+    /** 意料之外的错误 */
+    UnknownError = "UnknownError",
+    /** 数据未加载 */
+    DataNotLoaded = "DataNotLoaded",
+    /** 展示过程被隐藏打断 */
+    BreakOffByHide = "BreakOffByHide",
+    /** 展示过程中插件被禁用 */
+    BreakOffByDisable = "BreakOffByDisable",
+    /** 模型未加载完成 */
+    ModelNotLoaded = "ModelNotLoaded",
+    /** Five changeMode 行为不符合预期 */
+    ChangeModeError = "ChangeModeError",
+    /** Five updateCamera 行为不符合预期 */
+    UpdateCameraError = "UpdateCameraError"
+}
+/** 户型图展示 & 模型消失的默认时间 */
+export declare const SHOW_ANIME_DURATION = 500;
+/** Five camera 默认 fov */
+export declare const FIVE_CAMERA_DEFAULT_FOV = 80;
+/** 展示户型图时，默认模型的透明度 */
+export declare const DEFAULT_SHOW_MODEL_OPACITY = 0.01;

package/dist/ModelTVVideoPlugin/floorplan/utils/correctFiveState.d.ts

@@ -0,0 +1,15 @@
+import type { Five, Mode } from '@realsee/five';
+export interface ShowState {
+    latitude: number;
+    longitude: number;
+    fov: number;
+    mode: Mode;
+}
+/** 判断当前状态是否可以展示户型图 */
+export declare function checkShowState(five: Five, showState: ShowState): boolean;
+/** 更改 Five 状态到展示户型图的状态
+ * 1. 判断状态不符合时，会纠正到正确的状态
+ * 2. 内置了相应的动画时间计算
+ * 3. 纠正成功会返回 true，失败「可能会被用户行为中断」会返回 false
+ */
+export default function correctFiveState(five: Five, showState: ShowState, userAction?: boolean): Promise<void>;

package/dist/ModelTVVideoPlugin/floorplan/utils/formatData.d.ts

@@ -0,0 +1,5 @@
+import type { Five } from '@realsee/five';
+import type { FloorplanData, FloorplanExtraObject, FloorplanExtraObject3D } from '../typings/floorplanData';
+import type { FloorplanServerData } from '../typings/floorplanServerData';
+export default function formatData(data: FloorplanServerData): Promise<FloorplanData>;
+export declare function formatExtraObjects(data: FloorplanExtraObject3D[], five: Five, floorplanData: FloorplanData): FloorplanExtraObject[];

package/dist/ModelTVVideoPlugin/floorplan/utils/formatPosition.d.ts

@@ -0,0 +1,36 @@
+import type { Five } from '@realsee/five';
+import type { Vector2Position } from '../../typings/math.type';
+import type { FloorplanData, FloorplanBounding } from '../typings/floorplanData';
+export declare function pathD(points: Vector2Position[], options?: {
+    needZ?: boolean;
+    needA?: Record<number, string>;
+    format?: (vector: Vector2Position) => Vector2Position;
+}): string;
+/** 把户型图上点点位转换到 SVG 上的点位 */
+export default function formatFloorplanPoint({ x, y }: Vector2Position, bounding: FloorplanBounding): {
+    x: number;
+    y: number;
+};
+/** 模型坐标转户型图坐标 */
+export declare function modelPosition2FloorplanPosition(position: {
+    x: number;
+    y: number;
+    z: number;
+}, floorplanData: FloorplanData): {
+    x: number;
+    y: number;
+};
+/** 户型图点位转在图片上的相对坐标 */
+export declare function floorplanPosition2ImagePosition(position: {
+    x: number;
+    y: number;
+}, floorplanData: FloorplanData): {
+    x: number;
+    y: number;
+};
+/** 求三维坐标点所在的楼层 */
+export declare function getFloorIndexFromModelPosition(position: {
+    x: number;
+    y: number;
+    z: number;
+}, five: Five): number;

package/dist/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/dist/ModelTVVideoPlugin/index.js

@@ -0,0 +1,301 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var THREE = require('three');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+exports.DIRECTION = void 0;
+(function (DIRECTION) {
+    DIRECTION["TOP_LEFT"] = "topLeft";
+    DIRECTION["TOP_RIGHT"] = "topRight";
+    DIRECTION["BOTTOM_LEFT"] = "bottomLeft";
+    DIRECTION["BOTTOM_RIGHT"] = "bottomRight";
+})(exports.DIRECTION || (exports.DIRECTION = {}));
+
+function parseModelTVVideoPoints(points) {
+    if (points.length === 0)
+        return [];
+    if (Array.isArray(points[0]))
+        return points;
+    let newPoints = [];
+    points.map(point => {
+        const newPoint = [point[exports.DIRECTION.TOP_LEFT], point[exports.DIRECTION.BOTTOM_LEFT], point[exports.DIRECTION.BOTTOM_RIGHT], point[exports.DIRECTION.TOP_RIGHT]];
+        newPoints.push(newPoint);
+    });
+    return newPoints;
+}
+
+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__namespace.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__namespace.BufferAttribute(new Float32Array(verticesArray), 3));
+            geometry.setAttribute('uv', new THREE__namespace.BufferAttribute(new Float32Array(uvArray), 2));
+            geometry.setIndex(new THREE__namespace.BufferAttribute(new Uint32Array(indicesArray), 1));
+            const material = new THREE__namespace.MeshBasicMaterial({
+                map: state.videoTextureEnabled ? state.videoTexture : state.imageTexture,
+                side: THREE__namespace.DoubleSide,
+            });
+            const mesh = new THREE__namespace.Mesh(geometry, material);
+            mesh.renderOrder = 1;
+            mesh.name = `ModelTVVideoPlugin-${index}-${performance.now()}`;
+            return mesh;
+        });
+    };
+    const getImageTexture = (source) => {
+        const texture = new THREE__namespace.TextureLoader().load(source);
+        texture.minFilter = THREE__namespace.LinearFilter;
+        texture.magFilter = THREE__namespace.LinearFilter;
+        texture.format = THREE__namespace.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__namespace.VideoTexture(video);
+                        texture.minFilter = THREE__namespace.LinearFilter;
+                        texture.magFilter = THREE__namespace.LinearFilter;
+                        texture.format = THREE__namespace.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__namespace.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__namespace.Vector3(total.x + curr.x / points.length, total.y + curr.y / points.length, total.z + curr.z / points.length), new THREE__namespace.Vector3());
+                return (points.map((point) => new THREE__namespace.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__namespace.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__namespace.Vector3(total.x + curr.x / points.length, total.y + curr.y / points.length, total.z + curr.z / points.length), new THREE__namespace.Vector3());
+            return (points.map((point) => new THREE__namespace.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__namespace.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 };
+};
+
+exports.ModelTVVideoPlugin = ModelTVVideoPlugin;
+exports["default"] = ModelTVVideoPlugin;

package/dist/ModelTVVideoPlugin/shared-utils/Preloader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 预载器
+ */
+export declare const Preloader: {
+    blob: (url: string) => Promise<string>;
+};