@realsee/dnalogel 2.1.2-alpha.10 → 2.1.2-alpha.12

package/dist/shared-utils/Object3DHelper/Base/BaseController.d.ts

@@ -0,0 +1,48 @@
+import * as THREE from 'three';
+import { Subscribe } from '../../Subscribe';
+import type { HelperEventMap } from '../typings';
+import type { BaseHelper } from './BaseHelper';
+import DomEvents from '../utils/threex/domevents';
+export declare let originOpacity: {
+    opacity: number;
+} | null;
+export declare abstract class BaseController<T extends BaseHelper = BaseHelper, K extends THREE.Object3D = THREE.Object3D> {
+    hooks: Subscribe<HelperEventMap>;
+    helperObject3D: T;
+    originObject3D: K;
+    protected camera: THREE.Camera;
+    protected model: THREE.Object3D;
+    protected scene: THREE.Scene;
+    protected container: HTMLElement;
+    protected domEvents: DomEvents;
+    protected isDragging: boolean;
+    protected onRender: () => void;
+    protected enabled: boolean;
+    constructor(camera: THREE.Camera, model: THREE.Object3D, originObject3D: K, helperObject3D: T, container: HTMLElement, scene: THREE.Scene, onRender?: () => void);
+    initialHelperPosition(): void;
+    initialHelperQuaternion(): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    setOpacity(opacity: number): void;
+    restoreOpacity(): void;
+    setOriginOpacityProperty(): void;
+    updateHelperPosition(): void;
+    updateHelperQuaternion(): void;
+    applyHelperMatrix4(matrix4: THREE.Matrix4): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    applyHelperScaleMatrix4(matrix4: THREE.Matrix4, params?: {
+        origin?: THREE.Vector3;
+        helperOrigin?: THREE.Vector3;
+    }): void;
+    onWantsTapGesture: (raycaster: THREE.Raycaster) => false | void;
+    onWantsGesture(type: 'press' | 'pan' | string, pointers: {
+        x: number;
+        y: number;
+    }[], final: boolean): false | void;
+    protected render(): void;
+    protected hoverListener(object3D: THREE.Object3D | undefined | THREE.Group | (THREE.Object3D | undefined | THREE.Group)[], hoverColor?: THREE.Color | string | number, hoverOpacity?: number): () => void;
+    private getIntersectObject;
+}

package/dist/shared-utils/Object3DHelper/Base/BaseHelper.d.ts

@@ -0,0 +1,91 @@
+import type { Create3DElementReturnType } from '../../../CSS3DRenderPlugin';
+import type * as THREE from 'three';
+import { Mesh, Object3D, Vector3 } from 'three';
+import type { Direction, Direction4 } from '../typings';
+import type { tipsDom } from '../Helper/HTML/tipsDom';
+export declare abstract class BaseHelper<OriginObject3D extends Object3D = Object3D> extends Object3D {
+    protected originObject3D: OriginObject3D;
+    protected onRender: () => any;
+    get helperObject(): Object3D;
+    constructor(originObject3D: OriginObject3D, config?: {
+        onRender?: () => any;
+    });
+    render(): void;
+    show(): void;
+    hide(): void;
+    updatePosition(): void;
+    updateQuaternion(): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+        origin?: THREE.Vector3;
+        helperOrigin?: THREE.Vector3;
+    }): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    abstract showDraggingHelper(directions?: Direction[]): void;
+    abstract dispose(): void;
+}
+export declare abstract class MoveHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+    abstract xArrow?: Object3D & {
+        arrow: Object3D;
+        line?: Object3D;
+        direction: Direction;
+    };
+    abstract yArrow?: Object3D & {
+        arrow: Object3D;
+        line?: Object3D;
+        direction: Direction;
+    };
+    abstract zArrow?: Object3D & {
+        arrow: Object3D;
+        line?: Object3D;
+        direction: Direction;
+    };
+}
+export declare abstract class RotateHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+    abstract xyCircle: Mesh & {
+        direction: Direction;
+    };
+    abstract xzCircle: Mesh & {
+        direction: Direction;
+    };
+    abstract yzCircle: Mesh & {
+        direction: Direction;
+    };
+    abstract xRingHelper: Object3D;
+    abstract yRingHelper: Object3D;
+    abstract zRingHelper: Object3D;
+    abstract xAngleHelper: Object3D & {
+        baseAxes: Vector3;
+        direction: Direction;
+    };
+    abstract yAngleHelper: Object3D & {
+        baseAxes: Vector3;
+        direction: Direction;
+    };
+    abstract zAngleHelper: Object3D & {
+        baseAxes: Vector3;
+        direction: Direction;
+    };
+    abstract angleTips?: ReturnType<typeof tipsDom>;
+    abstract showDraggingHelper(directions: Direction[]): void;
+    abstract updateAngleHelperQuaternion(): void;
+}
+export declare abstract class ScaleHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+}
+declare type NonVoid<T> = T extends void ? never : T;
+export declare abstract class RectangleScaleHelperAbstract<OriginObject3D extends Object3D, PointType extends Object3D | HTMLElement> extends ScaleHelperAbstract<OriginObject3D> {
+    abstract points: PointType extends Object3D ? {
+        point: PointType;
+        direction: Direction4;
+    }[] : {
+        point: PointType;
+        direction: Direction4;
+        position: Vector3;
+    }[];
+    abstract cornerPositions: Vector3[];
+    abstract css3DInstance?: NonVoid<Create3DElementReturnType>;
+    abstract plane?: THREE.Mesh;
+    abstract updatePoints(): void;
+    abstract enable(): void;
+    abstract disable(): void;
+}
+export {};

