@realsee/dnalogel 3.69.12 → 3.69.13-alpha-1

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

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { Subscribe } from '../../Subscribe';
+import type { DashGuideOptions } from '../utils/dashGuide';
 import type { HelperEventMap, HelperOffset, InternalHelperEventMap, ScaleCallback } from '../typings';
 import type { BaseHelper } from './BaseHelper';
 import DomEvents from '../../threex/domevents';
@@ -12,6 +13,8 @@ type Config = {
     xAxis?: THREE.Vector3 | (() => THREE.Vector3);
     zAxis?: THREE.Vector3 | (() => THREE.Vector3);
     scaleCallback?: ScaleCallback;
+    /** 虚线样式与行为配置（透传给 DashGuideLine） */
+    dashGuide?: DashGuideOptions;
 };
 export declare abstract class BaseController<T extends BaseHelper = BaseHelper, K extends THREE.Object3D = THREE.Object3D> {
     originObject3D: K;

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

@@ -54,6 +54,9 @@ export declare abstract class MoveHelperAbstract<OriginObject3D extends Object3D
         line?: Object3D;
         direction: Direction;
     };
+    abstract centerHandle?: Object3D & {
+        direction: Direction;
+    };
     abstract showDraggingHelper(directions?: Direction[]): void;
     abstract update(camera: THREE.Camera): void;
 }
@@ -73,11 +76,13 @@ export declare abstract class RotateHelperAbstract<OriginObject3D extends Object
     abstract zCircle?: Circle;
     abstract angleTips?: ReturnType<typeof tipsDom>;
     abstract showDraggingHelper(directions: Direction[]): void;
