@realsee/dnalogel 3.20.6 → 3.21.0

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);
+}

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

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import { BoxMesh, type BoxData, type BoxStyle } from '../../Meshes/Box';
+import type { LiteralString } from '../../typings/utils.type';
+export interface BoxImportData extends BaseImportData, BoxData {
+    type: LiteralString<'Box'>;
+    style?: Partial<BoxStyle>;
+}
+export declare class Box extends BaseObject<BoxImportData> {
+    readonly type = "Box";
+    boxMesh: BoxMesh;
+    get data(): {
+        points: [number, number, number][];
+        heightPoint: [number, number, number];
+        style: {
+            color: number;
+            lineWidth: number;
+            lineColor: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: BoxImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<BoxStyle>): Promise<void>;
+}
+export declare function createBox(boxMesh: BoxMesh, pointSelector: PointSelector): Promise<void>;

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

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

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

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { CircleData, CircleMesh } from '../../Meshes/Circle';
+import { CircleWithEdgeMesh, type CircleWithEdgeMeshStyle } from '../../Meshes/CircleWithEdge';
+import type { LiteralString } from '../../typings/utils.type';
+export interface CircleImportData extends BaseImportData, CircleData {
+    type: LiteralString<'Circle'>;
+    style?: Partial<CircleWithEdgeMeshStyle>;
+}
+export declare class Circle extends BaseObject<CircleImportData> {
+    readonly type = "Circle";
+    circleMesh: CircleWithEdgeMesh;
+    get data(): {
+        center: [number, number, number];
+        normal: [number, number, number];
+        radius: number;
+        style: {
+            color: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: CircleImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<CircleWithEdgeMeshStyle>): Promise<void>;
+}
+export declare function createCircle(circleMesh: CircleMesh, pointSelector: PointSelector): Promise<void>;

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

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

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

@@ -0,0 +1,30 @@
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { CircleStyle } from '../../Meshes/Circle';
+import { CylinderMesh, type CylinderData } from '../../Meshes/Cylinder';
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { LiteralString } from '../../typings/utils.type';
+type CylinderStyle = CircleStyle;
+export interface CylinderImportData extends BaseImportData, CylinderData {
+    type: LiteralString<'Cylinder'>;
+    style?: Partial<CylinderStyle>;
+}
+export declare class Cylinder extends BaseObject<CylinderImportData> {
+    readonly type = "Cylinder";
+    cylinderMesh: CylinderMesh;
+    get data(): {
+        bottomCenter: [number, number, number];
+        topCenter: [number, number, number];
+        radius: number;
+        style: {
+            color: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: CylinderImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<CylinderStyle>): Promise<void>;
+}
+export declare function createCylinder(cylinderMesh: CylinderMesh, pointSelector: PointSelector): Promise<void>;
+export {};

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

@@ -0,0 +1,8 @@
+import { BaseEditor } from '../Base/Editor';
+import type { Point } from '.';
+export declare class PointEditor extends BaseEditor<Point> {
+    constructor(originObject: Point);
+    enable(): void;
+    disable(): void;
+    private onDrag;
+}

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

@@ -0,0 +1,35 @@
+import { PointMesh, type PointData, type PointStyle } from '../../Meshes/Point';
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { LiteralString } from '../../typings/utils.type';
+export interface PointImportData extends BaseImportData, PointData {
+    type: LiteralString<'Point'>;
+    style?: Partial<PointStyle>;
+}
+export declare class Point extends BaseObject<PointImportData> {
+    readonly type = "Point";
+    pointMesh: PointMesh;
+    get data(): {
+        point: [number, number, number];
+        style: {
+            color: number;
+            size: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: PointImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    /**
+     * @description: 设置颜色
+     * @param {Color} style.color
+     * @param {number} style.size
+     */
+    setStyle(style: Partial<PointStyle>): void;
+    /**
+     * @description: 创建点
+     */
+    create(params?: PointStyle): Promise<void>;
+}
+export declare function createPoint(pointMesh: PointMesh, pointSelector: PointSelector): Promise<void>;

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

@@ -0,0 +1,8 @@
+import type { Polygon } from '.';
+import type { FiveDomEvent } from '../../../shared-utils/five/FiveDomEvents';
+import { LineEditor } from '../Polyline/Editor';
+export declare class PolygonEditor extends LineEditor<Polygon> {
+    get lines(): import("../../Meshes/LineWithDots").LineWithDotsMesh[];
+    constructor(originObject: Polygon);
+    protected onDrag: (event: FiveDomEvent) => void;
+}

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

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import { AreaMesh, type AreaStyle } from '../../Meshes/Area';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { LiteralString } from '../../typings/utils.type';
+import type { PolygonData, PolygonStyle } from '../../Meshes/Polygon';
+export interface PolygonImportData extends BaseImportData, PolygonData {
+    type: LiteralString<'Polygon'>;
+    style?: Partial<AreaStyle>;
+}
+export declare class Polygon extends BaseObject<PolygonImportData> {
+    readonly type = "Polygon";
+    areaMesh: AreaMesh;
+    get data(): {
+        points: [number, number, number][];
+        style: {
+            color: number;
+            lineColor: number;
+            lineWidth: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: PolygonImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<PolygonStyle>): Promise<void>;
+}
+export declare function createPolygon(areaMesh: AreaMesh, pointSelector: PointSelector): Promise<void>;

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

@@ -0,0 +1,25 @@
+import { BaseEditor } from '../Base/Editor';
+import type { FiveDomEvent } from '../../../shared-utils/five/FiveDomEvents';
+import type { Polyline } from '.';
+import type * as THREE from 'three';
+import { PointMesh } from '../../Meshes/Point';
+import type { LineWithDotsMesh } from '../../Meshes/LineWithDots';
+export declare abstract class LineEditor<OriginObject extends THREE.Object3D = THREE.Object3D> extends BaseEditor<OriginObject> {
+    protected draggingPoints: PointMesh[];
+    protected get points(): PointMesh[];
+    abstract get lines(): LineWithDotsMesh[];
+    get pointHandles(): PointMesh[];
+    constructor(originObject: OriginObject);
+    enable(): void;
+    disable(): void;
+    protected onDragstart: (event: FiveDomEvent) => void;
+    protected onDragend: (event: FiveDomEvent) => void;
+    protected abstract onDrag(event: FiveDomEvent): void;
+}
+export declare class PolylineEditor extends LineEditor<Polyline> {
+    get lines(): LineWithDotsMesh[];
+    constructor(originObject: Polyline);
+    enable(): void;
+    disable(): void;
+    protected onDrag: (event: FiveDomEvent) => void;
+}

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

@@ -0,0 +1,31 @@
+import type { Color } from '../../../Object3DHelperPlugin';
+import { PolylineMesh, PolylineWithDotsMesh, type PolylineData, type PolylineStyle } from '../../Meshes/Polyline';
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { LiteralString } from '../../typings/utils.type';
+export interface PolylineImportData extends BaseImportData, PolylineData {
+    type: LiteralString<'Polyline'>;
+    style?: Partial<PolylineStyle>;
+}
+export declare class Polyline extends BaseObject<PolylineImportData> {
+    readonly type = "Polyline";
+    polyLineMesh: PolylineWithDotsMesh;
+    get data(): {
+        points: [number, number, number][];
+        style: {
+            lineColor: number;
+            lineWidth: number;
+            dashed: boolean;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: PolylineImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: {
+        color?: Color;
+        lineWidth?: number;
+    }): Promise<void>;
+}
+export declare function createPolyline(polyLineMesh: PolylineMesh, pointSelector: PointSelector): Promise<void>;

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

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

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

@@ -0,0 +1,28 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import { PrismMesh, type PrismData, type PrismStyle } from '../../Meshes/Prism';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { LiteralString } from '../../typings/utils.type';
+export interface PrismImportData extends BaseImportData, PrismData {
+    type: LiteralString<'Prism'>;
+    style?: Partial<PrismStyle>;
+}
+export declare class Prism extends BaseObject<PrismImportData> {
+    readonly type = "Prism";
+    prismMesh: PrismMesh;
+    get data(): {
+        readonly points: [number, number, number][];
+        readonly heightPoint: [number, number, number];
+        readonly style: {
+            readonly color: number;
+            readonly lineWidth: number;
+            readonly lineColor: number;
+        };
+        readonly id: string;
+        readonly type: string;
+    };
+    constructor(data?: PrismImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<PrismStyle>): Promise<void>;
+}
+export declare function createPrism(prismMesh: PrismMesh, pointSelector: PointSelector): Promise<void>;

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

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

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

@@ -0,0 +1,29 @@
+import { BaseObject, type BaseImportData, type BaseObjectConfig } from '../Base';
+import type { PointSelector } from '../../../shared-utils/three/PointSelector';
+import type { ArrayPosition } from '../../../PanoTagPlugin';
+import type { RectangleData, RectangleMesh } from '../../Meshes/Rectangle';
+import { RectangleWithEdgeMesh, type RectangleWithEdgeMeshStyle } from '../../Meshes/RectangleWithEdge';
+import type { LiteralString } from '../../typings/utils.type';
+export interface RectangleImportData extends BaseImportData, RectangleData {
+    type: LiteralString<'Rectangle'>;
+    style?: Partial<RectangleWithEdgeMeshStyle>;
+}
+export declare class Rectangle extends BaseObject<RectangleImportData> {
+    readonly type = "Rectangle";
+    rectangleMesh: RectangleWithEdgeMesh;
+    get data(): {
+        points: [ArrayPosition, ArrayPosition, ArrayPosition];
+        style: {
+            color: number;
+            lineWidth: number;
+            lineColor: number;
+        };
+        id: string;
+        type: string;
+    };
+    constructor(data?: RectangleImportData, config?: Partial<BaseObjectConfig>);
+    highlight(): void;
+    unhighlight(): void;
+    create(params?: Partial<RectangleWithEdgeMeshStyle>): Promise<void>;
+}
+export declare function createRectangle(rectangleMesh: RectangleMesh, pointSelector: PointSelector): Promise<void>;

package/dist/Sculpt/index.d.ts

@@ -0,0 +1,184 @@
+import type { Five } from '@realsee/five';
+import type * as THREE from 'three';
+import type { BaseObject, BaseObjectConfig } from './Objects/Base';
+import { Subscribe } from '../shared-utils/Subscribe';
+import { IObject3D } from '../shared-utils/three/IObject3D';
+import type { PartialDeep } from 'type-fest';
+import { Polyline } from './Objects/Polyline';
+import { Point } from './Objects/Point';
+import { Polygon } from './Objects/Polygon';
+import { Prism } from './Objects/Prism';
+import { Rectangle } from './Objects/Rectangle';
+import { Circle } from './Objects/Circle';
+import { Cylinder } from './Objects/Cylinder';
+import { Box } from './Objects/Box';
+import type { PolylineImportData, PointImportData, PolygonImportData, PrismImportData, RectangleImportData, CircleImportData, CylinderImportData, BoxImportData } from './typings';
+import type { AreaStyle, PointStyle, PolylineStyle, PrismStyle, RectangleStyle, CircleStyle, CylinderStyle, BoxStyle } from './typings';
+type BuiltInData = PolylineImportData | PointImportData | PolygonImportData | PrismImportData | RectangleImportData | CircleImportData | CylinderImportData | BoxImportData;
+type BuiltInItem = Polyline | Point | Polygon | Prism | Rectangle | Circle | Cylinder | Box;
+type Theme = PartialDeep<{
+    point: PointStyle;
+    polyline: PolylineStyle;
+    polygon: AreaStyle;
+    prism: PrismStyle;
+    rectangle: RectangleStyle;
+    circle: CircleStyle;
+    cylinder: CylinderStyle;
+    box: BoxStyle;
+}>;
+interface Data {
+    items: Array<BuiltInData>;
+}
+type Event = {
+    /**
+     * @description: 点击事件
+     * @param {BuiltInItem} item 点击的物体
+     * 返回 false 来禁用 Five 默认行为
+     */
+    click: (item: BuiltInItem) => void | false;
+};
+export declare class Sculpt extends Subscribe<Event> {
+    static modules: {
+        five: Five;
+        _cursor: import("./Modules/Cursor").Cursor;
+        _pointSelector: import("../shared-utils/three/PointSelector").PointSelector;
+        _fiveDomEvents: import("../shared-utils/five/FiveDomEvents").FiveDomEvents;
+        _object3DHelper: import("..").Object3DHelperController;
+        inited: boolean;
+        readonly cursor: import("./Modules/Cursor").Cursor;
+        readonly pointSelector: import("../shared-utils/three/PointSelector").PointSelector;
+        readonly fiveDomEvents: import("../shared-utils/five/FiveDomEvents").FiveDomEvents;
+        readonly object3DHelper: import("..").Object3DHelperController;
+        init: (five: Five) => void;
+    };
+    get data(): {
+        items: ({
+            points: [number, number, number][];
+            style: {
+                lineColor: number;
+                lineWidth: number;
+                dashed: boolean;
+            };
+            id: string;
+            type: string;
+        } | {
+            point: [number, number, number];
+            style: {
+                color: number;
+                size: number;
+            };
+            id: string;
+            type: string;
+        } | {
+            points: [number, number, number][];
+            style: {
+                color: number;
+                lineColor: number;
+                lineWidth: number;
+            };
+            id: string;
+            type: string;
+        } | {
+            readonly points: [number, number, number][];
+            readonly heightPoint: [number, number, number];
+            readonly style: {
+                readonly color: number;
+                readonly lineWidth: number;
+                readonly lineColor: number;
+            };
+            readonly id: string;
+            readonly type: string;
+        } | {
+            points: [import("..").ArrayPosition, import("..").ArrayPosition, import("..").ArrayPosition];
+            style: {
+                color: number;
+                lineWidth: number;
+                lineColor: number;
+            };
+            id: string;
+            type: string;
+        } | {
+            center: [number, number, number];
+            normal: [number, number, number];
+            radius: number;
+            style: {
+                color: number;
+            };
+            id: string;
+            type: string;
+        } | {
+            bottomCenter: [number, number, number];
+            topCenter: [number, number, number];
+            radius: number;
+            style: {
+                color: number;
+            };
+            id: string;
+            type: string;
+        })[];
+    };
+    group: IObject3D;
+    get items(): BuiltInItem[];
+    private five;
+    private theme;
+    constructor(five: Five, theme?: Theme);
+    /**
+     * @description: 加载数据 展示
+     */
+    load(data: Data, config?: Partial<BaseObjectConfig>): void;
+    /**
+     * @description: 获取物体实例
+     */
+    getItemById(id: string): BuiltInItem;
+    /**
+     * @description: 放置物体
+     */
+    putObject(object: THREE.Object3D): import("..").Object3DHelperController;
+    /**
+     * @description: 开始绘制点
+     */
+    createPoint(params?: Parameters<Point['create']>[0]): Promise<BaseObject<any, any, BaseObjectConfig>>;
+    /**
+     * @description: 开始绘制空间折线
+     */
+    createPolyline(params?: Parameters<Polyline['create']>[0]): Promise<BaseObject<any, any, BaseObjectConfig>>;
+    /**
+     * @description: 开始绘制平面多边形
+     */
+    createPolygon(params?: Parameters<Polygon['create']>[0]): Promise<BaseObject<any, any, BaseObjectConfig>>;
+    /**
+     * @description: 开始绘制多棱柱
+     */
+    createPrism(params?: Parameters<Prism['create']>[0]): Promise<BaseObject<any, any, BaseObjectConfig>>;
+    /**
+     * @description: 开始绘制矩形
+     */
+    createRectangle(params?: Parameters<Rectangle['create']>[0]): Promise<BaseObject<any, any, BaseObjectConfig>>;
+    /**
+     * @description: 开始绘制圆形
+     */
+    createCircle(params?: Parameters<Circle['create']>[0]): Promise<BaseObject<any, any, BaseObjectConfig>>;
+    /**
+     * @description: 开始绘制圆柱
+     */
+    createCylinder(params?: Parameters<Cylinder['create']>[0]): Promise<BaseObject<any, any, BaseObjectConfig>>;
+    /**
+     * @description: 开始绘制 Box
+     */
+    createBox(params?: Parameters<Box['create']>[0]): Promise<BaseObject<any, any, BaseObjectConfig>>;
+    /**
+     * @description: 撤销
+     */
+    undo(): void;
+    /**
+     * @description: 重做
+     */
+    redo(): void;
+    /**
+     * @description: 清空数据
+     */
+    clear(): void;
+    private createItem;
+    private needsRender;
+}
+export {};

package/dist/Sculpt/typings/index.d.ts

@@ -0,0 +1,16 @@
+export type { Polyline, PolylineImportData } from '../Objects/Polyline';
+export type { Point, PointImportData } from '../Objects/Point';
+export type { Polygon, PolygonImportData } from '../Objects/Polygon';
+export type { Prism, PrismImportData } from '../Objects/Prism';
+export type { Rectangle, RectangleImportData } from '../Objects/Rectangle';
+export type { Circle, CircleImportData } from '../Objects/Circle';
+export type { Cylinder, CylinderImportData } from '../Objects/Cylinder';
+export type { Box, BoxImportData } from '../Objects/Box';
+export type { PointStyle } from '../Meshes/Point';
+export type { PolylineStyle } from '../Meshes/Polyline';
+export type { PrismStyle } from '../Meshes/Prism';
+export type { RectangleWithEdgeMeshStyle as RectangleStyle } from '../Meshes/RectangleWithEdge';
+export type { CircleWithEdgeMeshStyle as CircleStyle } from '../Meshes/CircleWithEdge';
+export type { CylinderStyle } from '../Meshes/Cylinder';
+export type { BoxStyle } from '../Meshes/Box';
+export type { AreaStyle } from '../Meshes/Area';

package/dist/Sculpt/typings/utils.type.d.ts

@@ -0,0 +1,12 @@
+import type * as THREE from 'three';
+import type { LiteralUnion, UnknownArray } from 'type-fest';
+import type { IsNull, NonRecursiveType } from 'type-fest/source/internal';
+export type LiteralString<T> = LiteralUnion<T, string>;
+export type JsonVector3<T> = ReplaceDeep<T, THREE.Vector3, number[]>;
+export type JsonColor<T> = ReplaceDeep<T, THREE.Color>;
+export type JsonData<T> = JsonColor<JsonVector3<T>>;
+type SafeType<T, SourceType, TargetType = null> = IsNull<TargetType> extends true ? Exclude<T, SourceType> : TargetType;
+export type ReplaceDeep<T, SourceType, TargetType = null> = T extends SourceType ? SafeType<T, SourceType, TargetType> : T extends THREE.Vector3 | THREE.Color | NonRecursiveType ? T : T extends UnknownArray ? T[number] extends SourceType ? SafeType<T[number], SourceType, TargetType>[] : T : T extends object ? {
+    [K in keyof T]: T[K] extends SourceType ? SafeType<T[K], SourceType, TargetType> : SourceType extends T[K] ? SafeType<T[K], SourceType, TargetType> : ReplaceDeep<T[K], SourceType, TargetType>;
+} : T;
+export {};

package/dist/Sculpt/utils/color.d.ts

@@ -0,0 +1,40 @@
+import type * as THREE from 'three';
+export type Color = THREE.Color | string | number;
+export declare const DEFAULT_COLOR = 16777215;
+export declare const DEFAULT_LINE_COLOR = 16777215;
+export declare const DEFAULT_LINE_WIDTH = 2;
+export declare const DEFAULT_HIGHLIGHT_OPACITY = 0.6;
+export type OpacityStyle = {
+    /**
+     * @description: 透明度
+     */
+    opacity?: number;
+};
+export type ColorStyle = {
+    /**
+     * @description: 颜色
+     * @default 0x1193fa
+     */
+    color?: Color;
+};
+export type LineColorStyle = {
+    /**
+     * @description: 边框线颜色
+     * @default 0x1193fa
+     */
+    lineColor?: Color;
+};
+export type LineWidthStyle = {
+    /**
+     * @description: 线宽
+     * @default 2
+     */
+    lineWidth?: number;
+};
+export type OcclusionStyle = {
+    /**
+     * @description: 是否以一种半透明的方式显示遮挡的部分
+     */
+    occlusionVisibility: boolean;
+};
+export type LineStyle = LineColorStyle & LineWidthStyle;

package/dist/Sculpt/utils/data.d.ts

@@ -0,0 +1,7 @@
+import type { AnyPosition } from '../../shared-utils/positionToVector3';
+export type PointData = {
+    point: AnyPosition;
+};
+export type PointsData = {
+    points: AnyPosition[];
+};

package/dist/Sculpt/utils/getBetterNormal.d.ts

@@ -0,0 +1,2 @@
+import * as THREE from 'three';
+export default function getBetterNormal(points: THREE.Vector3[], closestPoint: THREE.Vector3): THREE.Vector3;

package/dist/Sculpt/utils/radiusToSegments.d.ts

@@ -0,0 +1 @@
+export default function radiusToSegments(radius: number): number;

package/dist/Sculpt/utils/three/ColoredMesh.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import { type ColorStyle, type OpacityStyle, type OcclusionStyle } from '../color';
+import { IObject3D } from '../../../shared-utils/three/IObject3D';
+export type ColoredMeshStyle = OpacityStyle & ColorStyle & OcclusionStyle;
+export default class ColoredMesh<TGeometry extends THREE.Geometry | THREE.BufferGeometry = THREE.Geometry | THREE.BufferGeometry> extends IObject3D {
+    name: string;
+    meshFont: THREE.Mesh<TGeometry, THREE.MeshBasicMaterial>;
+    meshBackground: THREE.Mesh<TGeometry, THREE.MeshBasicMaterial>;
+    get color(): THREE.Color;
+    get opacity(): number;
+    get occlusionVisibility(): boolean;
+    set geometry(geometry: TGeometry);
+    get geometry(): TGeometry;
+    private _geometry;
+    constructor(params?: Partial<ColoredMeshStyle>);
+    setStyle(params: Partial<ColoredMeshStyle>): void;
+}

package/dist/Sculpt/utils/three/RectangleGeometry.d.ts

@@ -0,0 +1,6 @@
+import * as THREE from 'three';
+export declare class RectangleGeometry extends THREE.BufferGeometry {
+    name: string;
+    points: THREE.Vector3[];
+    constructor(points: THREE.Vector3[]);
+}

package/dist/Sculpt/utils/three/rayOnLine.d.ts

@@ -0,0 +1,5 @@
+import * as THREE from 'three';
+/**
+ * @description: 求射线与直线的交点
+ */
+export declare function rayOnLine(cameraPosition: THREE.Vector3, ray: THREE.Ray, line: THREE.Line3): THREE.Vector3;