@realsee/dnalogel 2.1.0-alpha.13 → 2.1.0-alpha.15

package/libs/src/shared-utils/Object3DHelper/index.js

@@ -0,0 +1,301 @@
+import { Subscribe } from '../Subscribe';
+const VERSION = 'v1.0.1';
+const NAME = 'Object3DHelper';
+const NAMEVERSION = `${NAME}@${VERSION}`;
+const OBJECT_OPACITY = 0.4;
+const disposedErrorLog = () => {
+    console.error(`${NAMEVERSION} is disposed`);
+};
+const disableWarnLog = () => {
+    console.warn(`${NAMEVERSION} is disabled`);
+};
+const disableErrorLog = () => {
+    console.error(`${NAMEVERSION} is disabled`);
+};
+export class Object3DHelper {
+    constructor(controllers, helpers) {
+        Object.defineProperty(this, "controllers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                visible: true,
+                enabled: true,
+                disposed: false,
+            }
+        });
+        Object.defineProperty(this, "hooks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Subscribe()
+        });
+        Object.defineProperty(this, "helpers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "eventListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "handlePositionUpdate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (controller, ...positionParams) => {
+                var _a, _b, _c, _d;
+                const [position] = positionParams;
+                const matrix4 = position === null || position === void 0 ? void 0 : position.matrix4;
+                if (matrix4) {
+                    if (controller !== this.controllers.moveController)
+                        (_a = this.controllers.moveController) === null || _a === void 0 ? void 0 : _a.applyHelperMatrix4(matrix4);
+                    if (controller !== this.controllers.rotateController)
+                        (_b = this.controllers.rotateController) === null || _b === void 0 ? void 0 : _b.applyHelperMatrix4(matrix4);
+                    if (controller !== this.controllers.scaleController)
+                        (_c = this.controllers.scaleController) === null || _c === void 0 ? void 0 : _c.applyHelperMatrix4(matrix4);
+                    (_d = this.helpers.outlineHelper) === null || _d === void 0 ? void 0 : _d.applyMatrix4(matrix4);
+                }
+                // if (position?.position) {
+                //   if (controller !== this.controllers.moveController) this.controllers.moveController?.setHelperPosition(position.position)
+                //   if (controller !== this.controllers.rotateController) this.controllers.rotateController?.setHelperPosition(position.position)
+                //   this.controllers.scaleController?.setHelperPosition(position.position)
+                //   this.helpers.outlineHelper?.position.copy(position.position)
+                // }
+            }
+        });
+        Object.defineProperty(this, "handleScaleUpdate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (controller, ...positionParams) => {
+                var _a, _b;
+                const [params] = positionParams;
+                const matrix4 = params === null || params === void 0 ? void 0 : params.matrix4;
+                if (matrix4) {
+                    (_a = this.controllers.scaleController) === null || _a === void 0 ? void 0 : _a.applyHelperScaleMatrix4(matrix4, params);
+                    (_b = this.helpers.outlineHelper) === null || _b === void 0 ? void 0 : _b.scale.applyMatrix4(matrix4);
+                }
+            }
+        });
+        Object.defineProperty(this, "handleRotateUpdate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (controller, ...rotateParams) => {
+                var _a, _b, _c, _d;
+                const [rotate] = rotateParams;
+                if (rotate) {
+                    const { quaternion, origin } = rotate;
+                    if (quaternion) {
+                        if (controller !== this.controllers.moveController)
+                            (_a = this.controllers.moveController) === null || _a === void 0 ? void 0 : _a.applyHelperQuaternion(quaternion, origin);
+                        if (controller !== this.controllers.rotateController)
+                            (_b = this.controllers.rotateController) === null || _b === void 0 ? void 0 : _b.applyHelperQuaternion(quaternion, origin);
+                        if (controller !== this.controllers.scaleController)
+                            (_c = this.controllers.scaleController) === null || _c === void 0 ? void 0 : _c.applyHelperQuaternion(quaternion, origin);
+                        (_d = this.helpers.outlineHelper) === null || _d === void 0 ? void 0 : _d.applyQuaternion(quaternion);
+                    }
+                }
+            }
+        });
+        if (controllers)
+            this.addControllers(controllers);
+        this.helpers = helpers !== null && helpers !== void 0 ? helpers : {};
+        this.setState(this.state);
+    }
+    /**
+     * @description Show guide line
+     */
+    async show(options) {
+        this.setState({ visible: true }, options);
+    }
+    /**
+     * @description Hide guide line
+     */
+    async hide(options) {
+        this.setState({ visible: false }, options);
+    }
+    /**
+     * @description Enable
+     */
+    enable(options) {
+        this.setState({ enabled: true }, options);
+    }
+    /**
+     * @description Disable
+     */
+    disable(options) {
+        this.setState({ enabled: false }, options);
+    }
+    /**
+     * @description Dispose
+     */
+    dispose() {
+        this.setState({ disposed: true });
+    }
+    setState(state, options) {
+        if (this.state.disposed)
+            return disposedErrorLog();
+        if (!this.state.enabled) {
+            // when plugin is disabled, only can change enabled or disposed to true
+            if (state.enabled !== true && state.disposed !== true)
+                return disableErrorLog();
+        }
+        const prevState = Object.assign({}, this.state);
+        this.state = Object.assign(Object.assign({}, this.state), state);
+        if (state.disposed !== undefined && state.disposed !== prevState.disposed) {
+            if (state.disposed)
+                this.handleDispose();
+        }
+        if (state.visible !== undefined) {
+            this.handleVisible(state.visible);
+        }
+        if (state.enabled !== undefined) {
+            this.handleEnable(state.enabled);
+        }
+        this.hooks.emit('stateChange', { state: this.state, prevState });
+    }
+    addControllers(controllers) {
+        this.controllers = Object.assign(Object.assign({}, this.controllers), controllers);
+        this.addEventListener();
+        this.setState(this.state);
+    }
+    addHelpers(helpers) {
+        this.helpers = Object.assign(Object.assign({}, this.helpers), helpers);
+    }
+    getCurrentState() {
+        return this.state;
+    }
+    addEventListener() {
+        for (const k in this.controllers) {
+            if (!k)
+                continue;
+            const key = k;
+            if (this.eventListener[key])
+                continue;
+            this.eventListener[key] = (() => {
+                const controller = this.controllers[key];
+                if (!controller)
+                    return;
+                const handleStart = () => this.handleStart(controller);
+                const handleEnd = () => this.handleEnd(controller);
+                const handlePositionUpdate = (...params) => this.handlePositionUpdate(controller, ...params);
+                const handleRotateUpdate = (...params) => this.handleRotateUpdate(controller, ...params);
+                const handleScaleUpdate = (...params) => this.handleScaleUpdate(controller, ...params);
+                controller.hooks.on('moveStart', handleStart);
+                controller.hooks.on('rotateStart', handleStart);
+                controller.hooks.on('scaleStart', handleStart);
+                controller.hooks.on('positionUpdate', handlePositionUpdate);
+                controller.hooks.on('rotateUpdate', handleRotateUpdate);
+                controller.hooks.on('scaleUpdate', handleScaleUpdate);
+                controller.hooks.on('moveEnd', handleEnd);
+                controller.hooks.on('rotateEnd', handleEnd);
+                controller.hooks.on('scaleEnd', handleEnd);
+                return () => {
+                    controller.hooks.off('moveStart', handleStart);
+                    controller.hooks.off('rotateStart', handleStart);
+                    controller.hooks.off('scaleStart', handleStart);
+                    controller.hooks.off('positionUpdate', handlePositionUpdate);
+                    controller.hooks.off('rotateUpdate', handleRotateUpdate);
+                    controller.hooks.off('scaleUpdate', handleScaleUpdate);
+                    controller.hooks.off('moveEnd', handleEnd);
+                    controller.hooks.off('rotateEnd', handleEnd);
+                    controller.hooks.off('scaleEnd', handleEnd);
+                };
+            })();
+        }
+    }
+    handleEnd(controller) {
+        if (controller)
+            this.setOtherHelpersVisible(true, controller);
+    }
+    handleStart(controller) {
+        if (controller)
+            this.setOtherHelpersVisible(false, controller);
+    }
+    setOtherHelpersVisible(visible, currentController) {
+        var _a, _b, _c, _d;
+        if (!visible) {
+            if (currentController !== this.controllers.moveController)
+                (_a = this.controllers.moveController) === null || _a === void 0 ? void 0 : _a.helperObject3D.hide();
+            if (currentController !== this.controllers.rotateController)
+                (_b = this.controllers.rotateController) === null || _b === void 0 ? void 0 : _b.helperObject3D.hide();
+            // if (currentController !== this.controllers.scaleController) this.controllers.scaleController?.helperObject3D.hide()
+        }
+        else {
+            (_c = this.controllers.moveController) === null || _c === void 0 ? void 0 : _c.helperObject3D.show();
+            (_d = this.controllers.rotateController) === null || _d === void 0 ? void 0 : _d.helperObject3D.show();
+        }
+    }
+    handleEnable(enabled, userAction = true) {
+        if (enabled) {
+            this.everyControllerDo((controller) => {
+                controller.enable();
+                controller.setOpacity(OBJECT_OPACITY);
+            });
+            this.hooks.emit('enable', { userAction });
+        }
+        else {
+            this.everyControllerDo((controller) => {
+                controller.disable();
+                controller.restoreOpacity();
+            });
+            this.hooks.emit('disable', { userAction });
+        }
+        this.state.enabled = enabled;
+    }
+    handleVisible(visible, userAction = true) {
+        if (visible) {
+            this.everyControllerDo((controller) => {
+                controller.show();
+                controller.setOpacity(OBJECT_OPACITY);
+            });
+            this.actionIfStateIsEnabled(() => this.hooks.emit('show', { userAction }));
+        }
+        else {
+            this.everyControllerDo((controller) => {
+                controller.hide();
+                controller.restoreOpacity();
+            });
+            this.actionIfStateIsEnabled(() => this.hooks.emit('hide', { userAction }));
+        }
+        this.state.visible = visible;
+    }
+    everyControllerDo(func) {
+        Object.values(this.controllers).forEach((controller) => {
+            if (controller)
+                func(controller);
+        });
+    }
+    handleDispose() {
+        var _a, _b;
+        Object.values(this.controllers).forEach((controller) => {
+            controller === null || controller === void 0 ? void 0 : controller.dispose();
+            controller === null || controller === void 0 ? void 0 : controller.restoreOpacity();
+        });
+        for (const k in this.controllers) {
+            if (!k)
+                continue;
+            const key = k;
+            (_b = (_a = this.eventListener)[key]) === null || _b === void 0 ? void 0 : _b.call(_a);
+        }
+    }
+    actionIfStateIsEnabled(func, options) {
+        if (this.state.enabled)
+            return func();
+        else {
+            if (options === null || options === void 0 ? void 0 : options.warnLog)
+                disableWarnLog();
+        }
+    }
+}

