@realsee/dnalogel 2.2.5-alpha.0 → 2.2.6

package/dist/CSS3DRenderPlugin/CSS3DRender.d.ts

@@ -1,10 +1,10 @@
-import type * as THREE from 'three';
-import { ICSS3DRenderer as CSS3DRenderer } from './utils/three/CSS3DRenderer';
+import * as THREE from 'three';
+import { CSS3DRenderer } from 'three/examples/jsm/renderers/CSS3DRenderer';
 import { Subscribe } from '../shared-utils/Subscribe';
 import { AnyPosition } from './utils';
-import { CSS3DObjectPlus } from './utils/three/CSS3DObject';
-import { CSS3DBehindScene, CSS3DFrontScene } from './utils/three/CSS3DScene';
-export { MinRatio } from './utils/three/CSS3DObject';
+import { CSS3DObjectPlus, Mode } from './utils/CSS3DObjectPlus';
+export { MinRatio } from './utils/CSS3DObjectPlus';
+export declare const __ELEMENT__ = "__CSS3DOBJECT_CSS3DRENDER_CONTAINER__";
 export declare const PLUGIN: string;
 export interface CSS3DRenderState {
     enabled: boolean;
@@ -62,35 +62,26 @@ export declare const globalStore: {
         observe: () => void;
         unobserve: () => void;
     };
-    css3DObjects: CSS3DObjectPlus[];
-    frontModeStore: {
-        css3DScene?: CSS3DFrontScene;
+    frontModeContainer?: Element;
+    behindModeContainer?: Element;
+    frontModeStore?: {
+        css3DScene: THREE.Scene;
         css3DRenderer: CSS3DRenderer;
-        container?: HTMLElement;
+        requestAnimationFrameId?: number;
+        appendedToPage?: boolean;
     };
-    behindModeStore: {
-        css3DScene?: CSS3DBehindScene;
+    behindModeStore?: {
+        scene: THREE.Scene;
+        css3DScene: THREE.Scene;
         css3DRenderer: CSS3DRenderer;
-        container?: HTMLElement;
-        scene?: THREE.Scene;
+        requestAnimationFrameId?: number;
+        appendedToPage?: boolean;
     };
 };
-declare function setFrontModeContainer(container: HTMLElement): void;
-declare function setBehindModeContainer(container: HTMLElement): void;
 export declare class CSS3DRender {
-    static setFrontModeContainer: typeof setFrontModeContainer;
-    static setBehindModeContainer: typeof setBehindModeContainer;
     hooks: Subscribe<CSS3DRenderEventMap>;
     state: CSS3DRenderState;
-    get scene(): THREE.Scene;
-    private _scene?;
     private store;
-    static get frontModeCSS3DRenderer(): CSS3DRenderer;
-    static get behindModeCSS3DRenderer(): CSS3DRenderer;
-    get frontModeCSS3DRenderer(): CSS3DRenderer;
-    get behindModeCSS3DRenderer(): CSS3DRenderer;
-    constructor(scene?: THREE.Scene);
-    setScene(scene: THREE.Scene): void;
     getCurrentState(): CSS3DRenderState;
     setState(state: Partial<CSS3DRenderState>, options?: {
         userAction: boolean;
@@ -111,8 +102,8 @@ export declare class CSS3DRender {
     /**
      * @description 根据传入的四个点位创建一个 3d dom容器，可以通过ReactDom.render()的方式将react组件放到容器中
      * @param { Vector3Position[] } points 矩形四个点坐标
-     * @param params 均为可选值
-     * @config_document `params` 均为可选值
+     * @param config 均为可选值
+     * @config_document `config` 均为可选值
      *  | key                   | type                       | defaultValue        | comment |
      *  | -                     | -                          | -                   | -       |
      *  | `ratio`               | *`number`*                 | `0.00216`           | 1px对应多少米，默认为 0.00216，即1px对应2.16mm |
@@ -142,39 +133,35 @@ export declare class CSS3DRender {
      *    } | void
      * ```
      */
-    create3DElement: (camera: THREE.Camera, points: Create3DDElementParamsType['points'], params?: Create3DDElementParamsType['config']) => void | {
+    create3DElement: (camera: THREE.Camera, points: Create3DDElementParamsType['points'], config?: Create3DDElementParamsType['config']) => void | {
         id: string;
         container: HTMLElement;
+        dispose: () => boolean;
         css3DObject: CSS3DObjectPlus<HTMLElement>;
         render: () => void;
         show: () => void;
         hide: () => void;
         setVisible: (visible: boolean) => void;
-        enable: () => void;
         disable: () => void;
+        enable: () => void;
         setEnabled: (enabled: boolean) => void;
-        dispose: () => boolean;
-        appendToElement: (element: HTMLElement) => CSS3DRenderer;
+        appendToElement: (container: Element) => void;
     };
-    getFrontCSS3DScene({ createSceneIfNotExists }?: {
-        createSceneIfNotExists?: boolean;
-    }): CSS3DFrontScene;
-    getBehindCSS3DScene({ createSceneIfNotExists }?: {
-        createSceneIfNotExists?: boolean;
-    }): CSS3DBehindScene;
-    getFrontCSS3DObjectGroup({ addGroupIfNotExists }?: {
-        addGroupIfNotExists?: boolean;
-    }): THREE.Group;
-    getBehindCSS3DObjectGroup({ addGroupIfNotExists }?: {
-        addGroupIfNotExists?: boolean;
-    }): THREE.Group;
-    setVisibleById: (id: number, visible: boolean) => void;
-    setEnabledById: (id: number, enabled: boolean) => void;
-    render(camera: THREE.Camera): void;
+    setContainer(container: Element, mode: Mode): void;
+    appendToElement(container: Element | undefined, mode: Mode): void;
+    setVisibleById: (id: string, visible: boolean) => void;
+    setEnabledById: (id: string, enabled: boolean) => void;
+    private render;
     private createObject;
+    private initGlobalModeStore;
+    /**
+     * @description: 生成透明Mesh
+     */
+    private createOpacityMesh;
     private handleShow;
     private handleHide;
     private handleEnable;
     private handleDisable;
-    private handleDispose;
+    private createResizeObserver;
+    private disposedErrorLog;
 }

package/dist/CSS3DRenderPlugin/Controller.d.ts

@@ -67,15 +67,15 @@ export default class Controller extends CSS3DRender implements BasePlugin.Contro
         render: () => void;
         id: string;
         container: HTMLElement;
-        css3DObject: import("./utils/three/CSS3DObject").CSS3DObjectPlus<HTMLElement>;
+        dispose: () => boolean;
+        css3DObject: import("./utils/CSS3DObjectPlus").CSS3DObjectPlus<HTMLElement>;
         show: () => void;
         hide: () => void;
         setVisible: (visible: boolean) => void;
-        enable: () => void;
         disable: () => void;
+        enable: () => void;
         setEnabled: (enabled: boolean) => void;
-        dispose: () => boolean;
-        appendToElement: (element: HTMLElement) => import("./utils/three/CSS3DRenderer").default;
+        appendToElement: (container: Element) => void;
     };
-    getBehindFiveElement(): HTMLElement;
+    private getBehindFiveElement;
 }

package/dist/CSS3DRenderPlugin/index.d.ts

@@ -1,6 +1,5 @@
 import type { FivePlugin } from '@realsee/five';
 import Controller from './Controller';
-export declare const CSS3DRenderPlugin: FivePlugin<void, InstanceType<typeof Controller>>;
-export { CSS3DRender } from './CSS3DRender';
 export * from './typing';
+export declare const CSS3DRenderPlugin: FivePlugin<void, InstanceType<typeof Controller>>;
 export default CSS3DRenderPlugin;

package/dist/CSS3DRenderPlugin/utils/{three/CSS3DObject.d.ts → CSS3DObjectPlus.d.ts}

@@ -1,7 +1,7 @@
 import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
 import { Matrix4, Quaternion, Vector3 } from 'three';
-import { Subscribe } from '../../../shared-utils/Subscribe';
-import OpacityMesh from './OpacityMesh';
+import { Subscribe } from '../../shared-utils/Subscribe';
+import type * as THREE from 'three';
 export declare const MinRatio = 0.00216;
 export declare const DefaultRatio = 0.003;
 export declare type Mode = 'front' | 'behind';
@@ -10,39 +10,25 @@ export declare type CSS3DRenderEventMap = {
     applyMatrix4: (matrix: Matrix4) => void;
     applyQuaternion: (quaternion: Quaternion) => void;
     applyScaleMatrix4: (matrix: Matrix4) => void;
+    changeMode: <T extends Mode = Mode>(mode: T, prevMode: Mode, scene: T extends 'behind' ? THREE.Scene : undefined) => void;
 };
 export declare class CSS3DObjectPlus<T extends HTMLElement = HTMLElement> extends CSS3DObject {
-    version: number;
-    readonly isCSS3DObjectPlus: true;
-    container: T;
+    version: string;
     width: number;
     height: number;
     domWidthPx: number;
     domHeightPx: number;
     cornerPoints: CornerPoints;
-    centerPosition: Vector3;
     ratio: number;
+    container: T;
+    centerPosition: Vector3;
     mode: 'front' | 'behind';
     readonly hooks: Subscribe<CSS3DRenderEventMap>;
-    opacityMesh?: OpacityMesh;
-    constructor(params: {
-        container: T;
-        mode?: 'front' | 'behind';
-        cornerPoints: CornerPoints;
-        ratio?: number;
-        dpr?: number;
-        pointerEvents?: 'none' | 'auto';
-    });
-    setVisible(visible: boolean): void;
-    removeFromParent(): this;
-    removeOpacityMesh(): this;
-    dispose(): void;
-    getOpacityMesh(): OpacityMesh;
+    readonly isCSS3DObjectPlus: true;
+    constructor(container: T, cornerPoints: CornerPoints, ratio?: number, dpr?: number, mode?: Mode);
+    changeMode(mode: 'front'): void;
+    changeMode(mode: 'behind', scene: THREE.Scene): void;
+    applyScaleMatrix4(matrix: Matrix4): void;
     applyMatrix4(matrix: Matrix4): void;
     applyQuaternion(quaternion: Quaternion): this;
-    applyScaleMatrix4(matrix: Matrix4): void;
-    /**
-     * @description: 生成透明Mesh
-     */
-    private createOpacityMesh;
 }

package/dist/CSS3DRenderPlugin/utils/evenNumber.d.ts

@@ -0,0 +1,3 @@
+export declare function evenNumber(num: number, config?: {
+    smaller?: boolean;
+}): number;

package/dist/CSS3DRenderPlugin/utils/index.d.ts

@@ -1,4 +1,4 @@
 export * from './centerPoint';
-export * from './even';
+export * from './evenNumber';
 export * from './random';
 export * from './positionToVector3';

package/dist/ModelEntryDoorGuidePlugin/Plugin.d.ts

@@ -7,6 +7,7 @@ export interface ModelEntryDoorGuidePluginData {
 }
 export declare type ModelEntryDoorGuidePluginParameterType = {
     animationEnabled?: boolean;
+    name?: string;
 } & ModelEntryDoorGuidePluginData;
 export interface ModelEntryDoorGuidePluginExportType {
     enable: (config?: {

package/dist/Object3DHelperPlugin/Controller.d.ts

@@ -11,8 +11,6 @@ export declare class Object3DHelperController extends BasePlugin.Controller<Obje
     name: string;
     state: Object3DHelperState;
     objectHelperMap: Map<THREE.Object3D, Object3DHelper>;
-    private css3DObjectParentMap;
-    private css3DRender;
     constructor(five: Five);
     /**
      * @description Show guide line