@realsee/five 6.8.0-alpha.9 → 6.8.1

package/plugins/Object3DHelperPlugin/Controllers/MoveController.d.ts

@@ -0,0 +1,66 @@
+import { BaseController } from './BaseController';
+import * as THREE from 'three';
+import type { MoveHelperAbstract } from '../Helper/BaseHelper';
+export declare function rayOnLine(params: {
+    raycaster: THREE.Raycaster;
+    line: THREE.Line3;
+    clampToLine?: boolean;
+}): THREE.Vector3;
+export type UseFaceNormalInterface = {
+    /**
+     * 是否使用面的法线，默认为true
+     */
+    enable?: boolean;
+    /**
+     * 期望对齐的方向，默认为Y轴对齐Face的法向向量，即 `{ x: 0, y: 1, z: 0 }`
+     */
+    alignmentVector?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    /**
+     * 修正后的face normal
+     */
+    fixedFaceNormal?: (face: THREE.Vector3) => THREE.Vector3;
+} | boolean;
+export declare class MoveController<T extends MoveHelperAbstract = MoveHelperAbstract> extends BaseController<T> {
+    get moveByMouseEnable(): boolean;
+    protected name: string;
+    private startInfo?;
+    /** 拖拽时用于显示方向参考的直线（与 ScaleController 一致：Line + LineBasicMaterial） */
+    private dragGuideLine?;
+    private solidGuide;
+    private _moveByMouse;
+    private mouseInfo?;
+    private mousedownEventListenerDisposer?;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    dispose(): void;
+    /**
+     * @description: 跟随鼠标移动
+     */
+    moveByMouse(params?: {
+        /** 是否使用面的法线，默认为false */
+        useFaceNormal: UseFaceNormalInterface;
+    }): void;
+    /**
+     * @description: 禁用跟随鼠标移动
+     */
+    disableMoveByMouse(): void;
+    onIntersectionOnModelUpdate(intersection: THREE.Intersection): void;
+    private handleMouseDown;
+    private handleMouseUp;
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    /**
+     * 更新直线缩放，保持视觉上的恒定大小（与 ScaleController 保持一致）
+     */
+    private updateDragGuideLineScale;
+    private move;
+    private dragEnd;
+    private setTipsText;
+    private setTipsPosition;
+}

package/plugins/Object3DHelperPlugin/Controllers/RotateController.d.ts

@@ -0,0 +1,61 @@
+import { BaseController } from './BaseController';
+import type { RotateHelperAbstract } from '../Helper/BaseHelper';
+import * as THREE from 'three';
+export declare class RotateController<T extends RotateHelperAbstract = RotateHelperAbstract> extends BaseController<T> {
+    protected name: string;
+    private get rotateCenter();
+    private startInfo?;
+    private removeListener?;
+    private solidGuide;
+    private snapGuideLines;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    setRotateAngle(angle: {
+        x?: number;
+        y?: number;
+        z?: number;
+    }): void;
+    /**
+     * @description 通过改变欧拉角中的某一个值来改变旋转，但保持其他两个轴的旋转不变
+     * @param axis 要修改的轴 ('x' | 'y' | 'z')
+     * @param angle 新的角度值（度）
+     * @returns 新的四元数值
+     */
+    getEulerAngle(axis: 'x' | 'y' | 'z', angle: number): THREE.Quaternion;
+    protected onApplyOriginObjectRotate(params: {
+        quaternion: THREE.Quaternion;
+        origin: THREE.Vector3;
+    }): void;
+    protected onApplyOriginObjectScale(params: {
+        matrix: THREE.Matrix4;
+        origin?: THREE.Vector3;
+    }): void;
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private getMatrix;
+    private getMatrixAngle;
+    private parseAngleByDirection;
+    private dragging;
+    private rotate;
+    private dragEnd;
+    private updateOtherHelpers;
+    private getAngleHelper;
+    private setAngleHelperStart;
+    private setAngleHelperLength;
+    private setTipsAngle;
+    private setTipsPosition;
+    /**
+     * 从 quaternion 提取绕指定轴的旋转角度
+     * 通过投影分解，不受万向锁影响
+     */
+    private extractAxisAngle;
+    /**
+     * 显示吸附辅助线：在旋转平面上显示两条轴线
+     */
+    private showSnapGuideLines;
+    /**
+     * 移除吸附辅助线
+     */
+    private removeSnapGuideLines;
+}

