@realsee/dnalogel 3.20.7 → 3.21.1

package/README.md

@@ -2,6 +2,7 @@
  <a href="https://realsee.js.org/"><img src="https://vrlab-public.ljcdn.com/common/file/web/ea031fa5-ad82-46b3-86c8-7b20ec1e635a.jpg" width="60" /></a>
 </p>
 
+
 <p align="center">
   <a href="https://www.npmjs.com/package/@realsee/dnalogel">
     <img src="https://img.shields.io/npm/v/@realsee/dnalogel.svg" alt="npm version" >

package/dist/Object3DHelperPlugin/Controller.d.ts

@@ -2,9 +2,32 @@ import type { Five } from '@realsee/five';
 import * as BasePlugin from '../base/BasePlugin';
 import type * as THREE from 'three';
 import { Object3DHelper } from '../shared-utils/Object3DHelper/index';
-import type { Object3DHelperState, ObjectHelperControllers } from '../shared-utils/Object3DHelper/typings';
+import type { Object3DHelperState, ObjectHelperControllers, PositionFrom, ScaleCallback, ScalePosition } from '../shared-utils/Object3DHelper/typings';
 import type { HelperConfig, HelperOffset, Object3DHelperPluginEventMap, Object3DHelperPluginState } from './typings';
 export declare const PLUGIN = "Object3DHelperPlugin";