package/dist/shared-utils/Object3DHelper/Constants/color.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+declare const AXES_COLOR: {
+    X: number;
+    Y: number;
+    Z: number;
+};
+declare class AXES_THREE_COLOR {
+    static get X(): THREE.Color;
+    static get Y(): THREE.Color;
+    static get Z(): THREE.Color;
+}
+export { AXES_COLOR, AXES_THREE_COLOR };

package/dist/shared-utils/Object3DHelper/Controller/CSS3DScaleController.d.ts

@@ -0,0 +1,6 @@
+import type { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import { RectangleScaleController } from './RectangleScaleController';
+export declare class CSS3DScaleController extends RectangleScaleController<CSS3DObject, HTMLElement> {
+    constructor(...params: ConstructorParameters<typeof RectangleScaleController<CSS3DObject, HTMLElement>>);
+    private addHTMLEventListener;
+}

package/dist/shared-utils/Object3DHelper/Controller/MoveController.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from '../Base/BaseController';
+import type { MoveHelperAbstract } from '../Helper';
+export declare class MoveController<T extends MoveHelperAbstract = MoveHelperAbstract> extends BaseController<T> {
+    private startInfo?;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    private move;
+    private dragEnd;
+}

package/dist/shared-utils/Object3DHelper/Controller/RectangleScaleController.d.ts

@@ -0,0 +1,37 @@
+import { BaseController } from '../Base/BaseController';
+import type { RectangleScaleHelperAbstract } from '../Helper';
+import * as THREE from 'three';
+import type { Direction4 } from '../typings';
+import { Vector3 } from 'three';
+interface StartInfo {
+    startPoint: {
+        position: Vector3;
+        direction: Direction4;
+    };
+    dragPointInCenterBottom?: boolean | null;
+    dragPointInCenterLeft?: boolean | null;
+    plane: THREE.Plane;
+}
+export declare abstract class RectangleScaleController<OriginObject3D extends THREE.Object3D, PointType extends THREE.Object3D | HTMLElement> extends BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>> {
+    protected startInfo?: StartInfo;
+    constructor(...params: ConstructorParameters<typeof BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>>>);
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    protected getDragPlane(): THREE.Plane;
+    protected dragStart(mousePoint: {
+        x: number;
+        y: number;
+    }, point: {
+        position: THREE.Vector3;
+        direction: Direction4;
+    }): void;
+    protected dragging(point: {
+        x: number;
+        y: number;
+    }): false | void;
+    protected scale(raycaster: THREE.Raycaster): void;
+    protected dragEnd(): void;
+}
+export {};

package/dist/shared-utils/Object3DHelper/Controller/RotateController.d.ts

@@ -0,0 +1,22 @@
+import { BaseController } from '../Base/BaseController';
+import type { RotateHelperAbstract } from '../Helper';
+export declare class RotateController<T extends RotateHelperAbstract = RotateHelperAbstract> extends BaseController<T> {
+    private startInfo?;
+    private lastRotation?;
+    private rotations;
+    private helperObject3DQuaternion;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    initialHelperQuaternion(): void;
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    private rotate;
+    private dragEnd;
+    private getAngleHelper;
+    private setAngleHelperStart;
+    private setAngleHelperLength;
+    private setTipsAngle;
+    private setTipsPosition;
+}

package/dist/shared-utils/Object3DHelper/Helper/HTML/rectangleScaleDom.d.ts

@@ -0,0 +1,11 @@
+import type { Direction4 } from '../../typings';
+interface Square {
+    element: HTMLElement;
+    direction: Direction4;
+}
+export declare function rectangleScaleDom(): {
+    container: HTMLElement;
+    squares: [Square, Square, Square, Square, Square, Square, Square, Square];
+};
+export declare function backgroundDom(): HTMLElement;
+export {};

package/dist/shared-utils/Object3DHelper/Helper/HTML/tipsDom.d.ts

@@ -0,0 +1,6 @@
+export declare function tipsDom(style?: Partial<CSSStyleDeclaration>): {
+    element: HTMLElement;
+    show: () => void;
+    hide: () => void;
+    setLeftTop: (left: string, top: string) => void;
+};

package/dist/shared-utils/Object3DHelper/Helper/HTML/utils/createElement.d.ts

@@ -0,0 +1,2 @@
+export declare function createElement(style?: Partial<CSSStyleDeclaration>, tagName?: string): HTMLElement;
+export declare function setStyle(element: HTMLElement, style?: Partial<CSSStyleDeclaration>): HTMLElement;

package/dist/shared-utils/Object3DHelper/Helper/MoveHelper.d.ts

@@ -0,0 +1,13 @@
+import type { Object3D } from 'three';
+import type { Direction } from '../typings';
+import { MoveHelperAbstract } from '.';
+import { ArrowGroup } from './Objects/ArrowGroup';
+export declare class MoveHelper extends MoveHelperAbstract {
+    xArrow: ArrowGroup;
+    yArrow: ArrowGroup;
+    zArrow: ArrowGroup;
+    constructor(originObject3D: Object3D);
+    show(): void;
+    showDraggingHelper(directions: Direction[]): void;
+    dispose(): void;
+}

package/dist/shared-utils/Object3DHelper/Helper/Objects/ArrowGroup.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import type { Direction } from '../../typings';
+import { DirectionGroup, DirectionMesh } from '../../utils';
+interface InstanceParameter {
+    direction: Direction;
+    color?: THREE.Color | string | number;
+}
+export declare class ArrowGroup extends DirectionGroup {
+    line: DirectionMesh<THREE.Geometry, THREE.MeshBasicMaterial>;
+    arrow: DirectionMesh<THREE.ConeGeometry, THREE.MeshBasicMaterial>;
+    private lineHeight;
+    private arrowHeight;
+    constructor(param: InstanceParameter);
+    private formatArrow;
+    private formatLine;
+}
+export {};

package/dist/shared-utils/Object3DHelper/Helper/OutlineHelper.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+export declare class OutlineHelper extends THREE.Group {
+    box: THREE.Mesh<THREE.BufferGeometry, THREE.MeshBasicMaterial>;
+    outline: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    private originObject;
+    private positionAttribute;
+    constructor(obj: THREE.Object3D);
+    private update;
+    private createOutline;
+    private createBox;
+}

package/dist/shared-utils/Object3DHelper/Helper/RectangleScaleHelper.d.ts

@@ -0,0 +1,40 @@
+import * as THREE from 'three';
+import { RectangleScaleHelperAbstract } from '.';
+import type { Create3DElementReturnType } from '../../../CSS3DRenderPlugin';
+import type { Vector3 } from 'three';
+import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import type { CSS3DObjectPlus } from '../../../CSS3DRenderPlugin/utils/CSS3DObjectPlus';
+declare type NonVoid<T> = T extends void ? never : T;
+declare type OriginObjectType = CSS3DObject | THREE.Object3D;
+export declare class RectangleScaleHelper<T extends OriginObjectType = OriginObjectType> extends RectangleScaleHelperAbstract<T, HTMLElement> {
+    points: RectangleScaleHelperAbstract<THREE.Object3D, HTMLElement>['points'];
+    cornerPositions: Vector3[];
+    css3DInstance?: NonVoid<Create3DElementReturnType>;
+    get helperObject(): CSS3DObjectPlus<HTMLElement>;
+    plane?: THREE.Mesh<THREE.PlaneGeometry, THREE.MeshBasicMaterial>;
+    private css3DRenderer;
+    private camera;
+    private scene;
+    private container;
+    private enabled;
+    constructor(originObject3D: T, container: Element, camera: THREE.Camera, scene: THREE.Scene);
+    updatePosition(): void;
+    updateQuaternion(): void;
+    applyMatrix4(matrix: THREE.Matrix4): void;
+    showDraggingHelper(): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+        origin?: Vector3;
+        helperOrigin?: Vector3;
+    }): void;
+    updatePoints(): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    private initRectangleScaleHelper;
+    private getCornerPositions;
+    private calculatePointPosition;
+}
+export {};