package/plugins/Object3DHelperPlugin/FiveControllerWrapper.d.ts

@@ -0,0 +1,17 @@
+import type { Five } from '@realsee/five';
+import type { BaseController } from './Controllers/BaseController';
+import type * as THREE from 'three';
+import type { Subscribe } from '@realsee/five';
+import DomEvents from '../thirdParty/domevents';
+type ControllerClass = new (...params: ConstructorParameters<typeof BaseController<any>>) => any;
+declare class ControllerWrapper<HelperControllerInterface extends ControllerClass> {
+    helperController?: InstanceType<HelperControllerInterface>;
+    private five;
+    constructor(five: Five, donEvents: DomEvents, HelperController: HelperControllerInterface, object: THREE.Object3D, helperObject3D: InstanceType<HelperControllerInterface>['helperObject3D'], HelperControllerConfig?: any, hooks?: Subscribe<any>, internalHooks?: Subscribe<any>, helperGroup?: THREE.Object3D);
+    dispose(): void;
+    private onFiveWantsTapGesture;
+    private onFiveWantsGesture;
+    private onFiveIntersectionOnModelUpdate;
+}
+export { ControllerWrapper };
+export { ControllerWrapper as FiveControllerWrapper };

package/plugins/Object3DHelperPlugin/Helper/BaseHelper.d.ts

@@ -0,0 +1,97 @@
+import * as THREE from 'three';
+import type { Group, Mesh, Object3D } from 'three';
+import { Vector3 } from 'three';
+import type { Direction, PositionFrom } from '../typing';
+import type { tipsDom } from '../utils/tipsDom';
+export interface BaseHelperConfig {
+    onRender?: () => any;
+    /**
+     * @description: helper 初始位置来源
+     * @default 'objectPosition'
+     */
+    positionFrom?: PositionFrom;
+}
+export declare abstract class BaseHelper<OriginObject3D extends Object3D = Object3D> extends THREE.Object3D {
+    protected originObject3D: OriginObject3D;
+    protected onRender: () => any;
+    private positionFrom;
+    removeChildren(): this;
+    add(...objects: Object3D[]): this;
+    addIfNotExists(...objects: Object3D[]): this;
+    remove(...objects: Object3D[]): this;
+    removeFromParent(): this;
+    get helperObject(): Object3D;
+    constructor(originObject3D: OriginObject3D, config?: BaseHelperConfig);
+    render(): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    raycasterIntersectObject(raycaster: THREE.Raycaster, intersection?: THREE.Intersection[]): THREE.Intersection[];
+    initialPosition(offset?: THREE.Vector3): void;
+    setScaleByCamera(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
+    initQuaternion(config?: {
+        xAxis?: Vector3 | (() => Vector3);
+        yAxis?: Vector3 | (() => Vector3);
+        zAxis?: Vector3 | (() => Vector3);
+    }): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, origin?: Vector3): void;
+    setHelperQuaternion(quaternion: THREE.Quaternion, origin?: Vector3): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: Vector3): void;
+    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;
+    };
+    abstract centerHandle?: Object3D & {
+        direction: Direction;
+    };
+    abstract xyPlane?: Object3D & {
+        direction: Direction;
+    };
+    abstract xzPlane?: Object3D & {
+        direction: Direction;
+    };
+    abstract yzPlane?: Object3D & {
+        direction: Direction;
+    };
+    abstract moveTips?: {
+        element: HTMLElement;
+        show: () => void;
+        hide: () => void;
+        setLeftTop: (left: string, top: string) => void;
+    };
+    abstract showDraggingHelper(directions?: Direction[]): void;
+    abstract update(camera: THREE.Camera): void;
+}
+export declare abstract class BoundingBoxHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+}
+export type Circle = (Mesh | Group) & {
+    direction: Direction;
+    circle: Mesh;
+    angleSector?: Mesh & {
+        angleDirection: number;
+        baseAxes: Vector3;
+    };
+};
+export declare abstract class RotateHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
+    abstract xCircle?: Circle;
+    abstract yCircle?: Circle;
+    abstract zCircle?: Circle;
+    abstract angleTips?: ReturnType<typeof tipsDom>;
+    abstract showDraggingHelper(directions: Direction[]): void;
+    abstract update(camera: THREE.Camera): void;
+}