package/libs/src/shared-utils/Object3DHelper/typings/Direction.d.ts

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

package/libs/src/shared-utils/Object3DHelper/typings/Direction.js

@@ -0,0 +1 @@
+export {};

package/libs/src/shared-utils/Object3DHelper/typings/Hooks.d.ts

@@ -0,0 +1,45 @@
+import type * as THREE from 'three';
+export declare type HelperEventMap = {
+    moveStart: () => void;
+    rotateStart: () => void;
+    scaleStart: () => void;
+    positionUpdate: (position: {
+        matrix4?: THREE.Matrix4;
+    } | undefined) => void;
+    rotateUpdate: (rotate: {
+        quaternion?: THREE.Quaternion;
+        origin: THREE.Vector3;
+    } | undefined) => void;
+    scaleUpdate: (scale: {
+        matrix4?: THREE.Matrix4;
+        origin?: THREE.Vector3;
+        helperOrigin: THREE.Vector3;
+    } | undefined) => void;
+    moveEnd: () => void;
+    rotateEnd: () => void;
+    scaleEnd: () => void;
+};
+export interface Object3DHelperState {
+    enabled: boolean;
+    visible: boolean;
+    disposed: boolean;
+}
+export declare type Object3DHelperEventMap = {
+    show: (options?: {
+        userAction?: boolean;
+    }) => void;
+    hide: (options?: {
+        userAction?: boolean;
+    }) => void;
+    enable: (options?: {
+        userAction?: boolean;
+    }) => void;
+    disable: (options?: {
+        userAction?: boolean;
+    }) => void;
+    dispose: () => void;
+    stateChange: (params: {
+        state: Object3DHelperState;
+        prevState?: Object3DHelperState;
+    }) => void;
+};