+    abstract update(camera: THREE.Camera): void;
 }
 export declare abstract class ScaleHelperAbstract<OriginObject3D extends Object3D = Object3D> extends BaseHelper<OriginObject3D> {
     abstract scaleMeshes: Array<Object3D & {
         scalePosition: ScalePosition;
     }>;
+    abstract update(camera: THREE.Camera): void;
 }
 export declare abstract class RectangleScaleHelperAbstract<OriginObject3D extends Object3D, PointType extends Object3D | HTMLElement> extends BaseHelper<OriginObject3D> {
     abstract points: PointType extends Object3D ? {

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

@@ -20,6 +20,9 @@ export declare class MoveController<T extends MoveHelperAbstract = MoveHelperAbs
     get moveByMouseEnable(): boolean;
     protected name: string;
     private startInfo?;
+    /** 拖拽时用于显示方向参考的直线（与 ScaleController 一致：Line + LineBasicMaterial） */
+    private dragGuideLine?;
+    private dashGuide;
     private _moveByMouse;
     private mouseInfo?;
     private mousedownEventListenerDisposer;
@@ -47,6 +50,10 @@ export declare class MoveController<T extends MoveHelperAbstract = MoveHelperAbs
      */
     private dragStart;
     private dragging;
+    /**
+     * 更新直线缩放，保持视觉上的恒定大小（与 ScaleController 保持一致）
+     */
+    private updateDragGuideLineScale;
     private move;
     private dragEnd;
 }

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

@@ -12,6 +12,13 @@ export declare class RotateController<T extends RotateHelperAbstract = RotateHel
         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;
@@ -24,9 +31,13 @@ export declare class RotateController<T extends RotateHelperAbstract = RotateHel
      * @description: 拖动开始，找出拖的Direction
      */
     private dragStart;
+    private getMatrix;
+    private getMatrixAngle;
+    private parseAngleByDirection;
     private dragging;
     private rotate;
     private dragEnd;
+    private updateOtherHelpers;
     private getAngleHelper;
     private setAngleHelperStart;
     private setAngleHelperLength;

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

@@ -3,12 +3,19 @@ import type { ScaleHelperAbstract } from '../Helper';
 import * as THREE from 'three';
 export declare class ScaleController<T extends ScaleHelperAbstract = ScaleHelperAbstract> extends BaseController<T> {
     protected name: string;
+    /** 拖拽时用于显示方向参考的直线（使用 Line 实现无限长穿透整个平面的直线） */
+    private dragGuideLine?;
+    /** 当前拖拽时显示的面片 */
+    private currentFacePatch?;
+    private dashGuide;
     private startInfo?;
     constructor(...params: ConstructorParameters<typeof BaseController<T>>);
     initialHelperPosition(): void;
     dragStart: (params: {
         intersect: THREE.Intersection;
     }) => void;
+    private addFaceMesh;
+    private removeFaceMesh;
     dragging: (point: {
         x: number;
         y: number;
@@ -20,4 +27,32 @@ export declare class ScaleController<T extends ScaleHelperAbstract = ScaleHelper
     }): void;
     scale: (raycaster: THREE.Raycaster) => void;
     dragEnd: () => void;
+    /**
+     * 更新直线方向，保持直线始终经过物体中心和当前拉伸球位置
+     */
+    private updateDragGuideLineDirection;
+    /**
+     * 更新直线缩放，保持视觉上的恒定大小
+     */
+    private updateDragGuideLineScale;
+    /**
+     * 更新面片位置，使其跟随拖拽球的位置
+     */
+    private updateFacePatchPosition;
+    /**
+     * 向场景添加一个表示 face 的面片，红色，位置与 face.center 一致，使用两个三角形拼成矩形
+     */
+    addFacePatch(face: {
+        center: THREE.Vector3;
+        vertices?: THREE.Vector3[];
+        normal?: THREE.Vector3;
+    } | {
+        center: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        vertices?: THREE.Vector3[];
+        normal?: THREE.Vector3;
+    }): THREE.Mesh<THREE.BufferGeometry, THREE.MeshBasicMaterial>;
 }

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

@@ -22,6 +22,7 @@ export declare class CSS3DScaleHelper<T extends CSS3DObjectPlus = CSS3DObjectPlu
     showDraggingHelper(): void;
     applyHelperScaleMatrix4(matrix: THREE.Matrix4, origin?: Vector3): void;
     updatePoints(): void;
+    update(camera: THREE.Camera): void;
     applyHelperQuaternion(quaternion: THREE.Quaternion, origin: Vector3): void;
     enable(): void;
     disable(): void;

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

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

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

@@ -8,6 +8,9 @@ export declare class MoveHelper extends MoveHelperAbstract {
     xArrow?: ArrowGroup;
     yArrow?: ArrowGroup;
     zArrow?: ArrowGroup;
+    centerHandle?: THREE.Object3D & {
+        direction: Direction;
+    };
     constructor(originObject3D: Object3D, config?: {
         xArrowEnable?: boolean;
         yArrowEnable?: boolean;

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

@@ -21,6 +21,7 @@ export declare class RotateHelper extends RotateHelperAbstract {
     hide(): void;
     show(): void;
     setScaleByCamera(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
+    update(camera: THREE.Camera): void;
     showDraggingHelper(directions: Direction[]): void;
     dispose(): void;
 }
@@ -59,11 +60,34 @@ declare class DashedRing extends THREE.Group {
 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/dist/shared-utils/Object3DHelper/Helper/ScaleHelper.d.ts

@@ -1,16 +1,61 @@
 import * as THREE from 'three';
 import { ScaleHelperAbstract, type BaseHelperConfig } from '../Base/BaseHelper';
 import type { ScalePosition } from '../typings';
+interface LineConnection {
+    line: THREE.Line;
+    mesh1: THREE.Object3D & {
+        scalePosition: ScalePosition;
+    };
+    mesh2: THREE.Object3D & {
+        scalePosition: ScalePosition;
+    };
+}
 export declare class ScaleHelper<T extends THREE.Object3D = THREE.Object3D> extends ScaleHelperAbstract<T> {
     name: string;
     scaleMeshes: Array<THREE.Object3D & {
         scalePosition: ScalePosition;
     }>;
+    lineConnections: Array<LineConnection>;
     private positions;
+    private container;
+    private needsInitialScaling;
+    private lastCamera;
+    private isInitializing;
     constructor(originObject3D: T, config?: {
         positions?: Array<ScalePosition> | (() => Array<ScalePosition>);
+        container?: HTMLElement | null;
     } & BaseHelperConfig);
     initQuaternion(): void;
     initialPosition(offset?: THREE.Vector3): void;
+    /**
+     * 清理所有缩放球
+     */
+    private clearAllSpheres;
+    /**
+     * 创建中心对称球之间的直线连接
+     */
+    private createLineConnections;
+    update(camera: THREE.Camera): void;
+    /**
+     * 应用球的缩放逻辑
+     */
+    private applySphereScaling;
+    /**
+     * 应用直线缩放逻辑（直线不需要特殊的缩放处理）
+     */
+    private applyLineScaling;
+    /**
+     * 显示所有直线连接
+     */
+    showLineConnections(): void;
+    /**
+     * 隐藏所有直线连接
+     */
+    hideLineConnections(): void;
+    /**
+     * 更新直线连接的位置和可见性
+     */
+    private updateLineConnections;
     setScaleByCamera(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
 }
+export {};

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

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

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

@@ -14,6 +14,9 @@ export type HelperEventMap = {
     scaleEnd: () => void;
     moveByMouseEnable: () => void;
     moveByMouseDisable: () => void;
+    updateOtherHelpers: (params: {
+        camera: THREE.Camera;
+    }) => void;
 };
 export type InternalHelperEventMap = {
     initialHelperPosition: () => void;

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

@@ -0,0 +1,56 @@
+import * as THREE from 'three';
+/** 将世界坐标投影为屏幕像素坐标 */
+export declare function projectToScreen(camera: THREE.Camera, container: HTMLElement | null | undefined, point: THREE.Vector3): THREE.Vector2;
+/** 估算某方向上线段的像素与世界长度的比例（世界单位/像素） */
+export declare function computeWorldPerPixel(camera: THREE.Camera, container: HTMLElement | null | undefined, center: THREE.Vector3, direction: THREE.Vector3): number;
+/** 计算虚线长度：随相机距离/视口变化自适应，限制在可视范围内 */
+export declare function computeGuideLength(camera: THREE.Camera, center: THREE.Vector3): number;
+export type ComputeParamsOptions = {
+    lengthFactorPx?: number;
+    dashPx?: number;
+    gapPx?: number;
+};
+/** 计算虚线总长度与像素目标（用于生成 LineSegments） */
+export declare function computeGuideParams(camera: THREE.Camera, container: HTMLElement | null | undefined, center: THREE.Vector3, direction: THREE.Vector3, options?: ComputeParamsOptions): {
+    length: number;
+    dashPx: number;
+    gapPx: number;
+};
+/** 基于像素恒定构建虚线段几何（返回 position attribute） */
+export type BuildSegmentsOptions = {
+    segmentsCap?: number;
+    wppClampFactor?: number;
+    expectedSegmentsSafety?: number;
+    expectedSegmentsMargin?: number;
+};
+export declare function buildDashSegments(camera: THREE.Camera, container: HTMLElement | null | undefined, center: THREE.Vector3, direction: THREE.Vector3, totalLength: number, dashPx: number, gapPx: number, options?: BuildSegmentsOptions): Float32Array;
+export type DashGuideOptions = ComputeParamsOptions & BuildSegmentsOptions & {
+    color?: number;
+    renderOrder?: number;
+};
+export declare class DashGuideLine {
+    private camera;
+    private container;
+    private defaults;
+    constructor(camera: THREE.Camera, container: HTMLElement | null | undefined, defaults?: DashGuideOptions);
+    /** 创建虚线（LineSegments + LineBasicMaterial），控制器负责添加到场景 */
+    create(center: THREE.Vector3, direction: THREE.Vector3, options?: DashGuideOptions): THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    /** 更新已创建的虚线，使其保持像素恒定 */
+    update(segments: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>, center: THREE.Vector3, direction: THREE.Vector3, options?: DashGuideOptions): void;
+    /** 创建无限长直线（Line + LineBasicMaterial），穿过整个平面 */
+    createSolidLine(center: THREE.Vector3, direction: THREE.Vector3, options?: {
+        color?: number;
+        renderOrder?: number;
+    }): THREE.Line<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    /** 更新已创建的直线，使其始终穿过整个平面 */
+    updateSolidLine(line: THREE.Line<THREE.BufferGeometry, THREE.LineBasicMaterial>, center: THREE.Vector3, direction: THREE.Vector3, options?: {
+        color?: number;
+        renderOrder?: number;
+    }): void;
+    /** 计算"无限"直线的长度，确保穿过整个可视区域 */
+    private computeInfiniteLineLength;
+    /** 释放虚线的几何与材质 */
+    dispose(segments?: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial> | THREE.Line<THREE.BufferGeometry, THREE.LineBasicMaterial>): void;
+    /** 更新默认配置 */
+    updateDefaults(options: DashGuideOptions): void;
+}