@realsee/dnalogel 2.1.0-alpha.1 → 2.1.0-alpha.10

package/libs/shared-utils/Object3DHelper/Controller/RectangleScaleController.js

@@ -2,8 +2,6 @@ import { BaseController } from '../Base/BaseController';
 import * as THREE from 'three';
 import { getMouseRaycaster, vectorIsEqual } from '../utils';
 import { Vector3 } from 'three';
-import { negateScale } from '../utils/negateScale';
-import '../utils/getPoint';
 export class RectangleScaleController extends BaseController {
     constructor(...params) {
         super(...params);
@@ -40,10 +38,6 @@ export class RectangleScaleController extends BaseController {
             plane.setFromNormalAndCoplanarPoint(this.originObject3D.getWorldDirection(new Vector3()), positions[0]);
         else
             plane.setFromCoplanarPoints(positions[0], positions[1], positions[2]);
-        // const p0 = getPoint(positions[0]!, 0)
-        // const p1 = getPoint(positions[1]!, 1)
-        // const p2 = getPoint(positions[2]!, 2)
-        // this.scene.add(p0, p1, p2)
         return plane;
     }
     dragStart(mousePoint, point) {
@@ -53,8 +47,9 @@ export class RectangleScaleController extends BaseController {
         if (!plane)
             return this.dragEnd();
         this.startInfo = { startPoint: { position: point.position.clone(), direction: point.direction }, plane };
+        // this.scene.add(getPoint(point.position.clone(), 3))
         this.hooks.emit('scaleStart');
-        this.needsRender();
+        this.render();
         this.isDragging = true;
         console.log('%c RectangleScaleController dragStart', 'color: #e5af2e');
     }
@@ -65,7 +60,7 @@ export class RectangleScaleController extends BaseController {
         if (!raycaster)
             return this.dragEnd();
         this.scale(raycaster);
-        console.log('%c RectangleScaleController dragging', 'color: #49de1b');
+        // console.log('%c RectangleScaleController dragging', 'color: #49de1b')
     }
     scale(raycaster) {
         var _a, _b;
@@ -81,101 +76,116 @@ export class RectangleScaleController extends BaseController {
             return;
         if (vectorIsEqual(planeIntersection, this.camera.position))
             return;
-        const referencePosition = cornerPositions[0].clone();
         const planeCenter = new Vector3().addVectors(cornerPositions[0], cornerPositions[2]).divideScalar(2);
         const { position: startPosition, direction } = startPoint;
-        const ewVector = new Vector3().subVectors(cornerPositions[1], referencePosition); // west -> east vector
-        const nsVector = new Vector3().subVectors(cornerPositions[3], referencePosition); // south -> north vector
+        const ewVector = new Vector3().subVectors(cornerPositions[1], cornerPositions[0]); // west -> east vector
+        const nsVector = new Vector3().subVectors(cornerPositions[3], cornerPositions[0]); // south -> north vector
         // eslint-disable-next-line complexity
-        const getScale = (direction) => {
+        const getOffset = (direction) => {
+            const defaultVector = new Vector3(0, 0, 0);
+            if (!this.startInfo)
+                return defaultVector;
             const baseVector = (direction === 'ew' ? ewVector : nsVector).clone();
             const startPositionProject = startPosition.clone().projectOnVector(baseVector);
             const nowPositionProject = planeIntersection.clone().projectOnVector(baseVector);
             const planeCenterProject = planeCenter.clone().projectOnVector(baseVector);
-            if (this.startInfo) {
-                if (direction === 'ns' && typeof this.startInfo.nsMoveIsNegative !== 'boolean') {
-                    const offset = new Vector3().subVectors(nowPositionProject, planeCenterProject);
-                    const xIsNegative = offset.x < 0 && baseVector.x >= 0;
-                    const yIsNegative = offset.y < 0 && baseVector.y >= 0;
-                    const zIsNegative = offset.z < 0 && baseVector.z >= 0;
-                    this.startInfo.nsMoveIsNegative = xIsNegative || yIsNegative || zIsNegative;
+            // this.scene.add(getPoint(startPosition, 0))
+            // this.scene.add(getPoint(planeIntersection, 0))
+            if (nowPositionProject.equals(startPositionProject))
+                return defaultVector;
+            if (direction === 'ns' && typeof this.startInfo.dragPointInCenterBottom !== 'boolean') {
+                const offset = new Vector3().subVectors(nowPositionProject, planeCenterProject);
+                const xIsNegative = offset.x < 0 && baseVector.x >= 0;
+                const yIsNegative = offset.y < 0 && baseVector.y >= 0;
+                const zIsNegative = offset.z < 0 && baseVector.z >= 0;
+                this.startInfo.dragPointInCenterBottom = xIsNegative || yIsNegative || zIsNegative;
+            }
+            if (direction === 'ew' && typeof this.startInfo.dragPointInCenterLeft !== 'boolean') {
+                const offset = new Vector3().subVectors(nowPositionProject, planeCenterProject);
+                const xIsNegative = offset.x < 0 && baseVector.x >= 0;
+                const yIsNegative = offset.y < 0 && baseVector.y >= 0;
+                const zIsNegative = offset.z < 0 && baseVector.z >= 0;
+                this.startInfo.dragPointInCenterLeft = xIsNegative || yIsNegative || zIsNegative;
+            }
+            const offset = new Vector3().subVectors(nowPositionProject, startPositionProject);
+            // TODO: 不知道为啥b端在缩放结束有问题，先临时加个限制
+            const offsetLength = offset.length();
+            if (offsetLength > 0.2) {
+                console.warn('offset.length() > 0.2, skipped', offsetLength);
+                return defaultVector;
+            }
+            return offset;
+        };
+        const ewOffset = getOffset('ew');
+        const nsOffset = getOffset('ns');
+        const setEWScale = () => {
+            const offset = ewOffset;
+            this.helperObject3D.cornerPositions.forEach((position, index) => {
+                var _a;
+                if ((_a = this.startInfo) === null || _a === void 0 ? void 0 : _a.dragPointInCenterLeft) {
+                    if (index === 0 || index === 3)
+                        position.add(offset); // 拖左边，只改左边点
                 }
-                if (direction === 'ew' && typeof this.startInfo.ewMoveIsNegative !== 'boolean') {
-                    const offset = new Vector3().subVectors(nowPositionProject, planeCenterProject);
-                    const xIsNegative = offset.x < 0 && baseVector.x >= 0;
-                    const yIsNegative = offset.y < 0 && baseVector.y >= 0;
-                    const zIsNegative = offset.z < 0 && baseVector.z >= 0;
-                    this.startInfo.ewMoveIsNegative = xIsNegative || yIsNegative || zIsNegative;
+                else {
+                    if (index === 1 || index === 2)
+                        position.add(offset); // 拖右边，只改右边点
                 }
-            }
-            if (nowPositionProject.equals(startPositionProject))
-                return;
-            const startPositionProjectOffset = new Vector3().subVectors(startPositionProject, planeCenterProject);
-            const nowPositionProjectOffset = new Vector3().subVectors(nowPositionProject, planeCenterProject);
-            const scale = nowPositionProjectOffset.clone().divide(startPositionProjectOffset);
-            scale.x = isNaN(scale.x) ? 1 : scale.x;
-            scale.y = isNaN(scale.y) ? 1 : scale.y;
-            scale.z = isNaN(scale.z) ? 1 : scale.z;
-            return scale;
+            });
         };
-        const nsScale = (_a = getScale('ns')) !== null && _a !== void 0 ? _a : new Vector3(1, 1, 1);
-        const ewScale = (_b = getScale('ew')) !== null && _b !== void 0 ? _b : new Vector3(1, 1, 1);
-        const scale = (() => {
-            switch (direction) {
-                case 'ew':
-                    return ewScale;
-                case 'ns':
-                    return nsScale;
-                case 'nesw':
-                case 'nwse':
-                    return new Vector3().multiplyVectors(nsScale, ewScale);
-            }
-        })();
-        const halfScale = scale.clone().sub(new Vector3(1, 1, 1)).multiplyScalar(0.5).add(new Vector3(1, 1, 1));
-        const scaleMatrix = new THREE.Matrix4().scale(halfScale);
-        const newScale = object.scale.clone().applyMatrix4(scaleMatrix);
-        // const minScale = 0.000001
-        // newScale.x = Math.max(newScale.x, minScale)
-        // newScale.y = Math.max(newScale.y, minScale)
-        // newScale.z = Math.max(newScale.z, minScale)
-        // if (direction === 'ew' || direction === 'ns') {
-        //   if (newScale.x === minScale || newScale.y === minScale || newScale.z === minScale) return
-        // }
-        // if (direction === 'nesw' || direction === 'nwse') {
-        //   if (newScale.x === minScale && newScale.y === minScale) return
-        //   if (newScale.x === minScale && newScale.z === minScale) return
-        //   if (newScale.y === minScale && newScale.z === minScale) return
-        // }
-        object.scale.copy(newScale); // 或者 object.scale.applyMatrix4(scaleMatrix)
-        startPoint.position.copy(planeIntersection);
-        this.hooks.emit('scaleUpdate', { matrix4: scaleMatrix, helperOrigin: planeCenter });
-        // 移动位置
-        if (referencePosition) {
-            const ewMoveScale = this.startInfo.ewMoveIsNegative ? negateScale(ewScale) : ewScale;
-            const nsMoveScale = this.startInfo.nsMoveIsNegative ? negateScale(nsScale) : nsScale;
-            const moveScale = (() => {
-                switch (direction) {
-                    case 'ew':
-                        return ewMoveScale;
-                    case 'ns':
-                        return nsMoveScale;
-                    case 'nesw':
-                    case 'nwse':
-                        return new Vector3().multiplyVectors(ewMoveScale, nsMoveScale);
+        const setNSScale = () => {
+            const offset = nsOffset;
+            this.helperObject3D.cornerPositions.forEach((position, index) => {
+                var _a;
+                if ((_a = this.startInfo) === null || _a === void 0 ? void 0 : _a.dragPointInCenterBottom) {
+                    if (index === 0 || index === 1)
+                        position.add(offset); // 拖下边，只改下边点
+                }
+                else {
+                    if (index === 2 || index === 3)
+                        position.add(offset); // 拖上边，只改上边点
                 }
-            })();
-            const halfMoveScale = moveScale.clone().sub(new Vector3(1, 1, 1)).multiplyScalar(0.5).add(new Vector3(1, 1, 1));
-            const objectPosition = object.position.clone();
-            const newPosition = new Vector3()
-                .subVectors(objectPosition, referencePosition)
-                .multiply(halfMoveScale)
-                .add(referencePosition)
-                .sub(objectPosition);
-            const transform = new THREE.Matrix4().setPosition(newPosition);
-            object.applyMatrix4(transform);
-            this.hooks.emit('positionUpdate', { matrix4: transform });
+            });
+        };
+        switch (direction) {
+            case 'ew':
+                setEWScale();
+                break;
+            case 'ns':
+                setNSScale();
+                break;
+            case 'nesw':
+            case 'nwse':
+                setEWScale();
+                setNSScale();
         }
-        this.needsRender();
+        // this.helperObject3D.cornerPositions.forEach((position, index) => {
+        //   this.scene.add(getPoint(position, index))
+        // })
+        const scaleX = new Vector3().subVectors(cornerPositions[1], cornerPositions[0]).length() / ewVector.length();
+        const scaleY = new Vector3().subVectors(cornerPositions[3], cornerPositions[0]).length() / nsVector.length();
+        const scaleXY = new Vector3(scaleX, scaleY, 1);
+        console.log(scaleXY);
+        const scaleMatrix = new THREE.Matrix4().scale(scaleXY);
+        // const newScale = object.scale.clone().applyMatrix4(scaleMatrix)
+        // object.scale.copy(newScale) // 或者 object.scale.applyMatrix4(scaleMatrix)
+        object.scale.applyMatrix4(scaleMatrix);
+        startPoint.position.copy(planeIntersection);
+        // =================================================================================================================================================================
+        // =================================================================================================================================================================
+        // 移动位置
+        const centerPosition = new Vector3().addVectors(cornerPositions[0], cornerPositions[2]).divideScalar(2);
+        const offset = new Vector3().subVectors(centerPosition, planeCenter);
+        const transformMatrix4 = new THREE.Matrix4().setPosition(offset);
+        object.applyMatrix4(transformMatrix4);
+        (_a = this.helperObject3D.css3DInstance) === null || _a === void 0 ? void 0 : _a.css3DObject.applyMatrix4(transformMatrix4);
+        (_b = this.helperObject3D.plane) === null || _b === void 0 ? void 0 : _b.applyMatrix4(transformMatrix4);
+        this.hooks.emit('scaleUpdate', { matrix4: scaleMatrix, helperOrigin: planeCenter });
+        this.hooks.emit('positionUpdate', { matrix4: transformMatrix4 });
+        // 移动位置end
+        // this.helperObject3D.cornerPositions.forEach((position, index) => {
+        //   this.scene.add(getPoint(position, index))
+        // })
+        this.render();
     }
     dragEnd() {
         if (!this.isDragging)
@@ -183,7 +193,7 @@ export class RectangleScaleController extends BaseController {
         this.startInfo = undefined;
         this.isDragging = false;
         this.hooks.emit('scaleEnd');
-        this.needsRender();
+        this.render();
         console.log('%c RectangleScaleController dragEnd', 'color: #e94e4e');
     }
 }

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

@@ -4,9 +4,9 @@ export declare class RotateController<T extends RotateHelperAbstract = RotateHel
     private startInfo?;
     private lastRotation?;
     private rotations;
-    private a;
     private helperObject3DQuaternion;
     constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    initialHelperQuaternion(): void;
     /**
      * @description: 拖动开始，找出拖的Direction
      */

package/libs/shared-utils/Object3DHelper/Controller/RotateController.js

@@ -1,7 +1,6 @@
 import { BaseController } from '../Base/BaseController';
 import * as THREE from 'three';
 import { getMouseRaycaster } from '../utils';
-import '../utils/getPoint';
 export class RotateController extends BaseController {
     constructor(...params) {
         super(...params);
@@ -23,17 +22,11 @@ export class RotateController extends BaseController {
             writable: true,
             value: []
         });
-        Object.defineProperty(this, "a", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "helperObject3DQuaternion", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: this.helperObject3D.quaternion.clone()
+            value: this.originObject3D.quaternion.clone()
         });
         // add hover listener
         const helper = this.helperObject3D;
@@ -45,6 +38,10 @@ export class RotateController extends BaseController {
         document.addEventListener('mousemove', dragging);
         document.addEventListener('mouseup', dragEnd);
     }
+    initialHelperQuaternion() {
+        this.helperObject3D.updateAngleHelperQuaternion();
+        this.helperObject3D.applyHelperQuaternion(this.originObject3D.quaternion);
+    }
     /**
      * @description: 拖动开始，找出拖的Direction
      */
@@ -69,9 +66,9 @@ export class RotateController extends BaseController {
         this.setTipsPosition(tipsPosition);
         // end
         // init plane
-        const directionX = new THREE.Vector3(1, 0, 0).applyQuaternion(this.helperObject3DQuaternion.clone());
-        const directionY = new THREE.Vector3(0, 1, 0).applyQuaternion(this.helperObject3DQuaternion.clone());
-        const directionZ = new THREE.Vector3(0, 0, 1).applyQuaternion(this.helperObject3DQuaternion.clone());
+        const directionX = new THREE.Vector3(1, 0, 0).applyQuaternion(this.helperObject3DQuaternion);
+        const directionY = new THREE.Vector3(0, 1, 0).applyQuaternion(this.helperObject3DQuaternion);
+        const directionZ = new THREE.Vector3(0, 0, 1).applyQuaternion(this.helperObject3DQuaternion);
         const directionVector = (() => {
             switch (direction) {
                 case 'x':
@@ -83,6 +80,10 @@ export class RotateController extends BaseController {
             }
         })();
         const plane = new THREE.Plane().setFromNormalAndCoplanarPoint(directionVector, startIntersect);
+        // this.a && this.scene.remove(this.a)
+        // const h = new THREE.PlaneHelper(plane, 1)
+        // this.scene.add(h)
+        // this.a = h
         // end
         // init startVectorProject
         const projectPoint = new THREE.Vector3();
@@ -100,7 +101,7 @@ export class RotateController extends BaseController {
         // this.a = new THREE.PlaneHelper(plane, 10, 0xffff00)
         // this.scene.add(this.a)
         this.startInfo = { direction, startVector, staticStartVector, plane, angleHelper };
-        this.helperObject3D.show(direction);
+        this.helperObject3D.showDraggingHelper([direction]);
         this.hooks.emit('rotateStart');
         this.isDragging = true;
         console.log(`%c RotateController dragStart ${direction}`, 'color: #e5af2e');
@@ -190,7 +191,7 @@ export class RotateController extends BaseController {
         // end
         const quaternion = new THREE.Quaternion().setFromUnitVectors(startVector.clone().normalize(), currentVector.clone().normalize());
         object.applyQuaternion(quaternion);
-        this.helperObject3D.updateQuaternion(quaternion);
+        this.helperObject3D.applyHelperQuaternion(quaternion);
         this.helperObject3DQuaternion.premultiply(quaternion);
         this.hooks.emit('rotateUpdate', { quaternion, origin: rotateCenter });
         this.startInfo.startVector = currentVector;

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

@@ -7,7 +7,7 @@ export declare class MoveHelper extends MoveHelperAbstract {
     yArrow: ArrowGroup;
     zArrow: ArrowGroup;
     constructor(originObject3D: Object3D);
-    hide(...directions: Direction[]): void;
-    show(direction?: Direction): void;
+    show(): void;
+    showDraggingHelper(directions: Direction[]): void;
     dispose(): void;
 }

package/libs/shared-utils/Object3DHelper/Helper/MoveHelper.js

@@ -26,29 +26,16 @@ export class MoveHelper extends MoveHelperAbstract {
         this.add(this.yArrow);
         this.add(this.zArrow);
     }
-    hide(...directions) {
-        if (directions.length === 0) {
-            this.xArrow.visible = false;
-            this.yArrow.visible = false;
-            this.zArrow.visible = false;
-        }
-        else {
-            directions.forEach((direction) => {
-                const arrow = [this.xArrow, this.yArrow, this.zArrow].find((arrow) => arrow.direction === direction);
-                arrow && (arrow.visible = false);
-            });
-        }
+    show() {
+        super.show();
+        this.xArrow.visible = true;
+        this.yArrow.visible = true;
+        this.zArrow.visible = true;
     }
-    show(direction) {
-        if (!direction) {
-            this.xArrow.visible = true;
-            this.yArrow.visible = true;
-            this.zArrow.visible = true;
-        }
-        else {
-            const arrow = [this.xArrow, this.yArrow, this.zArrow].find((arrow) => arrow.direction === direction);
-            arrow && (arrow.visible = true);
-        }
+    showDraggingHelper(directions) {
+        this.xArrow.visible = directions.includes('x');
+        this.yArrow.visible = directions.includes('y');
+        this.zArrow.visible = directions.includes('z');
     }
     dispose() {
         this.remove(this.xArrow, this.yArrow, this.zArrow);

package/libs/shared-utils/Object3DHelper/Helper/RectangleScaleHelper.d.ts

@@ -11,22 +11,23 @@ export declare class RectangleScaleHelper<T extends OriginObjectType = OriginObj
     cornerPositions: Vector3[];
     css3DInstance?: NonVoid<Create3DElementReturnType>;
     get helperObject(): CSS3DObjectPlus<HTMLElement>;
+    plane?: THREE.Mesh<THREE.PlaneGeometry, THREE.MeshBasicMaterial>;
     private css3DRenderer;
-    private plane?;
     private camera;
     private scene;
     private container;
     private enabled;
     constructor(originObject3D: T, container: Element, camera: THREE.Camera, scene: THREE.Scene);
     updatePosition(): void;
-    setPosition(position: Vector3): void;
-    updateMatrix4(matrix: THREE.Matrix4): void;
-    setHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
+    updateQuaternion(): void;
+    applyMatrix4(matrix: THREE.Matrix4): void;
+    showDraggingHelper(): void;
+    applyHelperScaleMatrix4(matrix: THREE.Matrix4, params?: {
         origin?: Vector3;
         helperOrigin?: Vector3;
     }): void;
     updatePoints(): void;
-    updateQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin: THREE.Vector3): void;
     enable(): void;
     disable(): void;
     show(): void;

package/libs/shared-utils/Object3DHelper/Helper/RectangleScaleHelper.js

@@ -4,6 +4,7 @@ import { RectangleScaleHelperAbstract } from '.';
 import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
 import { rectangleScaleDom } from './HTML/rectangleScaleDom';
 import { CSS3DObjectPlus } from '../../../CSS3DRenderPlugin/utils/CSS3DObjectPlus';
+import '../utils/getPoint';
 export class RectangleScaleHelper extends RectangleScaleHelperAbstract {
     constructor(originObject3D, container, camera, scene) {
         super(originObject3D);
@@ -25,17 +26,17 @@ export class RectangleScaleHelper extends RectangleScaleHelperAbstract {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "css3DRenderer", {
+        Object.defineProperty(this, "plane", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new CSS3DRender()
+            value: void 0
         });
-        Object.defineProperty(this, "plane", {
+        Object.defineProperty(this, "css3DRenderer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: new CSS3DRender()
         });
         Object.defineProperty(this, "camera", {
             enumerable: true,
@@ -77,28 +78,27 @@ export class RectangleScaleHelper extends RectangleScaleHelperAbstract {
         (_a = this.css3DInstance) === null || _a === void 0 ? void 0 : _a.css3DObject.position.copy(this.originObject3D.position);
         (_b = this.plane) === null || _b === void 0 ? void 0 : _b.position.copy(this.originObject3D.position);
     }
-    setPosition(position) {
-        var _a, _b;
-        (_a = this.css3DInstance) === null || _a === void 0 ? void 0 : _a.css3DObject.position.copy(position);
-        (_b = this.plane) === null || _b === void 0 ? void 0 : _b.position.copy(position);
+    updateQuaternion() {
+        var _a;
+        (_a = this.plane) === null || _a === void 0 ? void 0 : _a.quaternion.copy(this.originObject3D.quaternion);
     }
-    updateMatrix4(matrix) {
+    // public setPosition(position: Vector3) {
+    //   this.css3DInstance?.css3DObject.position.copy(position)
+    //   this.plane?.position.copy(position)
+    // }
+    applyMatrix4(matrix) {
         var _a, _b;
         (_a = this.css3DInstance) === null || _a === void 0 ? void 0 : _a.css3DObject.applyMatrix4(matrix);
         (_b = this.plane) === null || _b === void 0 ? void 0 : _b.applyMatrix4(matrix);
         this.cornerPositions.forEach((cornerPosition) => cornerPosition.applyMatrix4(matrix));
     }
-    setHelperScaleMatrix4(matrix, params) {
+    showDraggingHelper() {
+        // nothing to do
+    }
+    applyHelperScaleMatrix4(matrix, params) {
         var _a, _b;
         (_a = this.css3DInstance) === null || _a === void 0 ? void 0 : _a.css3DObject.scale.applyMatrix4(matrix);
         (_b = this.plane) === null || _b === void 0 ? void 0 : _b.scale.applyMatrix4(matrix);
-        const { origin, helperOrigin } = params !== null && params !== void 0 ? params : {};
-        if (!helperOrigin)
-            return;
-        this.cornerPositions.forEach((position) => {
-            position.subVectors(position, helperOrigin).applyMatrix4(matrix).add(helperOrigin);
-        });
-        this.updatePoints();
     }
     updatePoints() {
         const position8 = this.calculatePointPosition(this.cornerPositions);
@@ -106,7 +106,7 @@ export class RectangleScaleHelper extends RectangleScaleHelperAbstract {
             point.position.copy(position8[index]);
         });
     }
-    updateQuaternion(quaternion, origin) {
+    applyHelperQuaternion(quaternion, origin) {
         var _a;
         const css3DObject = (_a = this.css3DInstance) === null || _a === void 0 ? void 0 : _a.css3DObject;
         if (css3DObject) {

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

@@ -19,9 +19,10 @@ export declare class RotateHelper extends RotateHelperAbstract {
         container: HTMLElement;
     });
     updateAngleHelperQuaternion(): void;
-    updateQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
+    applyHelperQuaternion(quaternion: THREE.Quaternion, origin?: THREE.Vector3): void;
     hide(): void;
-    show(direction?: Direction): void;
+    show(): void;
+    showDraggingHelper(directions: Direction[]): void;
     dispose(): void;
     private filterRingHelper;
     private filterAngleHelper;

package/libs/shared-utils/Object3DHelper/Helper/RotateHelper.js

@@ -87,7 +87,7 @@ export class RotateHelper extends RotateHelperAbstract {
         this.yRingHelper.quaternion.copy(this.xzCircle.quaternion);
         this.zRingHelper.quaternion.copy(this.xyCircle.quaternion);
     }
-    updateQuaternion(quaternion, origin) {
+    applyHelperQuaternion(quaternion, origin) {
         this.yzCircle.applyQuaternion(quaternion);
         this.xzCircle.applyQuaternion(quaternion);
         this.xyCircle.applyQuaternion(quaternion);
@@ -96,21 +96,21 @@ export class RotateHelper extends RotateHelperAbstract {
         this.zAngleHelper.baseAxes.applyQuaternion(quaternion);
     }
     hide() {
+        // 改为remove而不是设置visible，是因为会影响其他helper的碰撞检测
         this.remove(this.yzCircle, this.xzCircle, this.xyCircle, this.xRingHelper, this.yRingHelper, this.zRingHelper, this.xAngleHelper, this.yAngleHelper, this.zAngleHelper);
     }
-    show(direction) {
-        var _a, _b;
-        if (direction) {
-            this.hide();
-            this.add(...this.filterRingHelper(direction));
-            this.add(...this.filterAngleHelper(direction));
-            (_a = this.angleTips) === null || _a === void 0 ? void 0 : _a.show();
-        }
-        else {
-            this.add(this.xyCircle, this.xzCircle, this.yzCircle);
-            this.remove(this.xRingHelper, this.yRingHelper, this.zRingHelper, this.xAngleHelper, this.yAngleHelper, this.zAngleHelper);
-            (_b = this.angleTips) === null || _b === void 0 ? void 0 : _b.hide();
-        }
+    show() {
+        var _a;
+        this.add(this.xyCircle, this.xzCircle, this.yzCircle);
+        this.remove(this.xRingHelper, this.yRingHelper, this.zRingHelper, this.xAngleHelper, this.yAngleHelper, this.zAngleHelper);
+        (_a = this.angleTips) === null || _a === void 0 ? void 0 : _a.hide();
+    }
+    showDraggingHelper(directions) {
+        var _a;
+        this.hide();
+        this.add(...this.filterRingHelper(directions));
+        this.add(...this.filterAngleHelper(directions));
+        (_a = this.angleTips) === null || _a === void 0 ? void 0 : _a.show();
     }
     dispose() {
         var _a, _b;
@@ -118,11 +118,11 @@ export class RotateHelper extends RotateHelperAbstract {
         if ((_a = this.angleTips) === null || _a === void 0 ? void 0 : _a.element)
             (_b = this.container) === null || _b === void 0 ? void 0 : _b.removeChild(this.angleTips.element);
     }
-    filterRingHelper(direction) {
-        return [this.xRingHelper, this.yRingHelper, this.zRingHelper].filter((helper) => helper.direction === direction);
+    filterRingHelper(directions) {
+        return [this.xRingHelper, this.yRingHelper, this.zRingHelper].filter((helper) => directions.includes(helper.direction));
     }
-    filterAngleHelper(direction) {
-        return [this.xAngleHelper, this.yAngleHelper, this.zAngleHelper].filter((helper) => helper.direction === direction);
+    filterAngleHelper(directions) {
+        return [this.xAngleHelper, this.yAngleHelper, this.zAngleHelper].filter((helper) => directions.includes(helper.direction));
     }
 }
 class Circle extends THREE.Mesh {

package/libs/shared-utils/Object3DHelper/index.d.ts

@@ -1,5 +1,5 @@
 import type { OutlineHelper } from './Helper';
-import type { EventMap, State } from './typings';
+import type { Object3DHelperEventMap, Object3DHelperState } from './typings';
 import type { MoveController } from './Controller/MoveController';
 import type { RotateController } from './Controller/RotateController';
 import type { BaseController } from './Base/BaseController';
@@ -14,8 +14,8 @@ interface Helpers {
 }
 export declare class Object3DHelper {
     controllers: Controllers;
-    state: State;
-    hooks: Subscribe<EventMap>;
+    state: Object3DHelperState;
+    hooks: Subscribe<Object3DHelperEventMap>;
     private helpers;
     private eventListener;
     constructor(controllers?: Controllers, helpers?: Helpers);
@@ -47,16 +47,14 @@ export declare class Object3DHelper {
      * @description Dispose
      */
     dispose(): void;
-    setState(state: Partial<State>, options?: {
+    setState(state: Partial<Object3DHelperState>, options?: {
         userAction?: boolean;
     } & Record<string, any>): void;
-    addControllers(controllers: Partial<{
-        [K in keyof Controllers]: Controllers[K];
-    }>): void;
+    addControllers(controllers: Controllers): void;
     addHelpers(helpers: Partial<{
         [K in keyof Helpers]: Helpers[K];
     }>): void;
-    getCurrentState(): State;
+    getCurrentState(): Object3DHelperState;
     private addEventListener;
     private handleEnd;
     private handleStart;