package/libs/src/shared-utils/Object3DHelper/typings/Hooks.js

@@ -0,0 +1 @@
+export {};

package/libs/src/shared-utils/Object3DHelper/typings/Scissor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 显示区域裁剪参数
+ * @description
+ * 可通过初始化，或者 setScissor 方式设置
+ * `scissor` 是将屏幕中的内容渲染到 `renderer` 的指定区域。
+ * 页面整体长宽均为 `1`。通过类似 css 的 `left` `bottom` `width` `height` 来确定区域。
+ */
+export interface Scissor {
+    /** 距离左侧 */
+    left: number;
+    /** 距离下侧 */
+    bottom: number;
+    /** 宽度 */
+    width: number;
+    /** 高度 */
+    height: number;
+}

package/libs/src/shared-utils/Object3DHelper/typings/Scissor.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+import type * as THREE from 'three';
+export * from './Scissor';
+export * from './Direction';
+export * from './Hooks';
+export declare type Color = THREE.Color | string | number;

package/libs/src/shared-utils/Object3DHelper/typings/index.js

@@ -0,0 +1,3 @@
+export * from './Scissor';
+export * from './Direction';
+export * from './Hooks';

package/libs/src/shared-utils/Object3DHelper/utils/calculateThreeMouse.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+/**
+ * 计算 three 中的 mouse 的值
+ * @param  mouseXY - 鼠标相对屏幕位置
+ * @param  element - canvas元素（three的展示元素）
+ * @param  scissor - 屏幕剪裁
+ */
+export declare function calculateThreeMouse(originMouse: {
+    x: number;
+    y: number;
+}, element: HTMLElement): THREE.Vector2 & {
+    x: number;
+    y: number;
+};