package/dist/shared-utils/Object3DHelper/Helper/RotateHelper.d.ts

@@ -0,0 +1,55 @@
+import * as THREE from 'three';
+import type { Object3D } from 'three';
+import { RotateHelperAbstract } from '../Base/BaseHelper';
+import type { Color, Direction } from '../typings';
+import { tipsDom } from './HTML/tipsDom';
+export declare class RotateHelper extends RotateHelperAbstract {
+    yzCircle: Circle;
+    xzCircle: Circle;
+    xyCircle: Circle;
+    xRingHelper: AxesDashedRing;
+    yRingHelper: AxesDashedRing;
+    zRingHelper: AxesDashedRing;
+    xAngleHelper: Sector;
+    yAngleHelper: Sector;
+    zAngleHelper: Sector;
+    angleTips?: ReturnType<typeof tipsDom>;
+    private container?;
+    constructor(originObject3D: Object3D, angleTipsParams?: {
+        container: HTMLElement;
+    });
+    updateAngleHelperQuaternion(): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    hide(): void;
+    show(): void;
+    showDraggingHelper(directions: Direction[]): void;
+    dispose(): void;
+    private filterRingHelper;
+    private filterAngleHelper;
+}
+declare class Circle extends THREE.Mesh {
+    direction: Direction;
+    material: THREE.MeshBasicMaterial;
+    gapAngle: number;
+    geometry: THREE.RingGeometry;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+}
+declare class AxesDashedRing extends THREE.Group {
+    direction: Readonly<Direction>;
+    constructor(options: {
+        direction: Direction;
+    });
+}
+declare class Sector extends THREE.Mesh {
+    direction: Direction;
+    material: THREE.MeshBasicMaterial;
+    baseAxes: THREE.Vector3;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+}
+export {};

