@realsee/dnalogel 2.2.6 → 2.3.0

package/dist/CSS3DRenderPlugin/CSS3DRender.d.ts

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

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;
-        dispose: () => boolean;
-        css3DObject: import("./utils/CSS3DObjectPlus").CSS3DObjectPlus<HTMLElement>;
+        css3DObject: import("./utils/three/CSS3DObject").CSS3DObjectPlus<HTMLElement>;
         show: () => void;
         hide: () => void;
         setVisible: (visible: boolean) => void;
-        disable: () => void;
         enable: () => void;
+        disable: () => void;
         setEnabled: (enabled: boolean) => void;
-        appendToElement: (container: Element) => void;
+        dispose: () => boolean;
+        appendToElement: (element: HTMLElement) => import("./utils/three/CSS3DRenderer").default;
     };
-    private getBehindFiveElement;
+    getBehindFiveElement(): HTMLElement;
 }

package/dist/CSS3DRenderPlugin/index.d.ts

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

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

@@ -0,0 +1,4 @@
+export default function createResizeObserver(element: Element, resizeHandler: (width: number, height: number) => any, fireImmediately?: boolean): {
+    observe: () => void;
+    unobserve: () => void;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * @description: 获取一个数字的最近的偶数
+ * @param { number } num
+ * @param { boolean } config.floor 是否取较小的偶数，默认为false，即取较大的偶数
+ * @return { number } 返回一个偶数
+ */
+export declare function even(num: number, config?: {
+    floor?: boolean;
+}): number;

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

@@ -0,0 +1,2 @@
+import type { Five } from '@realsee/five';
+export default function generateBehindFiveElement(five: Five): HTMLDivElement;

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

@@ -0,0 +1,3 @@
+import type { Object3D } from 'three';
+import type { CSS3DObjectPlus } from './three/CSS3DObject';
+export default function getAllCSS3DObject(...object: Object3D[]): CSS3DObjectPlus<HTMLElement>[];

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

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

package/dist/CSS3DRenderPlugin/utils/three/CSS3DGroup.d.ts

@@ -0,0 +1,25 @@
+import * as THREE from 'three';
+import { Subscribe } from '../../../shared-utils/Subscribe';
+import type { Object3D } from 'three';
+import type { Mode } from './CSS3DObject';
+export declare class CSS3DGroup extends THREE.Group {
+    readonly isCSS3DGroup = true;
+    mode: Mode;
+    CSS3DObjectLength: number;
+    hooks: Subscribe<{
+        visibleChange: (visible: boolean) => void;
+    }>;
+    constructor(mode: Mode);
+    add(...objects: Object3D[]): this;
+    setVisible(visible: boolean): void;
+    remove(...objects: Object3D[]): this;
+    private updateLength;
+}
+export declare class CSS3DFrontGroup extends CSS3DGroup {
+    constructor();
+}
+export declare class CSS3DBehindGroup extends CSS3DGroup {
+    private scene;
+    constructor(scene: THREE.Scene);
+    add(...objects: Object3D[]): this;
+}

package/dist/CSS3DRenderPlugin/utils/{CSS3DObjectPlus.d.ts → three/CSS3DObject.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 type * as THREE from 'three';
+import { Subscribe } from '../../../shared-utils/Subscribe';
+import OpacityMesh from './OpacityMesh';
 export declare const MinRatio = 0.00216;
 export declare const DefaultRatio = 0.003;
 export declare type Mode = 'front' | 'behind';
@@ -10,25 +10,45 @@ 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: string;
+    version: number;
+    readonly isCSS3DObjectPlus: true;
+    container: T;
     width: number;
     height: number;
     domWidthPx: number;
     domHeightPx: number;
     cornerPoints: CornerPoints;
-    ratio: number;
-    container: T;
     centerPosition: Vector3;
+    ratio: number;
     mode: 'front' | 'behind';
     readonly hooks: Subscribe<CSS3DRenderEventMap>;
-    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;
+    opacityMesh?: OpacityMesh;
+    private selfVisible;
+    private parentVisibleListenerDisposer?;
+    constructor(params: {
+        container: T;
+        mode?: 'front' | 'behind';
+        cornerPoints: CornerPoints;
+        ratio?: number;
+        dpr?: number;
+        pointerEvents?: 'none' | 'auto';
+    });
+    setVisible(visible: boolean, params?: {
+        setSelfVisible: boolean;
+    }): void;
+    removeFromParent(): this;
+    removeOpacityMesh(): this;
+    dispose(): void;
+    getOpacityMesh(): OpacityMesh;
     applyMatrix4(matrix: Matrix4): void;
     applyQuaternion(quaternion: Quaternion): this;
+    applyScaleMatrix4(matrix: Matrix4): void;
+    /**
+     * @description: 生成透明Mesh
+     */
+    private createOpacityMesh;
+    private addParentVisibleListener;
+    private removeParentVisibleListener;
 }

package/dist/CSS3DRenderPlugin/utils/three/CSS3DRenderer.d.ts

@@ -0,0 +1,14 @@
+import { CSS3DRenderer } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import type * as THREE from 'three';
+export default class ICSS3DRenderer extends CSS3DRenderer {
+    wrapper?: HTMLElement;
+    private requestAnimationFrameId?;
+    private resizeDisoper?;
+    constructor();
+    setWrapper(wrapper: HTMLElement): this;
+    appendToElement(wrapper: HTMLElement): void;
+    renderEveryFrame(scene: THREE.Scene, camera: THREE.Camera): void;
+    stopRender(): void;
+    dispose(): void;
+}
+export { ICSS3DRenderer };

package/dist/CSS3DRenderPlugin/utils/three/CSS3DScene.d.ts

@@ -0,0 +1,12 @@
+import type { Object3D } from 'three';
+import * as THREE from 'three';
+export declare class CSS3DFrontScene extends THREE.Scene {
+    constructor();
+    add(...objects: Object3D[]): this;
+}
+export declare class CSS3DBehindScene extends THREE.Scene {
+    private scene;
+    constructor(scene: THREE.Scene);
+    add(...objects: Object3D[]): this;
+    remove(...objects: Object3D[]): this;
+}

package/dist/CSS3DRenderPlugin/utils/three/OpacityMesh.d.ts

@@ -0,0 +1,6 @@
+import * as THREE from 'three';
+export default class OpecityMesh extends THREE.Mesh {
+    name: string;
+    constructor(width: number, height: number);
+    removeFromParent(): this;
+}

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

@@ -0,0 +1,2 @@
+import type { Five } from '@realsee/five';
+export default function fiveModelLoaded(five: Five): Promise<void>;

package/dist/Object3DHelperPlugin/Controller.d.ts

@@ -11,6 +11,8 @@ 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