package/libs/src/shared-utils/Object3DHelper/utils/calculateThreeMouse.js

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+/**
+ * 计算 three 中的 mouse 的值
+ * @param  mouseXY - 鼠标相对屏幕位置
+ * @param  element - canvas元素（three的展示元素）
+ * @param  scissor - 屏幕剪裁
+ */
+export function calculateThreeMouse(originMouse, element) {
+    const { offsetWidth: width, offsetHeight: height } = element;
+    const { top, left } = element.getBoundingClientRect();
+    return Object.assign(new THREE.Vector2(), {
+        x: ((originMouse.x - left) / width) * 2 - 1,
+        y: (-(originMouse.y - top) / height) * 2 + 1,
+    });
+}

package/libs/src/shared-utils/Object3DHelper/utils/direction.d.ts

@@ -0,0 +1,14 @@
+import type { Direction } from '../typings';
+import * as THREE from 'three';
+export declare class DirectionGroup extends THREE.Group {
+    direction: Direction;
+    constructor(direction?: Direction);
+}
+export declare class DirectionLine<T extends THREE.Geometry, K extends THREE.Material> extends THREE.Line<T, K> {
+    direction: Direction;
+    constructor(geometry?: T, material?: K, direction?: Direction);
+}
+export declare class DirectionMesh<T extends THREE.Geometry, K extends THREE.Material> extends THREE.Mesh<T, K> {
+    direction: Direction;
+    constructor(geometry?: T, material?: K, direction?: Direction);
+}

package/libs/src/shared-utils/Object3DHelper/utils/direction.js

