@realsee/five-webgpu 1.0.0-alpha.5 → 1.0.0-alpha.6

package/plugins/FloorplanPlugin/utils/formatPosition.d.ts

@@ -0,0 +1,33 @@
+import type { Five } from '@realsee/five-webgpu';
+import type { FloorplanBounding, FloorplanData, FloorplanPosition, FloorplanImagePosition } from '../typings';
+/**
+ * 拼接 SVG path 的 d 属性字符串
+ */
+export declare function pathD(points: FloorplanPosition[], options?: {
+    needZ?: boolean;
+    format?: (point: FloorplanPosition) => FloorplanPosition;
+}): string;
+/**
+ * 把户型图坐标系（原点在中心）的点转换到 SVG 坐标系（原点在左上角，y 轴向下）
+ */
+export declare function formatFloorplanPoint({ x, y }: FloorplanPosition, bounding: FloorplanBounding): FloorplanPosition;
+/**
+ * 三维模型坐标（米）转户型图坐标（毫米，原点在中心）
+ */
+export declare function modelPosition2FloorplanPosition(position: {
+    x: number;
+    y: number;
+    z: number;
+}, floorplanData: FloorplanData): FloorplanPosition;
+/**
+ * 户型图坐标转图片相对坐标 [0,1]
+ */
+export declare function floorplanPosition2ImagePosition(position: FloorplanPosition, floorplanData: FloorplanData): FloorplanImagePosition;
+/**
+ * 求三维世界坐标点所在的楼层
+ */
+export declare function getFloorIndexFromModelPosition(position: {
+    x: number;
+    y: number;
+    z: number;
+}, five: Five): number;

package/plugins/FloorplanPlugin/utils/getDistanceFromModel.d.ts

@@ -0,0 +1,6 @@
+import type { Five } from '@realsee/five-webgpu';
+/**
+ * 根据模型整体包围盒和目标 fov/aspect，反算相机取景合适的距离
+ * @description 与 five 内部 FloorplanController.distanceFromModel 等价（该方法未对外导出，故在插件内重新实现）
+ */
+export declare function getDistanceFromModel(five: Five, fov: number, aspect: number): number;

package/plugins/FloorplanPlugin/utils/getPxmm.d.ts

@@ -0,0 +1,19 @@
+import type { Five } from '@realsee/five-webgpu';
+import { FLOOR_PLAN_ATTACHED_TO } from '../typing';
+export interface GetPxmmOption {
+    attachedTo?: FLOOR_PLAN_ATTACHED_TO;
+}
+/**
+ * 取指定楼层的地面高度（该楼层所有点位站立位置 y 的最大值）
+ * @description 若 floorIndex 超过实际最大楼层（比如查询顶层的天花板），退化为取整模型包围盒顶部
+ */
+export declare function getFloorY(five: Five, floorIndex: number): number;
+/**
+ * 根据吸附方式获取户型图应当吸附的世界坐标高度（y）
+ */
+export declare function getAttachedY(five: Five, floorIndex: number, attachedTo?: FLOOR_PLAN_ATTACHED_TO): number;
+/**
+ * 计算「每毫米对应多少像素」（用于把 3D 世界的毫米尺寸换算为户型图 DOM 的像素尺寸）
+ * @description 在吸附高度上取原点与 x 方向单位点，分别投影到屏幕 NDC 坐标，用横向偏移量换算比例
+ */
+export declare function getPxmm(five: Five, container: Element, floorIndex: number, options?: GetPxmmOption): number;

package/plugins/FloorplanPlugin/utils/isTruelyObject.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 判断是否是「纯对象」（排除数组、null、Map、Set 等）
+ */
+export declare function isTruelyObject(value: unknown): value is Record<string, unknown>;

package/plugins/FloorplanPlugin/utils/nearlyEqual.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 判断两个数字四舍五入到 precision 位小数后是否相等
+ */
+export declare function nearlyEqual(x: number, y: number, precision?: number): boolean;
+/**
+ * 判断两个弧度值是否近似相等，处理 0 / 2π 边界（角度环绕）
+ */
+export declare function nearlyEqualRad(x: number, y: number, precision?: number): boolean;