+export type AddObject3DHelperConfig = {
+    positionFrom?: PositionFrom;
+    offset?: HelperOffset;
+    yAxis?: THREE.Vector3;
+    xAxis?: THREE.Vector3;
+    zAxis?: THREE.Vector3;
+    moveHelper?: HelperConfig<{
+        xArrowEnable?: boolean;
+        yArrowEnable?: boolean;
+        zArrowEnable?: boolean;
+    }>;
+    rotateHelper?: HelperConfig<{
+        yzCircleEnable?: boolean;
+        xzCircleEnable?: boolean;
+        xyCircleEnable?: boolean;
+        angleTipsEnable?: boolean;
+    }>;
+    scaleHelper?: HelperConfig<{
+        positions?: Array<ScalePosition> | (() => Array<ScalePosition>);
+        scaleCallback?: ScaleCallback;
+    }>;
+    boundingBoxHelper?: HelperConfig;
+};
 export declare class Object3DHelperController extends BasePlugin.Controller<Object3DHelperPluginState, Object3DHelperPluginEventMap> {
     name: string;
     state: Object3DHelperState;
@@ -57,23 +80,7 @@ export declare class Object3DHelperController extends BasePlugin.Controller<Obje
      * @param { boolean } config.rotateHelper   旋转helper
      * @param { boolean } config.scaleHelper    缩放helper
      */
-    addObject3DHelper(object3D: THREE.Object3D, config?: {
-        moveHelper?: HelperConfig<{
-            offset?: HelperOffset;
-            xArrowEnable?: boolean;
-            yArrowEnable?: boolean;
-            zArrowEnable?: boolean;
-        }>;
-        rotateHelper?: HelperConfig<{
-            offset?: HelperOffset;
-            yzCircleEnable?: boolean;
-            xzCircleEnable?: boolean;
-            xyCircleEnable?: boolean;
-            angleTipsEnable?: boolean;
-        }>;
-        scaleHelper?: HelperConfig;
-        boundingBoxHelper?: HelperConfig;
-    }): ObjectHelperControllers | undefined;
+    addObject3DHelper(object3D: THREE.Object3D, paramsConfig?: AddObject3DHelperConfig): ObjectHelperControllers | undefined;
     removeObject3DHelper(object3D: THREE.Object3D): void;
     private handleEnable;
     private handleVisible;

package/dist/Object3DHelperPlugin/FiveControllerWrapper.d.ts

@@ -9,6 +9,7 @@ declare class ControllerWrapper<HelperControllerInterface extends new (...params
     private five;
     constructor(five: Five, HelperController: HelperControllerInterface, object: THREE.Object3D, helperObject3D: InstanceType<HelperControllerInterface>['helperObject3D'], HelperControllerConfig?: ConstructorParameters<HelperControllerInterface>[1], hooks?: Subscribe<any>, internalHooks?: Subscribe<any>);
     dispose(): void;
+    private onFiveWantsUpdateCameraDistance;
     private onFiveWantsTapGesture;
     private onFiveWantsGesture;
     private onFiveIntersectionOnModelUpdate;

package/dist/PanoMeasurePlugin/Modules/Magnifier.d.ts

@@ -1,11 +1,5 @@
-import type { Five } from '@realsee/five';
-import Hammer from 'hammerjs';
-import * as THREE from 'three';
-import { Subscribe, type SubscribeEventMap } from '@realsee/five';
-interface MagnifierEvent extends SubscribeEventMap {
-    wantsPanGesture: (event: (typeof Hammer)['Input']) => boolean;
-}
-/** 放大镜配置参数 */
+import { Magnifier } from '../../shared-utils';
+export default Magnifier;
 export interface MagnifierParameter {
     width?: number;
     height?: number;
@@ -23,50 +17,3 @@ export interface MagnifierParameter {
 export interface MagnifierState {
     enabled: boolean;
 }
-export default class Magnifier {
-    width: number;
-    height: number;
-    containerDom?: Element;
-    hooks: Subscribe<MagnifierEvent>;
-    canvas: HTMLCanvasElement;
-    private five;
-    private scale;
-    private config;
-    private offset;
-    private context;
-    private renderCenter;
-    private hammer?;
-    private state;
-    private offsetRange?;
-    private isPanning;
-    constructor(five: Five, options: MagnifierParameter);
-    dispose(): void;
-    enable(): this;
-    disable(): this;
-    /** 把放大镜放到某一个容器中 */
-    appendTo(element: Element): this;
-    /** 清除放大镜渲染内容 */
-    clear(): this;
-    /** 放大传入点位周围的内容 */
-    renderWithPoint(point: THREE.Vector3): void;
-    /** 放大传入点位周围的内容 */
-    renderWithScreenPoint(point: {
-        x: number;
-        y: number;
-    }): void;
-    resetOffset(): void;
-    getCurrentState(): MagnifierState;
-    protected getRenderCenter(): THREE.Vector3 | {
-        x: number;
-        y: number;
-    };
-    private _appendTo;
-    private autoFixPCPosition;
-    private render;
-    private initStyle;
-    private getPanOffset;
-    private onPanstart;
-    private onPan;
-    private onPanend;
-}
-export {};

package/dist/Sculpt/Meshes/Area.d.ts

@@ -0,0 +1,30 @@
+import type { LineStyle } from '../utils/color';
+import { type AnyPositions } from '../../shared-utils/positionToVector3';
+import { PolylineWithDotsMesh } from './Polyline';
+import * as THREE from 'three';
+import PolygonMesh from './Polygon';
+import type { PointsData } from '../utils/data';
+import type { ColoredMeshStyle } from '../utils/three/ColoredMesh';
+export type AreaStyle = ColoredMeshStyle & LineStyle;
+export type AreaData = PointsData;
+export declare class AreaMesh extends PolylineWithDotsMesh {
+    name: string;
+    polygon: PolygonMesh;
+    get color(): THREE.Color;
+    get opacity(): number;
+    /** 多边形前三个点组成的平面，用来使得后面加的点也落在这个平面上 */
+    private planeHelper;
+    private planeHelperNeedUpdate;
+    constructor(params?: Partial<AreaStyle & AreaData>);
+    setStyle(params: Partial<AreaStyle>): void;
+    setPoints(points: AnyPositions, autoClosed?: boolean): void;
+    getGeometryInfo(): {
+        center: THREE.Vector3;
+        area: number;
+    };
+    /**
+     * @description: 获取一个点投影在当前平面上的点
+     */
+    projectPoint(point: THREE.Vector3): THREE.Vector3;
+    private updatePlaneHelper;
+}

package/dist/Sculpt/Meshes/Box.d.ts

@@ -0,0 +1,35 @@
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import { type AnyPositions, type AnyPosition } from '../../shared-utils/positionToVector3';
+import type * as THREE from 'three';
+import type { LineStyle } from '../utils/color';
+import { RectangleWithEdgeMesh } from './RectangleWithEdge';
+import { RectangleMesh } from './Rectangle';
+import type { PointsData } from '../utils/data';
+import type { ColoredMeshStyle } from '../utils/three/ColoredMesh';
+export type BoxStyle = ColoredMeshStyle & LineStyle;
+export type BoxData = PointsData & {
+    heightPoint: AnyPosition;
+};
+/**
+ * @description: Box
+ */
+export declare class BoxMesh extends IObject3D {
+    name: string;
+    get planes(): RectangleMesh[];
+    bottomPlane: RectangleWithEdgeMesh;
+    topPlane: RectangleWithEdgeMesh;
+    heightPoint: THREE.Vector3;
+    protected edgePlanes: RectangleWithEdgeMesh[];
+    get color(): THREE.Color;
+    get lineColor(): THREE.Color;
+    get lineWidth(): number;
+    get occlusionVisibility(): boolean;
+    constructor(params?: Partial<BoxStyle & BoxData>);
+    setPoints(params: Partial<BoxData>): void;
+    setBottomPoints(points: AnyPositions): void;
+    setTopHeightPoint(point: AnyPosition): void;
+    setEdgePlanes(): void;
+    setStyle(style: Partial<BoxStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}

package/dist/Sculpt/Meshes/Circle.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+import { type OcclusionStyle } from '../utils/color';
+import ColoredMesh, { type ColoredMeshStyle } from '../utils/three/ColoredMesh';
+import { type AnyPosition } from '../../shared-utils/positionToVector3';
+export type CircleStyle = ColoredMeshStyle & OcclusionStyle;
+export type CircleData = {
+    center: AnyPosition;
+    normal: AnyPosition;
+    radius: number;
+};
+type Params = Partial<CircleStyle & CircleData>;
+export declare class CircleMesh extends ColoredMesh {
+    get center(): THREE.Vector3;
+    get normal(): THREE.Vector3;
+    private set normal(value);
+    get radius(): number;
+    meshFont: THREE.Mesh<THREE.CircleGeometry, THREE.MeshBasicMaterial>;
+    private _normal;
+    private opacityBeforeHighlight;
+    private highlighted;
+    constructor(params?: Params);
+    setPoints(params: CircleData): void;
+    highlight(): void;
+    unhighlight(): void;
+}
+export {};

package/dist/Sculpt/Meshes/CircleWithEdge.d.ts

@@ -0,0 +1,11 @@
+import type { LineStyle } from '../utils/color';
+import { CircleMesh, type CircleData, type CircleStyle } from './Circle';
+export type CircleWithEdgeMeshStyle = CircleStyle & LineStyle;
+export declare class CircleWithEdgeMesh extends CircleMesh {
+    private edgeLine;
+    constructor(params?: Partial<CircleWithEdgeMeshStyle & CircleData>);
+    setPoints(...params: Parameters<InstanceType<typeof CircleMesh>['setPoints']>): void;
+    setStyle(style: Partial<CircleWithEdgeMeshStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}

package/dist/Sculpt/Meshes/Cylinder.d.ts

@@ -0,0 +1,34 @@
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import * as THREE from 'three';
+import { CircleWithEdgeMesh, type CircleWithEdgeMeshStyle } from './CircleWithEdge';
+import ColoredMesh from '../utils/three/ColoredMesh';
+import { type AnyPosition } from '../../shared-utils/positionToVector3';
+export type CylinderStyle = CircleWithEdgeMeshStyle;
+export interface CylinderData {
+    bottomCenter: AnyPosition;
+    topCenter: AnyPosition;
+    radius: number;
+}
+type Params = Partial<CylinderStyle & CylinderData>;
+export declare class CylinderMesh extends IObject3D {
+    get bottomCenter(): THREE.Vector3;
+    get topCenter(): THREE.Vector3;
+    get normal(): THREE.Vector3;
+    get radius(): number;
+    get color(): THREE.Color;
+    bottomCircle: CircleWithEdgeMesh;
+    topCircle: CircleWithEdgeMesh;
+    protected edgeMesh: ColoredMesh;
+    private opacityBeforeHighlight;
+    private highlighted;
+    private params;
+    constructor(params?: Params);
+    setPoints(params: CylinderData): void;
+    setTopCenter(center: THREE.Vector3): void;
+    setBottomCenter(center: THREE.Vector3): void;
+    setStyle(style: CylinderStyle): void;
+    highlight(): void;
+    unhighlight(): void;
+    private setEdgeMesh;
+}
+export {};

package/dist/Sculpt/Meshes/Line.d.ts

@@ -0,0 +1,27 @@
+import * as THREE from 'three';
+import { type OcclusionStyle, type LineStyle } from '../utils/color';
+import { type AnyPositions } from '../../shared-utils/positionToVector3';
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import type { PointsData } from '../utils/data';
+export type LineMeshStyle = LineStyle & {
+    dashed?: boolean;
+} & OcclusionStyle;
+export type LineData = PointsData;
+export declare class LineMesh extends IObject3D {
+    name: string;
+    points: THREE.Vector3[];
+    get lineWidth(): number;
+    get color(): THREE.Color;
+    get dashed(): boolean;
+    get occlusionVisibility(): boolean;
+    protected highlighted: boolean;
+    private line;
+    private backLine;
+    private opacityBeforeHighlight;
+    constructor(params?: Partial<LineMeshStyle & LineData>);
+    setPoints(points: AnyPositions): void;
+    setResolution(width: number, height: number): void;
+    setStyle(params: Partial<LineMeshStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}

package/dist/Sculpt/Meshes/LineWithDots.d.ts

@@ -0,0 +1,30 @@
+import { type AnyPositions } from '../../shared-utils/positionToVector3';
+import { PointMesh } from './Point';
+import { LineMesh, type LineMeshStyle } from './Line';
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import type { PointsData } from '../utils/data';
+type Style = LineMeshStyle & {
+    pointVisibility?: boolean | {
+        startPoint?: boolean;
+        endPoint?: boolean;
+    };
+};
+/**
+ * Represents a mesh that consists of a line with dots at the start and end points.
+ */
+export declare class LineWithDotsMesh extends LineMesh {
+    name: string;
+    pointGroup: IObject3D;
+    style: Style;
+    get startPoint(): PointMesh;
+    get endPoint(): PointMesh;
+    get visiblePointMeshes(): PointMesh[];
+    get pointMeshes(): PointMesh[];
+    constructor(params?: Partial<Style & PointsData>);
+    setPoints(points: AnyPositions): void;
+    setStyle: (style: Partial<Style>) => void;
+    highlight: () => void;
+    unhighlight: () => void;
+    private updateEdgePointsVisibility;
+}
+export {};

package/dist/Sculpt/Meshes/Point.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from 'three';
+import { type ColorStyle, type OcclusionStyle } from '../utils/color';
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import type { PointData } from '../utils/data';
+export type { PointData } from '../utils/data';
+export declare const circleImageURL: string;
+export type PointStyle = ColorStyle & {
+    size: number;
+} & OcclusionStyle;
+export declare class PointMesh extends IObject3D {
+    name: string;
+    get color(): THREE.Color;
+    get size(): number;
+    private opacityBeforeHighlight;
+    private highlighted;
+    private fontMesh;
+    private backgroundMesh;
+    constructor(params?: Partial<PointStyle & PointData>);
+    setStyle(params: Partial<PointStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}

package/dist/Sculpt/Meshes/Polygon.d.ts

@@ -0,0 +1,31 @@
+import * as THREE from 'three';
+import { type AnyPositions } from '../../shared-utils/positionToVector3';
+import ColoredMesh, { type ColoredMeshStyle } from '../utils/three/ColoredMesh';
+import type { PointsData } from '../utils/data';
+export declare const blankGeometry: THREE.BufferGeometry & {
+    isBlank: true;
+};
+export type PolygonStyle = ColoredMeshStyle;
+export type PolygonData = PointsData;
+export default class PolygonMesh extends ColoredMesh<THREE.BufferGeometry> {
+    name: string;
+    get isBlank(): boolean;
+    points: THREE.Vector3[];
+    planeHelperNeedUpdate: boolean;
+    private planeHelper;
+    private opacityBeforeHighlight;
+    private highlighted;
+    constructor(params?: Partial<PolygonStyle & PolygonData>);
+    setPoints(points: AnyPositions): void;
+    getGeometryInfo(): {
+        center: THREE.Vector3;
+        area: number;
+    };
+    /**
+     * @description: 获取一个点投影在当前平面上的点
+     */
+    projectPoint(point: THREE.Vector3): THREE.Vector3;
+    highlight(): void;
+    unhighlight(): void;
+    private updatePlaneHelper;
+}

package/dist/Sculpt/Meshes/Polyline.d.ts

@@ -0,0 +1,34 @@
+import { type AnyPositions } from '../../shared-utils/positionToVector3';
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import { LineWithDotsMesh } from './LineWithDots';
+import { LineMesh, type LineMeshStyle } from './Line';
+import type { PointsData } from '../utils/data';
+import * as THREE from 'three';
+export type PolylineStyle = LineMeshStyle;
+export type PolylineData = PointsData;
+export declare abstract class PolylineBaseMesh<WithDots extends boolean = true> extends IObject3D {
+    name: string;
+    get lineColor(): THREE.Color;
+    get lineWidth(): number;
+    get dashed(): boolean;
+    get occlusionVisibility(): boolean;
+    get points(): THREE.Vector3[];
+    lines: Array<WithDots extends true ? LineWithDotsMesh : LineMesh>;
+    private withDots;
+    private paramsStyle;
+    constructor(params?: Partial<PolylineStyle & PolylineData & {
+        withDots: WithDots extends true ? true : false;
+    }>);
+    setPoints(points: AnyPositions): void;
+    setStyle(style: Partial<PolylineStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}
+export declare class PolylineMesh extends PolylineBaseMesh<false> {
+    name: string;
+    constructor(...params: ConstructorParameters<typeof PolylineBaseMesh>);
+}
+export declare class PolylineWithDotsMesh extends PolylineBaseMesh<true> {
+    name: string;
+    constructor(...params: ConstructorParameters<typeof PolylineBaseMesh>);
+}

package/dist/Sculpt/Meshes/Prism.d.ts

@@ -0,0 +1,31 @@
+import { IObject3D } from '../../shared-utils/three/IObject3D';
+import { type AnyPosition, type AnyPositions } from '../../shared-utils/positionToVector3';
+import { AreaMesh, type AreaData } from './Area';
+import * as THREE from 'three';
+import type { LineStyle } from '../utils/color';
+import type { ColoredMeshStyle } from '../utils/three/ColoredMesh';
+export type PrismStyle = ColoredMeshStyle & LineStyle;
+export interface PrismData extends AreaData {
+    heightPoint: AnyPosition;
+}
+/**
+ * @description: 多棱柱
+ */
+export declare class PrismMesh extends IObject3D {
+    name: string;
+    heightPoint: THREE.Vector3;
+    bottomPolygon: AreaMesh;
+    topPolygon: AreaMesh;
+    get color(): THREE.Color;
+    get lineWidth(): number;
+    get lineColor(): THREE.Color;
+    private edgePlanes;
+    constructor(params?: Partial<PrismData & PrismStyle>);
+    setStyle(params: Partial<PrismStyle>): void;
+    setPoints(params: Partial<PrismData>): void;
+    highlight(): void;
+    unhighlight(): void;
+    setBottomPoints(points: AnyPositions): void;
+    setTopHeightPoint(heightPoint: THREE.Vector3): void;
+    private setEdgePlanes;
+}

package/dist/Sculpt/Meshes/Rectangle.d.ts

@@ -0,0 +1,24 @@
+import { type AnyPositions } from '../../shared-utils/positionToVector3';
+import * as THREE from 'three';
+import PolygonMesh from './Polygon';
+import { RectangleGeometry } from '../utils/three/RectangleGeometry';
+import type { PointsData } from '../utils/data';
+import type { ColoredMeshStyle } from '../utils/three/ColoredMesh';
+export type RectangleStyle = ColoredMeshStyle;
+export type RectangleData = PointsData;
+/**
+ * @description: 矩形
+ */
+export declare class RectangleMesh extends PolygonMesh {
+    name: string;
+    meshFont: THREE.Mesh<RectangleGeometry, THREE.MeshBasicMaterial>;
+    meshBackground: THREE.Mesh<RectangleGeometry, THREE.MeshBasicMaterial>;
+    get color(): THREE.Color;
+    /**
+     * @description: 构造矩形所需的三个点
+     */
+    get builtPoints(): THREE.Vector3[];
+    get sortedPoint(): THREE.Vector3[];
+    constructor(params?: Partial<RectangleStyle & RectangleData>);
+    setPoints(points: AnyPositions): void;
+}

package/dist/Sculpt/Meshes/RectangleWithEdge.d.ts

@@ -0,0 +1,20 @@
+import type { AnyPositions } from '../../shared-utils/positionToVector3';
+import { RectangleMesh, type RectangleData, type RectangleStyle } from './Rectangle';
+import { PolylineMesh } from './Polyline';
+import type { LineStyle } from '../utils/color';
+import * as THREE from 'three';
+export type RectangleWithEdgeMeshStyle = RectangleStyle & LineStyle;
+/**
+ * @description: 带边线的矩形
+ */
+export declare class RectangleWithEdgeMesh extends RectangleMesh {
+    name: string;
+    get lineWidth(): number;
+    get lineColor(): THREE.Color;
+    protected line: PolylineMesh;
+    constructor(params?: Partial<RectangleWithEdgeMeshStyle & RectangleData>);
+    setPoints(points: AnyPositions): void;
+    setStyle(style: Partial<RectangleWithEdgeMeshStyle>): void;
+    highlight(): void;
+    unhighlight(): void;
+}

package/dist/Sculpt/Modules/Cursor.d.ts

@@ -0,0 +1,13 @@
+type CursorType = 'auto' | 'pen' | 'pen-forbidden' | 'pen-crosshair' | 'pne-polygon' | 'pen-circle' | 'crosshair-rectangle' | 'crosshair-circle';
+export declare class Cursor {
+    private container;
+    constructor(container: HTMLElement);
+    /**
+     * @param type - The type of the cursor.
+     */
+    setType(type: CursorType): void;
+    tip(tip: string): () => void;
+    closeTip(): void;
+    reset(): void;
+}
+export {};

package/dist/Sculpt/Modules/Global.d.ts

@@ -0,0 +1,20 @@
+import type { Five } from '@realsee/five';
+import { Cursor } from './Cursor';
+import { PointSelector } from '../../shared-utils/three/PointSelector';
+import { FiveDomEvents } from '../../shared-utils/five/FiveDomEvents';
+import { Object3DHelperController } from '../../Object3DHelperPlugin';
+declare class GlobalModules {
+    five: Five;
+    _cursor: Cursor;
+    _pointSelector: PointSelector;
+    _fiveDomEvents: FiveDomEvents;
+    _object3DHelper: Object3DHelperController;
+    inited: boolean;
+    get cursor(): Cursor;
+    get pointSelector(): PointSelector;
+    get fiveDomEvents(): FiveDomEvents;
+    get object3DHelper(): Object3DHelperController;
+    init: (five: Five) => void;
+}
+declare const globalModules: GlobalModules;
+export { globalModules };

package/dist/Sculpt/Objects/Base/Editor.d.ts

@@ -0,0 +1,21 @@
+import type * as THREE from 'three';
+import { IObject3D } from '../../../shared-utils/three/IObject3D';
+import type { AddObject3DHelperConfig } from '../../../Object3DHelperPlugin';
+export declare class BaseEditor<OriginObject extends THREE.Object3D = THREE.Object3D> extends IObject3D {
+    protected originObject: OriginObject;
+    constructor(originObject: OriginObject);
+    /**
+     * @description: 开启编辑器
+     */
+    enable(): void;
+    /**
+     * @description: 禁用编辑器
+     */
+    disable(): void;
+}
+export declare class BaseEditorWithObjectHelper<OriginObject extends THREE.Object3D = THREE.Object3D> extends BaseEditor<OriginObject> {
+    private objectHelperConfig;
+    constructor(originObject: OriginObject, objectHelperConfig?: AddObject3DHelperConfig | (() => AddObject3DHelperConfig));
+    enable(): void;
+    disable(): void;
+}

package/dist/Sculpt/Objects/Base/index.d.ts

@@ -0,0 +1,60 @@
+import type { FiveDomEventMap } from '../../../shared-utils/five/FiveDomEvents';
+import { IObject3D } from '../../../shared-utils/three/IObject3D';
+import type { BaseEditor } from './Editor';
+import type { RequiredDeep } from 'type-fest';
+import type * as THREE from 'three';
+export interface BaseImportData {
+    id?: string;
+    type: string;
+}
+export interface BaseExportData extends RequiredDeep<BaseImportData> {
+}
+export interface BaseObjectConfig {
+    /**
+     * @description: 是否可以编辑
+     * @default true
+     */
+    canEdit: boolean;
+    /**
+     * @description: 是否以一种半透明的方式显示遮挡的部分
+     * @default true
+     */
+    occlusionVisibility: boolean;
+}
+/**
+ * @description: 基础对象
+ */
+export declare abstract class BaseObject<ImportData extends BaseImportData = BaseImportData, ExportData extends BaseExportData = any, Config extends BaseObjectConfig = BaseObjectConfig> extends IObject3D {
+    name: string;
+    readonly isSculptObject = true;
+    draggable: boolean;
+    /**
+     * @description: 是否被选中
+     */
+    selected: boolean;
+    /**
+     * @description: 配置
+     */
+    config: Config;
+    protected editor: BaseEditor;
+    abstract type: string;
+    /**
+     * @description: 物体导出数据
+     */
+    abstract get data(): ExportData;
+    protected get baseData(): {
+        id: string;
+        type: string;
+    };
+    protected get pointSelector(): import("../../../shared-utils/three/PointSelector").PointSelector;
+    constructor(data?: Partial<ImportData>, config?: Partial<Config>);
+    on: <T extends keyof FiveDomEventMap>(event: T, callback: FiveDomEventMap[T]) => void;
+    off: (event: keyof FiveDomEventMap, callback: (e: import("../../../shared-utils/five/FiveDomEvents").FiveDomEvent) => any, ...args: any[]) => void;
+    stopCreating(): void;
+    delete(): void;
+    highlight(): void;
+    unhighlight(): void;
+    protected applyObjectMatrixWorld<P extends THREE.Vector3 | THREE.Vector3[]>(point: P): P;
+    protected applyObjectQuaternion<P extends THREE.Vector3 | THREE.Vector3[]>(point: P): P;
+    abstract create(...args: any): any;
+}

package/dist/Sculpt/Objects/Box/Editor.d.ts

@@ -0,0 +1,5 @@
+import type { Box } from '.';
+import { BaseEditorWithObjectHelper } from '../Base/Editor';
+export declare class BoxEditor extends BaseEditorWithObjectHelper<Box> {
+    constructor(originObject: Box);
+}