@@ -0,0 +1,37 @@
+import * as THREE from 'three';
+export class DirectionGroup extends THREE.Group {
+    constructor(direction) {
+        super();
+        Object.defineProperty(this, "direction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.direction = direction || 'x';
+    }
+}
+export class DirectionLine extends THREE.Line {
+    constructor(geometry, material, direction) {
+        super(geometry, material);
+        Object.defineProperty(this, "direction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.direction = direction || 'x';
+    }
+}
+export class DirectionMesh extends THREE.Mesh {
+    constructor(geometry, material, direction) {
+        super(geometry, material);
+        Object.defineProperty(this, "direction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.direction = direction || 'x';
+    }
+}

package/libs/src/shared-utils/Object3DHelper/utils/filterNotColinearPoints.d.ts

@@ -0,0 +1,2 @@
+import type { Vector3 } from 'three';
+export declare function filterNotColinearPoints(positions: Vector3[]): [Vector3, Vector3, Vector3] | void;

package/libs/src/shared-utils/Object3DHelper/utils/filterNotColinearPoints.js

@@ -0,0 +1,20 @@
+import * as THREE from 'three';
+import { vectorIsEqual } from '.';
+export function filterNotColinearPoints(positions) {
+    const vector01 = new THREE.Vector3().subVectors(positions[1], positions[0]).normalize();
+    const result = [];
+    positions.forEach((value, index) => {
+        if (result.length >= 3)
+            return;
+        if (index === 0 || index === 1)
+            return result.push(value);
+        const vector = new THREE.Vector3().subVectors(positions[index], positions[0]).normalize();
+        if (!vectorIsEqual(vector, vector01) && !vectorIsEqual(vector, vector01.clone().negate())) {
+            if (positions.length === 8 && index === 2)
+                console.warn('filterNotColinearPoints: maybe not colinear');
+            return result.push(value);
+        }
+    });
+    if (result.length >= 3)
+        return result;
+}

package/libs/src/shared-utils/Object3DHelper/utils/finiteNumber.d.ts

@@ -0,0 +1 @@
+export default function finiteNumber(value: number | undefined | null | void, defaultValue?: number): number;

package/libs/src/shared-utils/Object3DHelper/utils/finiteNumber.js

@@ -0,0 +1,9 @@
+export default function finiteNumber(value, defaultValue = 0) {
+    if (typeof value === 'undefined' || value === null)
+        return defaultValue;
+    if (typeof value === 'number') {
+        if (Number.isNaN(value) || !Number.isFinite(value))
+            return defaultValue;
+    }
+    return value;
+}

package/libs/src/shared-utils/Object3DHelper/utils/getMouseRaycaster.d.ts

@@ -0,0 +1,5 @@
+import * as THREE from 'three';
+export declare function getMouseRaycaster(camera: THREE.Camera, mouse: {
+    x: number;
+    y: number;
+}, element: HTMLElement): THREE.Raycaster;

package/libs/src/shared-utils/Object3DHelper/utils/getMouseRaycaster.js

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+import { calculateThreeMouse } from '.';
+export function getMouseRaycaster(camera, mouse, element) {
+    if (!mouse || !element || !camera)
+        return;
+    const threeMouse = calculateThreeMouse(mouse, element);
+    if (Math.abs(threeMouse.x) === 1 || Math.abs(threeMouse.y) === 1)
+        return;
+    const raycaster = new THREE.Raycaster();
+    raycaster.setFromCamera(threeMouse, camera);
+    return raycaster;
+}

package/libs/src/shared-utils/Object3DHelper/utils/getPoint.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three';
+export default function getPoint(position?: THREE.Vector3, colorIndex?: number): THREE.Mesh<THREE.SphereGeometry, THREE.MeshBasicMaterial>;
+export declare function getAllMesh(): any[];

package/libs/src/shared-utils/Object3DHelper/utils/getPoint.js

@@ -0,0 +1,22 @@
+import * as THREE from 'three';
+const meshes = [];
+export default function getPoint(position = new THREE.Vector3(1, 1, 1), colorIndex = 0) {
+    const geometry = new THREE.SphereGeometry(0.02, 16, 16);
+    const materials = [
+        new THREE.MeshBasicMaterial({ color: 0xffff00 }),
+        new THREE.MeshBasicMaterial({ color: 0xff00ff }),
+        new THREE.MeshBasicMaterial({ color: 0xff0000 }),
+        new THREE.MeshBasicMaterial({ color: 0x00ffff }), // 蓝
+    ];
+    const material = materials[colorIndex];
+    const sphere = new THREE.Mesh(geometry, material);
+    sphere.material.depthTest = false;
+    sphere.material.transparent = false;
+    sphere.material.side = THREE.DoubleSide;
+    sphere.position.copy(position);
+    meshes.push(sphere);
+    return sphere;
+}
+export function getAllMesh() {
+    return meshes;
+}

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

@@ -0,0 +1,8 @@
+export * from '../../../CSS3DRenderPlugin/utils';
+export * from './direction';
+export * from './calculateThreeMouse';
+export * from './normalPositionToPositions';
+export * from './object3DBoundingPosition';
+export * from './getMouseRaycaster';
+export * from './filterNotColinearPoints';
+export * from './vectorIsEqual';

package/libs/src/shared-utils/Object3DHelper/utils/index.js

@@ -0,0 +1,8 @@
+export * from '../../../CSS3DRenderPlugin/utils';
+export * from './direction';
+export * from './calculateThreeMouse';
+export * from './normalPositionToPositions';
+export * from './object3DBoundingPosition';
+export * from './getMouseRaycaster';
+export * from './filterNotColinearPoints';
+export * from './vectorIsEqual';

package/libs/src/shared-utils/Object3DHelper/utils/negateScale.d.ts

@@ -0,0 +1,2 @@
+import * as THREE from 'three';
+export declare function negateScale(scale: THREE.Vector3): THREE.Vector3;

package/libs/src/shared-utils/Object3DHelper/utils/negateScale.js

@@ -0,0 +1,4 @@
+import * as THREE from 'three';
+export function negateScale(scale) {
+    return scale.clone().sub(new THREE.Vector3(1, 1, 1)).negate().add(new THREE.Vector3(1, 1, 1));
+}

package/libs/src/shared-utils/Object3DHelper/utils/normalPositionToPositions.d.ts

@@ -0,0 +1,5 @@
+import type { Vector3 } from 'three';
+export declare function normalPositionToPositions(cameraPosition: Vector3, position: Vector3, normal: Vector3, config?: {
+    width?: number;
+    height?: number;
+}): [Vector3, Vector3, Vector3, Vector3];

package/libs/src/shared-utils/Object3DHelper/utils/normalPositionToPositions.js

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import '.';
+// eslint-disable-next-line max-params
+export function normalPositionToPositions(cameraPosition, position, normal, config) {
+    const squareHeightHalfSize = ((config === null || config === void 0 ? void 0 : config.height) || 0.01) / 2;
+    const squareWidthHalfSize = ((config === null || config === void 0 ? void 0 : config.width) || 0.01) / 2;
+    const plane = new THREE.Plane().setFromNormalAndCoplanarPoint(normal, position);
+    const right = position.clone().sub(cameraPosition).cross(new THREE.Vector3(0, 1, 0)).setLength(squareWidthHalfSize);
+    const top = new THREE.Vector3(0, squareHeightHalfSize, 0);
+    const positions = [
+        position.clone().sub(right).sub(top),
+        position.clone().add(right).sub(top),
+        position.clone().add(right).add(top),
+        position.clone().sub(right).add(top), // 左上
+    ].map((v) => plane.projectPoint(v, new THREE.Vector3()));
+    return positions;
+}

package/libs/src/shared-utils/Object3DHelper/utils/object3DBoundingPosition.d.ts

@@ -0,0 +1 @@
+export declare function object3DBoundingPosition(): void;

package/libs/src/shared-utils/Object3DHelper/utils/object3DBoundingPosition.js

@@ -0,0 +1 @@
+export function object3DBoundingPosition() { }