package/plugins/FloorplanPlugin/utils/to.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Go 风格的错误处理封装：`const [err, data] = await to(promise)`
+ */
+export declare function to<T>(promise: Promise<T>): Promise<[null, T] | [Error, null]>;
+export default to;

package/plugins/Object3DHelperPlugin/Controller.d.ts

@@ -0,0 +1,99 @@
+import type { Five } from '@realsee/five-webgpu';
+import { BasePlugin } from '../BasePlugin';
+import * as THREE from 'three/webgpu';
+import type { Object3DHelperEventMap, Object3DHelperState, ObjectHelperControllers, PositionFrom } from './typing';
+import type { HelperConfig, HelperOffset, Object3DHelperPluginEventMap, Object3DHelperPluginState } from './typing';
+import { Subscribe } from '@realsee/five-webgpu';
+export declare const PLUGIN = "Object3DHelperPlugin";
+export type AddObject3DHelperConfig = {
+    positionFrom?: PositionFrom;
+    offset?: HelperOffset;
+    /** Helpers 的世界坐标偏移量 */
+    helperOffset?: THREE.Vector3;
+    yAxis?: THREE.Vector3 | (() => THREE.Vector3);
+    xAxis?: THREE.Vector3 | (() => THREE.Vector3);
+    zAxis?: THREE.Vector3 | (() => THREE.Vector3);
+    moveHelper?: HelperConfig<{
+        xArrowEnable?: boolean;
+        yArrowEnable?: boolean;
+        zArrowEnable?: boolean;
+    }>;
+    /** 是否展示 MoveHelper 拖拽时的坐标提示，默认 false */
+    moveHelperTips?: boolean;
+    rotateHelper?: HelperConfig<{
+        yzCircleEnable?: boolean;
+        xzCircleEnable?: boolean;
+        xyCircleEnable?: boolean;
+        angleTipsEnable?: boolean;
+    }>;
+    boundingBoxHelper?: HelperConfig;
+};
+export declare class Object3DHelper {
+    controllers: ObjectHelperControllers;
+    state: Object3DHelperState;
+    hooks: Subscribe<Object3DHelperEventMap>;
+    constructor(controllers?: ObjectHelperControllers);
+    show(options?: {
+        userAction?: boolean;
+    }): void;
+    hide(options?: {
+        userAction?: boolean;
+    }): void;
+    enable(options?: {
+        userAction?: boolean;
+    }): void;
+    disable(options?: {
+        userAction?: boolean;
+    }): void;
+    dispose(): void;
+    setState(state: Partial<Object3DHelperState>, _options?: {
+        userAction?: boolean;
+    }): void;
+    addControllers(controllers: ObjectHelperControllers): void;
+    initialHelperMatrix(): void;
+    private handleEnable;
+    private handleVisible;
+    private handleDispose;
+    private everyControllerDo;
+}
+export declare class Controller extends BasePlugin.Controller<Object3DHelperPluginState, Object3DHelperPluginEventMap & BasePlugin.EventMap<Object3DHelperPluginState, any>, any, any> {
+    name: string;
+    data?: any;
+    state: Object3DHelperState;
+    objectHelperMap: Map<THREE.Object3D, {
+        helper: Object3DHelper;
+        disposers: (() => any)[];
+        helperGroup: THREE.Group;
+    }>;
+    constructor(five: Five);
+    show(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    hide(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    enable(options?: {
+        userAction?: boolean;
+    }): void;
+    disable(options?: {
+        userAction?: boolean;
+    }): void;
+    dispose(): void;
+    load(_data: any): Promise<void>;
+    setState(state: Partial<Object3DHelperState>, options?: {
+        userAction?: boolean;
+    } & Record<string, any>): void;
+    getObject3DHelper(object3D: THREE.Object3D): {
+        helper: Object3DHelper;
+        disposers: (() => any)[];
+        helperGroup: THREE.Group;
+    } | undefined;
+    addObject3DHelper(object3D: THREE.Object3D, paramsConfig?: AddObject3DHelperConfig): ObjectHelperControllers | undefined;
+    removeObject3DHelper(object3D: THREE.Object3D): void;
+    private handleEnable;
+    private handleVisible;
+    private handleDispose;
+    private everyHelperDo;
+    private actionIfStateIsEnabled;
+    private getConfig;
+}

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

@@ -0,0 +1,142 @@
+import * as THREE from 'three/webgpu';
+import { Subscribe } from '@realsee/five-webgpu';
+import type { SolidGuideOptions } from '../utils/solidGuide';
+import type { HelperEventMap, HelperOffset, InternalHelperEventMap, ScaleCallback } from '../typing';
+import type { BaseHelper } from '../Helper/BaseHelper';
+import DomEvents from '../../thirdParty/domevents';
+export declare let originOpacity: {
+    opacity: number;
+} | null;
+type Config = {
+    offset?: HelperOffset;
+    yAxis?: THREE.Vector3 | (() => THREE.Vector3);
+    xAxis?: THREE.Vector3 | (() => THREE.Vector3);
+    zAxis?: THREE.Vector3 | (() => THREE.Vector3);
+    scaleCallback?: ScaleCallback;
+    /** 实线样式与行为配置（透传给 SolidGuideLine） */
+    solidGuide?: SolidGuideOptions;
+};
+export declare abstract class BaseController<T extends BaseHelper = BaseHelper, K extends THREE.Object3D = THREE.Object3D> {
+    originObject3D: K;
+    hooks: Subscribe<HelperEventMap>;
+    preventTapDefaultEvent: boolean;
+    protected internalHooks: Subscribe<InternalHelperEventMap>;
+    protected readonly disposers: (() => void)[];
+    protected helperObject3D: T;
+    protected camera: THREE.Camera;
+    protected model: THREE.Object3D;
+    protected scene: THREE.Object3D;
+    protected container: HTMLElement;
+    protected domEvents: DomEvents;
+    protected isDragging: boolean;
+    protected enabled: boolean;
+    protected name: string;
+    protected boundingBox?: THREE.Box3;
+    protected config: Config;
+    private onRender;
+    protected cameraHooks: Subscribe<{
+        cameraUpdate: () => any;
+    }>;
+    /** 其他控制器的引用，用于跨控制器状态检查 */
+    protected otherControllers?: {
+        moveController?: BaseController;
+        rotateController?: BaseController;
+        scaleController?: BaseController;
+    };
+    /**
+     * 更新其他控制器的引用
+     */
+    updateOtherControllers(otherControllers: {
+        moveController?: BaseController;
+        rotateController?: BaseController;
+        scaleController?: BaseController;
+    }): void;
+    /**
+     * 获取当前控制器的拖拽状态
+     */
+    getIsDragging(): boolean;
+    constructor(params: {
+        camera: THREE.Camera;
+        model: THREE.Object3D;
+        originObject3D: K;
+        helperObject3D: T;
+        container: HTMLElement;
+        domEvents: DomEvents;
+        scene: THREE.Object3D;
+        onRender?: () => void;
+        sharedHooks?: Subscribe<HelperEventMap>;
+        sharedInternalHooks?: Subscribe<InternalHelperEventMap>;
+        /** 其他控制器的引用，用于跨控制器状态检查 */
+        otherControllers?: {
+            moveController?: BaseController;
+            rotateController?: BaseController;
+            scaleController?: BaseController;
+        };
+    }, config?: Config);
+    initialHelperPosition(): void;
+    initialHelperQuaternion(): void;
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    /**
+     * @description: applyHelperMatrix4
+     * @param {THREE.Matrix4} matrix position 偏移量
+     */
+    applyHelperMatrix4(matrix: THREE.Matrix4): void;
+    /**
+     * @description: applyHelperQuaternion
+     * @param {THREE.Quaternion} quaternion 旋转四元数
+     * @param {THREE.Vector3} origin 旋转中心
+     */
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    /**
+     * @description: applyHelperScaleMatrix4
+     * @param {THREE.Matrix4} matrix 缩放矩阵
+     * @param {THREE.Vector3} origin 缩放中心
+     */
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, origin?: THREE.Vector3): void;
+    onWantsTapGesture: (raycaster: THREE.Raycaster) => false | void;
+    updateHelperScale: () => void;
+    onWantsGesture(type: 'press' | 'pan' | string, pointers: {
+        x: number;
+        y: number;
+    }[], final: boolean): false | void;
+    onIntersectionOnModelUpdate(intersection: THREE.Intersection): void;
+    /**
+     * @description: onApplyOriginObjectScale
+     * @param {THREE.Matrix4} params.matrix 缩放矩阵
+     * @param {THREE.Vector3} params.origin 缩放中心
+     */
+    protected onApplyOriginObjectScale(params: {
+        matrix: THREE.Matrix4;
+        origin?: THREE.Vector3;
+    }): void;
+    /**
+     * @description: onApplyOriginObjectRotate
+     * @param {THREE.Quaternion} params.quaternion 旋转四元数
+     * @param {THREE.Vector3} params.origin 旋转中心
+     */
+    protected onApplyOriginObjectRotate(params: {
+        quaternion: THREE.Quaternion;
+        origin: THREE.Vector3;
+    }): void;
+    /**
+     * @description: onApplyOriginObjectPosition
+     * @param {THREE.Matrix4} params.matrix position 偏移量
+     */
+    protected onApplyOriginObjectPosition(params: {
+        matrix: THREE.Matrix4;
+    }): void;
+    protected onSetOriginObjectScale(scale: THREE.Vector3): void;
+    protected onSetOriginObjectRotate(_quaternion: THREE.Quaternion, _origin?: THREE.Vector3): void;
+    protected onSetOriginObjectPosition(position: THREE.Vector3): void;
+    protected render(): void;
+    protected updateOffsetByScale(scale: THREE.Vector3): void;
+    protected hoverListener(object3D: THREE.Object3D | undefined | THREE.Group | (THREE.Object3D | undefined | THREE.Group)[], hoverColor?: THREE.Color | string | number, hoverOpacity?: number): () => void;
+    private getIntersectObject;
+    private getBox;
+    private calculateOffset;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { BaseController } from './BaseController';
+import type { BoundingBoxHelperAbstract } from '../Helper/BaseHelper';
+import * as THREE from 'three/webgpu';
+export declare class BoundingBoxController<OriginObject3D extends THREE.Object3D = THREE.Object3D> extends BaseController<BoundingBoxHelperAbstract<OriginObject3D>> {
+    protected name: string;
+    constructor(...params: ConstructorParameters<typeof BaseController<BoundingBoxHelperAbstract<OriginObject3D>>>);
+    protected onApplyOriginObjectRotate(params: {
+        quaternion: THREE.Quaternion;
+        origin: THREE.Vector3;
+    }): void;
+    protected onSetOriginObjectRotate(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    /**
+     * 直接从 object 同步 position 和 quaternion，消除累积误差
+     */
+    private syncWithObject;
+}

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

@@ -0,0 +1,66 @@
+import { BaseController } from './BaseController';
+import * as THREE from 'three/webgpu';
+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/webgpu';
+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-webgpu';
+import type { BaseController } from './Controllers/BaseController';
+import type * as THREE from 'three/webgpu';
+import type { Subscribe } from '@realsee/five-webgpu';
+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/webgpu';
+import type { Group, Mesh, Object3D } from 'three/webgpu';
+import { Vector3 } from 'three/webgpu';
+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/webgpu';
+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/webgpu';
+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-webgpu';
+import { tipsDom } from '../utils/tipsDom';
+import * as THREE from 'three/webgpu';
+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;
+}