package/plugins/Object3DHelperPlugin/Helper/BoundingBoxHelper.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from 'three';
+import { BoundingBoxHelperAbstract } from './BaseHelper';
+export declare class BoundingBoxHelper<T extends THREE.Object3D = THREE.Object3D> extends BoundingBoxHelperAbstract<T> {
+    name: string;
+    box: THREE.Mesh<THREE.BufferGeometry, THREE.MeshBasicMaterial>;
+    outline: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    private positionAttribute;
+    constructor(originObject: T);
+    initQuaternion(): void;
+    setHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    raycasterIntersectObject(raycaster: THREE.Raycaster, intersection: THREE.Intersection[]): THREE.Intersection[];
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+    update(): void;
+    private createOutline;
+    private createBox;
+}

package/plugins/Object3DHelperPlugin/Helper/MoveHelper.d.ts

@@ -0,0 +1,37 @@
+import type { Object3D } from 'three';
+import type { Direction } from '../typing';
+import { MoveHelperAbstract, type BaseHelperConfig } from './BaseHelper';
+import { ArrowGroup } from '../utils/ArrowGroup';
+import { CenterHandle } from '../utils/CenterHandle';
+import { PlaneHandle } from '../utils/PlaneHandle';
+import { Camera } from '@realsee/five';
+import { tipsDom } from '../utils/tipsDom';
+import * as THREE from 'three';
+export declare class MoveHelper extends MoveHelperAbstract {
+    name: string;
+    xArrow?: ArrowGroup;
+    yArrow?: ArrowGroup;
+    zArrow?: ArrowGroup;
+    centerHandle?: CenterHandle;
+    xyPlane?: PlaneHandle;
+    xzPlane?: PlaneHandle;
+    yzPlane?: PlaneHandle;
+    moveTips?: ReturnType<typeof tipsDom>;
+    private container?;
+    constructor(originObject3D: Object3D, config?: {
+        container?: HTMLElement;
+        xArrowEnable?: boolean;
+        yArrowEnable?: boolean;
+        zArrowEnable?: boolean;
+        centerHandleEnable?: boolean;
+        xyPlaneEnable?: boolean;
+        xzPlaneEnable?: boolean;
+        yzPlaneEnable?: boolean;
+        moveTipsEnable?: boolean;
+    } & BaseHelperConfig);
+    update(camera: Camera): void;
+    show(): void;
+    setScaleByCamera(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
+    showDraggingHelper(directions: Direction[]): void;
+    dispose(): void;
+}

package/plugins/Object3DHelperPlugin/Helper/RotateHelper.d.ts

@@ -0,0 +1,93 @@
+import * as THREE from 'three';
+import type { Object3D } from 'three';
+import { RotateHelperAbstract, type BaseHelperConfig } from './BaseHelper';
+import type { Color, Direction } from '../typing';
+import { tipsDom } from '../utils/tipsDom';
+export declare class RotateHelper extends RotateHelperAbstract {
+    name: string;
+    xCircle?: RotateCircleGroup;
+    yCircle?: RotateCircleGroup;
+    zCircle?: RotateCircleGroup;
+    children: RotateCircleGroup[];
+    angleTips?: ReturnType<typeof tipsDom>;
+    private container?;
+    constructor(originObject3D: Object3D, config?: {
+        container?: HTMLElement;
+        yzCircleEnable?: boolean;
+        xzCircleEnable?: boolean;
+        xyCircleEnable?: boolean;
+        angleTipsEnable?: boolean;
+    } & BaseHelperConfig);
+    hide(): void;
+    show(): void;
+    setScaleByCamera(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
+    update(camera: THREE.Camera): void;
+    showDraggingHelper(directions: Direction[]): void;
+    dispose(): void;
+}
+declare class RotateCircleGroup extends THREE.Group {
+    direction: Direction;
+    /** 1/4 圆 */
+    circle: Circle;
+    /** 旋转过程中展示的背景圆环 */
+    ring: DashedRing;
+    /** 旋转过程中表示角度的扇形 */
+    angleSector: AngleSector;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+    showCircle(): void;
+    showRing(): void;
+    hide(): void;
+}
+declare class Circle extends THREE.Mesh {
+    direction: Direction;
+    material: THREE.MeshBasicMaterial;
+    gapAngle: number;
+    geometry: THREE.RingGeometry;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+}
+declare class DashedRing extends THREE.Group {
+    direction: Readonly<Direction>;
+    constructor(options: {
+        direction: Direction;
+    });
+}
+declare class AngleSector extends THREE.Mesh {
+    direction: Direction;
+    baseAxes: THREE.Vector3;
+    offsetAngle: (angle: number) => number;
+    angleDirection: 1 | -1;
+    material: THREE.MeshBasicMaterial;
+    constructor(options: {
+        direction: Direction;
+        color?: Color;
+    });
+    /**
+     * 设置扇形旋转方向为顺时针
+     */
+    setClockwiseDirection(): void;
+    /**
+     * 设置扇形旋转方向为逆时针
+     */
+    setCounterClockwiseDirection(): void;
+    /**
+     * 切换扇形旋转方向
+     */
+    toggleDirection(): void;
+    /**
+     * 设置扇形的基础轴向
+     * @param axes 新的基础轴向向量
+     */
+    setBaseAxes(axes: THREE.Vector3): void;
+    /**
+     * 获取当前旋转方向
+     * @returns 'clockwise' | 'counterclockwise'
+     */
+    getDirection(): 'clockwise' | 'counterclockwise';
+}
+export {};

package/plugins/Object3DHelperPlugin/constant.d.ts

@@ -0,0 +1,27 @@
+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;
+}
+/**
+ * Object3DHelper 渲染顺序常量
+ * 数值越大，渲染优先级越高
+ */
+export declare const RENDER_ORDER: {
+    readonly ROTATE_HELPER: 9992;
+    readonly MOVE_HELPER: 9993;
+    readonly SCALE_HELPER_LINE: 9994;
+    readonly SCALE_HELPER_SPHERE: 9995;
+    readonly MOVE_HELPER_ARROW: 10001;
+    readonly MOVE_HELPER_CENTER: 10002;
+    readonly DRAG_GUIDE_LINE: 10003;
+    readonly DRAG_FACE_PATCH: 10004;
+};
+export type RenderOrderType = (typeof RENDER_ORDER)[keyof typeof RENDER_ORDER];
+export { AXES_COLOR, AXES_THREE_COLOR };

package/plugins/Object3DHelperPlugin/index.d.ts

@@ -0,0 +1,6 @@
+import * as Object3DHelperPluginType from './typing';
+import type { Five } from '@realsee/five';
+import { Controller } from './Controller';
+export declare const Object3DHelperPlugin: (five: Five) => Controller;
+export { Controller as Object3DHelperController };
+export type { Object3DHelperPluginType };

package/plugins/Object3DHelperPlugin/typing.d.ts

@@ -0,0 +1,143 @@
+import type * as THREE from 'three';
+import type { BaseHelper, MoveHelperAbstract, RotateHelperAbstract, Circle } from './Helper/BaseHelper';
+import type { MoveController, UseFaceNormalInterface } from './Controllers/MoveController';
+import type { Object3DHelper, AddObject3DHelperConfig } from './Controller';
+import type { BaseController } from './Controllers/BaseController';
+import type { RotateController } from './Controllers/RotateController';
+import type { BoundingBoxController } from './Controllers/BoundingBoxController';
+export interface Object3DHelperPluginState {
+    enabled: boolean;
+    visible: boolean;
+    disposed: boolean;
+}
+export type HelperConfig<T extends object = object> = boolean | ({
+    enable: boolean;
+} & T);
+export type Object3DHelperPluginEventMap = {
+    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: Object3DHelperPluginState;
+        prevState?: Object3DHelperPluginState;
+    }) => void;
+};
+export type Direction = 'x' | 'y' | 'z' | 'xy' | 'xz' | 'yz' | 'plane';
+export type Direction4 = 'nesw' | 'nwse' | 'ns' | 'ew';
+export interface Scissor {
+    left: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+export type HelperEventMap = {
+    wantToMove: (position: THREE.Vector3) => void;
+    moveBefore: (position: THREE.Vector3) => void;
+    wantToRotate: (quaternion: THREE.Quaternion) => void;
+    wantToScale: (scale: THREE.Vector3) => void;
+    move: (position: THREE.Vector3) => void;
+    rotate: (quaternion: THREE.Quaternion) => void;
+    scale: (scale: THREE.Vector3) => void;
+    moveStart: (direction?: Direction) => void;
+    rotateStart: (direction?: Direction) => void;
+    scaleStart: (direction?: Direction | Direction4) => void;
+    moveEnd: () => void;
+    rotateEnd: () => void;
+    scaleEnd: () => void;
+    moveByMouseEnable: () => void;
+    moveByMouseDisable: () => void;
+    updateOtherHelpers: (params: {
+        camera: THREE.Camera;
+    }) => void;
+};
+export type InternalHelperEventMap = {
+    initialHelperPosition: () => void;
+    setObjectPosition: (position: THREE.Vector3) => void;
+    setObjectRotate: (quaternion: THREE.Quaternion, origin?: THREE.Vector3) => void;
+    setObjectScale: (scale: THREE.Vector3) => void;
+    applyObjectPosition: (position: {
+        matrix: THREE.Matrix4;
+    }) => void;
+    applyObjectRotate: (rotate: {
+        quaternion: THREE.Quaternion;
+        origin: THREE.Vector3;
+    }) => void;
+    applyObjectScale: (scale: {
+        matrix: THREE.Matrix4;
+        origin?: THREE.Vector3;
+    }) => void;
+};
+export interface Object3DHelperState {
+    enabled: boolean;
+    visible: boolean;
+    disposed: boolean;
+}
+export type Object3DHelperEventMap = HelperEventMap & {
+    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;
+};
+export interface HelperOffset {
+    x: number | {
+        percents: number;
+    };
+    y: number | {
+        percents: number;
+    };
+    z: number | {
+        percents: number;
+    };
+}
+export type Color = THREE.Color | string | number;
+export type PositionFrom = 'objectPosition' | 'boundingBox' | 'boundingSphere' | THREE.Vector3 | ((object: THREE.Object3D) => THREE.Vector3);
+export interface ObjectHelperControllers {
+    moveController?: MoveController;
+    rotateController?: RotateController;
+    boundingBoxController?: BoundingBoxController;
+}
+export type ScaleCallback = (params: {
+    intersectPoint: THREE.Vector3;
+    scalePosition: ScalePosition;
+    offset: THREE.Vector3;
+}) => any;
+export type ScalePosition = {
+    id?: string;
+    handlePosition: THREE.Vector3;
+    basePosition: THREE.Vector3;
+};
+export interface Vector3Position {
+    x: number;
+    y: number;
+    z: number;
+}
+export type Vector3WithArray = [number, number, number];
+export interface Vector2Position {
+    x: number;
+    y: number;
+}
+export type Vector2WithArray = [number, number];
+export type { BaseController, BoundingBoxController, MoveController, UseFaceNormalInterface, RotateController, MoveHelperAbstract, RotateHelperAbstract, Circle, BaseHelper, Object3DHelper, AddObject3DHelperConfig, };

package/plugins/Object3DHelperPlugin/utils/ArrowGroup.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from 'three';
+import type { Direction } from '../typing';
+import { DirectionGroup, DirectionMesh } from './direction';
+interface InstanceParameter {
+    direction: Direction;
+    color?: THREE.Color | string | number;
+}
+/**
+ * 箭头组：正方向有线段+箭头，反方向有箭头
+ * 参考 three.js TransformControls 的 gizmoTranslate
+ */
+export declare class ArrowGroup extends DirectionGroup {
+    line: DirectionMesh<THREE.Geometry, THREE.MeshBasicMaterial>;
+    arrow: DirectionMesh<THREE.ConeGeometry, THREE.MeshBasicMaterial>;
+    arrowNeg: DirectionMesh<THREE.ConeGeometry, THREE.MeshBasicMaterial>;
+    private lineHeight;
+    private arrowHeight;
+    name: string;
+    constructor(param: InstanceParameter);
+    private formatGeometries;
+}
+export {};

package/plugins/Object3DHelperPlugin/utils/CenterHandle.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import type { Direction } from '../typing';
+import { DirectionGroup } from '../utils/direction';
+interface InstanceParameter {
+    color?: THREE.Color | string | number;
+    size?: number;
+}
+export declare class CenterHandle extends DirectionGroup {
+    cube: THREE.Mesh<THREE.BoxGeometry, THREE.MeshBasicMaterial[]> & {
+        direction: Direction;
+    };
+    name: string;
+    private faceMaterials;
+    private baseColor;
+    private faceNormals;
+    constructor(param?: InstanceParameter);
+    /**
+     * 更新各个面的颜色，根据与相机的角度动态调整
+     * @param camera 相机对象
+     */
+    update(camera: THREE.Camera): void;
+}
+export {};

package/plugins/Object3DHelperPlugin/utils/PlaneHandle.d.ts

@@ -0,0 +1,19 @@
+import * as THREE from 'three';
+import type { Direction } from '../typing';
+import { DirectionGroup } from './direction';
+interface PlaneHandleParams {
+    direction: Direction;
+    color?: THREE.Color | string | number;
+    size?: number;
+    offset?: number;
+}
+/**
+ * 平面移动手柄，参考 three.js TransformControls 的 XY/XZ/YZ 平面手柄
+ * 一个小的半透明方块，位于两个轴的交汇处
+ */
+export declare class PlaneHandle extends DirectionGroup {
+    handle: THREE.Mesh<THREE.BoxGeometry, THREE.MeshBasicMaterial>;
+    name: string;
+    constructor(params: PlaneHandleParams);
+}
+export {};

package/plugins/Object3DHelperPlugin/utils/calculateScaleByCamera.d.ts

@@ -0,0 +1,5 @@
+import type * as THREE from 'three';
+export default function calculateScaleByCamera(camera: any, position: THREE.Vector3, limit?: {
+    min?: number;
+    max?: number;
+}): number;

package/plugins/Object3DHelperPlugin/utils/cameraHooks.d.ts

@@ -0,0 +1,2 @@
+export declare function cameraHooks(camera: THREE.Camera): any;
+export declare function disposeCameraHooks(camera: THREE.Camera): void;

package/plugins/Object3DHelperPlugin/utils/direction.d.ts

@@ -0,0 +1,14 @@
+import type { Direction } from '../typing';
+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/plugins/Object3DHelperPlugin/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 | undefined;

package/plugins/Object3DHelperPlugin/utils/getOrthographicCameraDirection.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+/**
+ * @description 获取正交相机的方向
+ */
+export declare function getOrthographicCameraDirection(pose: {
+    longitude: number;
+    latitude: number;
+}): THREE.Vector3;