package/dist/shared-utils/Object3DHelper/Helper/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../Base/BaseHelper';
+export * from './MoveHelper';
+export * from './RotateHelper';
+export * from './RectangleScaleHelper';
+export * from './OutlineHelper';

package/dist/shared-utils/Object3DHelper/index.d.ts

@@ -0,0 +1,71 @@
+import type { OutlineHelper } from './Helper';
+import type { Object3DHelperEventMap, Object3DHelperState } from './typings';
+import type { MoveController } from './Controller/MoveController';
+import type { RotateController } from './Controller/RotateController';
+import type { BaseController } from './Base/BaseController';
+import { Subscribe } from '../Subscribe';
+interface Controllers {
+    moveController?: MoveController;
+    rotateController?: RotateController;
+    scaleController?: BaseController;
+}
+interface Helpers {
+    outlineHelper?: OutlineHelper;
+}
+export declare class Object3DHelper {
+    controllers: Controllers;
+    state: Object3DHelperState;
+    hooks: Subscribe<Object3DHelperEventMap>;
+    private helpers;
+    private eventListener;
+    constructor(controllers?: Controllers, helpers?: Helpers);
+    /**
+     * @description Show guide line
+     */
+    show(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Hide guide line
+     */
+    hide(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Enable
+     */
+    enable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Disable
+     */
+    disable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Dispose
+     */
+    dispose(): void;
+    setState(state: Partial<Object3DHelperState>, options?: {
+        userAction?: boolean;
+    } & Record<string, any>): void;
+    addControllers(controllers: Controllers): void;
+    addHelpers(helpers: Partial<{
+        [K in keyof Helpers]: Helpers[K];
+    }>): void;
+    getCurrentState(): Object3DHelperState;
+    private addEventListener;
+    private handleEnd;
+    private handleStart;
+    private setOtherHelpersVisible;
+    private handlePositionUpdate;
+    private handleScaleUpdate;
+    private handleRotateUpdate;
+    private handleEnable;
+    private handleVisible;
+    private everyControllerDo;
+    private handleDispose;
+    private actionIfStateIsEnabled;
+}
+export {};

package/dist/shared-utils/Object3DHelper/typings/Direction.d.ts

@@ -0,0 +1,2 @@
+export declare type Direction = 'x' | 'y' | 'z';
+export declare type Direction4 = 'nesw' | 'nwse' | 'ns' | 'ew';

package/dist/shared-utils/Object3DHelper/typings/Hooks.d.ts

@@ -0,0 +1,45 @@
+import type * as THREE from 'three';
+export declare type HelperEventMap = {
+    moveStart: () => void;
+    rotateStart: () => void;
+    scaleStart: () => void;
+    positionUpdate: (position: {
+        matrix4?: THREE.Matrix4;
+    } | undefined) => void;
+    rotateUpdate: (rotate: {
+        quaternion?: THREE.Quaternion;
+        origin: THREE.Vector3;
+    } | undefined) => void;
+    scaleUpdate: (scale: {
+        matrix4?: THREE.Matrix4;
+        origin?: THREE.Vector3;
+        helperOrigin: THREE.Vector3;
+    } | undefined) => void;
+    moveEnd: () => void;
+    rotateEnd: () => void;
+    scaleEnd: () => void;
+};
+export interface Object3DHelperState {
+    enabled: boolean;
+    visible: boolean;
+    disposed: boolean;
+}
+export declare type Object3DHelperEventMap = {
+    show: (options?: {
+        userAction?: boolean;
+    }) => void;
+    hide: (options?: {
+        userAction?: boolean;
+    }) => void;
+    enable: (options?: {
+        userAction?: boolean;
+    }) => void;
+    disable: (options?: {
+        userAction?: boolean;
+    }) => void;
+    dispose: () => void;
+    stateChange: (params: {
+        state: Object3DHelperState;
+        prevState?: Object3DHelperState;
+    }) => void;
+};

package/dist/shared-utils/Object3DHelper/typings/Scissor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 显示区域裁剪参数
+ * @description
+ * 可通过初始化，或者 setScissor 方式设置
+ * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
+ * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
+ */
+export interface Scissor {
+    /** 距离左侧 */
+    left: number;
+    /** 距离下侧 */
+    bottom: number;
+    /** 宽度 */
+    width: number;
+    /** 高度 */
+    height: number;
+}

package/dist/shared-utils/Object3DHelper/typings/index.d.ts

@@ -0,0 +1,5 @@
+import type * as THREE from 'three';
+export * from './Scissor';
+export * from './Direction';
+export * from './Hooks';
+export declare type Color = THREE.Color | string | number;

package/dist/shared-utils/Object3DHelper/utils/calculateThreeMouse.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+/**
+ * 计算 three 中的 mouse 的值
+ * @param  mouseXY - 鼠标相对屏幕位置
+ * @param  element - canvas元素（three的展示元素）
+ * @param  scissor - 屏幕剪裁
+ */
+export declare function calculateThreeMouse(originMouse: {
+    x: number;
+    y: number;
+}, element: HTMLElement): THREE.Vector2 & {
+    x: number;
+    y: number;
+};

package/dist/shared-utils/Object3DHelper/utils/direction.d.ts

@@ -0,0 +1,14 @@
+import type { Direction } from '../typings';
+import * as THREE from 'three';
+export declare class DirectionGroup extends THREE.Group {
+    direction: Direction;
+    constructor(direction?: Direction);
+}
+export declare class DirectionLine<T extends THREE.Geometry, K extends THREE.Material> extends THREE.Line<T, K> {
+    direction: Direction;
+    constructor(geometry?: T, material?: K, direction?: Direction);
+}
+export declare class DirectionMesh<T extends THREE.Geometry, K extends THREE.Material> extends THREE.Mesh<T, K> {
+    direction: Direction;
+    constructor(geometry?: T, material?: K, direction?: Direction);
+}

package/dist/shared-utils/Object3DHelper/utils/filterNotColinearPoints.d.ts

@@ -0,0 +1,2 @@
+import type { Vector3 } from 'three';
+export declare function filterNotColinearPoints(positions: Vector3[]): [Vector3, Vector3, Vector3] | void;

package/dist/shared-utils/Object3DHelper/utils/getMouseRaycaster.d.ts

@@ -0,0 +1,5 @@
+import * as THREE from 'three';
+export declare function getMouseRaycaster(camera: THREE.Camera, mouse: {
+    x: number;
+    y: number;
+}, element: HTMLElement): THREE.Raycaster;

package/dist/shared-utils/Object3DHelper/utils/getPoint.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three';
+export default function getPoint(position?: THREE.Vector3, colorIndex?: number): THREE.Mesh<THREE.SphereGeometry, THREE.MeshBasicMaterial>;
+export declare function getAllMesh(): any[];

package/dist/shared-utils/Object3DHelper/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from '../../../CSS3DRenderPlugin/utils';
+export * from './direction';
+export * from './calculateThreeMouse';
+export * from './normalPositionToPositions';
+export * from './object3DBoundingPosition';
+export * from './getMouseRaycaster';
+export * from './filterNotColinearPoints';
+export * from './vectorIsEqual';

package/dist/shared-utils/Object3DHelper/utils/normalPositionToPositions.d.ts

@@ -0,0 +1,5 @@
+import type { Vector3 } from 'three';
+export declare function normalPositionToPositions(cameraPosition: Vector3, position: Vector3, normal: Vector3, config?: {
+    width?: number;
+    height?: number;
+}): [Vector3, Vector3, Vector3, Vector3];

package/dist/shared-utils/Object3DHelper/utils/object3DBoundingPosition.d.ts

@@ -0,0 +1 @@
+export declare function object3DBoundingPosition(): void;

package/dist/shared-utils/Object3DHelper/utils/threex/domevents/index.d.ts

@@ -0,0 +1,34 @@
+import type * as THREE from 'three'
+
+type EventName =
+  | 'click'
+  | 'dblclick'
+  | 'mouseover'
+  | 'mouseout'
+  | 'mousemove'
+  | 'mousedown'
+  | 'mouseup'
+  | 'contextmenu'
+  | 'touchstart'
+  | 'touchend'
+
+declare class DomEvents {
+  public constructor(camera: THREE.Camera, domElement: HTMLElement)
+
+  public addEventListener<T extends EventName, K extends THREE.Object3D>(
+    object: K,
+    eventName: T,
+    callback: (params: {
+      type: T
+      target: K
+      origDomEvent: Event
+      intersect: THREE.Intersection & { object: K }
+      stopPropagation: () => void
+    }) => void,
+    useCapture?: boolean,
+  ): void
+
+  public removeEventListener(object: THREE.Object3D, eventName: EventName, callback: (params: any) => void, useCapture?: boolean): void
+}
+
+export default DomEvents

package/dist/shared-utils/Object3DHelper/utils/vectorIsEqual.d.ts

@@ -0,0 +1,2 @@
+import type * as THREE from 'three';
+export declare function vectorIsEqual(vector1: THREE.Vector3, vector2: THREE.Vector3): boolean;