@realsee/dnalogel 2.0.2-alpha → 2.2.0-alpha.1

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

@@ -0,0 +1,246 @@
+import * as THREE from 'three';
+import { RotateHelperAbstract } from '../Base/BaseHelper';
+import { AXES_THREE_COLOR } from '../Constants/color';
+import { tipsDom } from './HTML/tipsDom';
+export class RotateHelper extends RotateHelperAbstract {
+    constructor(originObject3D, angleTipsParams) {
+        var _a;
+        super(originObject3D);
+        Object.defineProperty(this, "yzCircle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Circle({ direction: 'x', color: AXES_THREE_COLOR.X })
+        });
+        Object.defineProperty(this, "xzCircle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Circle({ direction: 'y', color: AXES_THREE_COLOR.Y })
+        });
+        Object.defineProperty(this, "xyCircle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Circle({ direction: 'z', color: AXES_THREE_COLOR.Z })
+        });
+        Object.defineProperty(this, "xRingHelper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AxesDashedRing({ direction: 'x' })
+        });
+        Object.defineProperty(this, "yRingHelper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AxesDashedRing({ direction: 'y' })
+        });
+        Object.defineProperty(this, "zRingHelper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AxesDashedRing({ direction: 'z' })
+        });
+        Object.defineProperty(this, "xAngleHelper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Sector({ direction: 'x', color: AXES_THREE_COLOR.X })
+        });
+        Object.defineProperty(this, "yAngleHelper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Sector({ direction: 'y', color: AXES_THREE_COLOR.Y })
+        });
+        Object.defineProperty(this, "zAngleHelper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Sector({ direction: 'z', color: AXES_THREE_COLOR.Z })
+        });
+        Object.defineProperty(this, "angleTips", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "container", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (angleTipsParams) {
+            this.container = angleTipsParams === null || angleTipsParams === void 0 ? void 0 : angleTipsParams.container;
+            this.angleTips = tipsDom({ display: 'none' });
+            (_a = this.container) === null || _a === void 0 ? void 0 : _a.appendChild(this.angleTips.element);
+        }
+        this.show();
+    }
+    updateAngleHelperQuaternion() {
+        this.xAngleHelper.quaternion.copy(this.yzCircle.quaternion);
+        this.yAngleHelper.quaternion.copy(this.xzCircle.quaternion);
+        this.zAngleHelper.quaternion.copy(this.xyCircle.quaternion);
+        this.xRingHelper.quaternion.copy(this.yzCircle.quaternion);
+        this.yRingHelper.quaternion.copy(this.xzCircle.quaternion);
+        this.zRingHelper.quaternion.copy(this.xyCircle.quaternion);
+    }
+    updateQuaternion(quaternion, origin) {
+        this.yzCircle.applyQuaternion(quaternion);
+        this.xzCircle.applyQuaternion(quaternion);
+        this.xyCircle.applyQuaternion(quaternion);
+        this.xAngleHelper.baseAxes.applyQuaternion(quaternion);
+        this.yAngleHelper.baseAxes.applyQuaternion(quaternion);
+        this.zAngleHelper.baseAxes.applyQuaternion(quaternion);
+    }
+    hide() {
+        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();
+        }
+    }
+    dispose() {
+        var _a, _b;
+        this.remove(this.yzCircle, this.xzCircle, this.xyCircle, this.xRingHelper, this.yRingHelper, this.zRingHelper, this.xAngleHelper, this.yAngleHelper, this.zAngleHelper);
+        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);
+    }
+    filterAngleHelper(direction) {
+        return [this.xAngleHelper, this.yAngleHelper, this.zAngleHelper].filter((helper) => helper.direction === direction);
+    }
+}
+class Circle extends THREE.Mesh {
+    constructor(options) {
+        var _a;
+        super();
+        Object.defineProperty(this, "direction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gapAngle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.02
+        });
+        Object.defineProperty(this, "geometry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new THREE.RingGeometry(0.25, 0.3, 20, 8, this.gapAngle, Math.PI / 2 - this.gapAngle * 2)
+        });
+        this.material = new THREE.MeshBasicMaterial({
+            opacity: 0.6,
+            color: (_a = options.color) !== null && _a !== void 0 ? _a : 0xffffff,
+            depthTest: false,
+            transparent: true,
+            side: THREE.DoubleSide,
+        });
+        this.direction = options.direction;
+        this.geometry.name = `RotateHelperCircleGeometry-${this.direction}`;
+        // this.renderOrder = 20
+        if (this.direction === 'y') {
+            this.rotateX(Math.PI / 2);
+        }
+        else if (this.direction === 'x') {
+            this.rotateY(-Math.PI / 2);
+        }
+    }
+}
+class AxesDashedRing extends THREE.Group {
+    constructor(options) {
+        super();
+        Object.defineProperty(this, "direction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.direction = options.direction;
+        const gapAngle = 0.015;
+        const meshes = new Array(8).fill(null).map((_, i) => {
+            const geometry = new THREE.RingGeometry(0.25, 0.3, 20, 8, (Math.PI / 4) * i + gapAngle, Math.PI / 4 - gapAngle * 2);
+            const material = new THREE.MeshBasicMaterial({
+                opacity: 1,
+                color: 0xffffff,
+                depthTest: false,
+                transparent: true,
+                side: THREE.DoubleSide,
+            });
+            const mesh = new THREE.Mesh(geometry, material);
+            mesh.name = `AxesDashedRing-${this.direction}-${i}`;
+            return mesh;
+        });
+        this.add(...meshes);
+        if (this.direction === 'y') {
+            this.rotateX(Math.PI / 2);
+        }
+        else if (this.direction === 'x') {
+            this.rotateY(-Math.PI / 2);
+        }
+    }
+}
+class Sector extends THREE.Mesh {
+    constructor(options) {
+        var _a;
+        super();
+        Object.defineProperty(this, "direction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "baseAxes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        switch (options.direction) {
+            case 'x':
+                this.baseAxes = new THREE.Vector3(0, 0, 1);
+                break;
+            case 'y':
+                this.baseAxes = new THREE.Vector3(1, 0, 0);
+                break;
+            case 'z':
+                this.baseAxes = new THREE.Vector3(1, 0, 0);
+                break;
+        }
+        const ratio = 0.3 + 0.0005; // 挡住白色圆环的锯齿
+        this.geometry = new THREE.CircleGeometry(ratio, 48, 0, 0.0001);
+        this.material = new THREE.MeshBasicMaterial({
+            opacity: 0.4,
+            color: (_a = options.color) !== null && _a !== void 0 ? _a : 0xffffff,
+            depthTest: false,
+            transparent: true,
+            side: THREE.DoubleSide,
+        });
+        this.direction = options.direction;
+        // this.renderOrder = 20
+        if (this.direction === 'y') {
+            this.rotateX(Math.PI / 2);
+        }
+        else if (this.direction === 'x') {
+            this.rotateY(-Math.PI / 2);
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+export * from '../Base/BaseHelper';
+export * from './MoveHelper';
+export * from './RotateHelper';
+export * from './RectangleScaleHelper';
+export * from './OutlineHelper';

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

@@ -0,0 +1,5 @@
+export * from '../Base/BaseHelper';
+export * from './MoveHelper';
+export * from './RotateHelper';
+export * from './RectangleScaleHelper';
+export * from './OutlineHelper';

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

@@ -0,0 +1,73 @@
+import type { OutlineHelper } from './Helper';
+import type { EventMap, State } from './typings';
+import type { MoveController } from './Controller/MoveController';
+import type { RotateController } from './Controller/RotateController';
+import type { BaseController } from './Base/BaseController';
+import { Subscribe } from '../Subscribe';
+interface Controllers {
+    moveController?: MoveController;
+    rotateController?: RotateController;
+    scaleController?: BaseController;
+}
+interface Helpers {
+    outlineHelper?: OutlineHelper;
+}
+export declare class Object3DHelper {
+    controllers: Controllers;
+    state: State;
+    hooks: Subscribe<EventMap>;
+    private helpers;
+    private eventListener;
+    constructor(controllers?: Controllers, helpers?: Helpers);
+    /**
+     * @description Show guide line
+     */
+    show(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Hide guide line
+     */
+    hide(options?: {
+        userAction?: boolean;
+    }): Promise<void>;
+    /**
+     * @description Enable
+     */
+    enable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Disable
+     */
+    disable(options?: {
+        userAction?: boolean;
+    }): void;
+    /**
+     * @description Dispose
+     */
+    dispose(): void;
+    setState(state: Partial<State>, options?: {
+        userAction?: boolean;
+    } & Record<string, any>): void;
+    addControllers(controllers: Partial<{
+        [K in keyof Controllers]: Controllers[K];
+    }>): void;
+    addHelpers(helpers: Partial<{
+        [K in keyof Helpers]: Helpers[K];
+    }>): void;
+    getCurrentState(): State;
+    private addEventListener;
+    private handleEnd;
+    private handleStart;
+    private setOtherHelpersVisible;
+    private handlePositionUpdate;
+    private handleScaleUpdate;
+    private handleRotateUpdate;
+    private handleEnable;
+    private handleVisible;
+    private everyControllerDo;
+    private handleDispose;
+    private actionIfStateIsEnabled;
+}
+export {};

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

@@ -0,0 +1,280 @@
+import { Subscribe } from '../Subscribe';
+const VERSION = 'v1.0.0';
+const NAME = 'Object3DHelper';
+const NAMEVERSION = `${NAME}@${VERSION}`;
+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: void 0
+        });
+        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, _e, _f, _g, _h;
+                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.setHelperMatrix4(matrix4);
+                    if (controller !== this.controllers.rotateController)
+                        (_b = this.controllers.rotateController) === null || _b === void 0 ? void 0 : _b.setHelperMatrix4(matrix4);
+                    (_c = this.controllers.scaleController) === null || _c === void 0 ? void 0 : _c.setHelperMatrix4(matrix4);
+                    (_d = this.helpers.outlineHelper) === null || _d === void 0 ? void 0 : _d.applyMatrix4(matrix4);
+                }
+                if (position === null || position === void 0 ? void 0 : position.position) {
+                    if (controller !== this.controllers.moveController)
+                        (_e = this.controllers.moveController) === null || _e === void 0 ? void 0 : _e.setHelperPosition(position.position);
+                    if (controller !== this.controllers.rotateController)
+                        (_f = this.controllers.rotateController) === null || _f === void 0 ? void 0 : _f.setHelperPosition(position.position);
+                    (_g = this.controllers.scaleController) === null || _g === void 0 ? void 0 : _g.setHelperPosition(position.position);
+                    (_h = this.helpers.outlineHelper) === null || _h === void 0 ? void 0 : _h.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.setHelperScaleMatrix4(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.setHelperQuaternion(quaternion, origin);
+                        if (controller !== this.controllers.rotateController)
+                            (_b = this.controllers.rotateController) === null || _b === void 0 ? void 0 : _b.setHelperQuaternion(quaternion, origin);
+                        if (controller !== this.controllers.scaleController)
+                            (_c = this.controllers.scaleController) === null || _c === void 0 ? void 0 : _c.setHelperQuaternion(quaternion, origin);
+                        (_d = this.helpers.outlineHelper) === null || _d === void 0 ? void 0 : _d.applyQuaternion(quaternion);
+                    }
+                }
+            }
+        });
+        this.controllers = controllers !== null && controllers !== void 0 ? controllers : {};
+        this.helpers = helpers !== null && helpers !== void 0 ? helpers : {};
+    }
+    /**
+     * @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 && state.visible !== prevState.visible) {
+            this.handleVisible(state.visible);
+        }
+        if (state.enabled !== undefined && state.enabled !== prevState.enabled) {
+            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();
+    }
+    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) {
+        console.log({ enabled });
+        if (enabled) {
+            this.everyControllerDo((controller) => controller.enable());
+            this.hooks.emit('enable', { userAction });
+        }
+        else {
+            this.everyControllerDo((controller) => controller.disable());
+            this.hooks.emit('disable', { userAction });
+        }
+        this.state.enabled = enabled;
+    }
+    handleVisible(visible, userAction = true) {
+        console.log({ visible });
+        if (visible) {
+            this.everyControllerDo((controller) => controller.show());
+            this.actionIfStateIsEnabled(() => this.hooks.emit('show', { userAction }));
+        }
+        else {
+            this.everyControllerDo((controller) => controller.hide());
+            this.actionIfStateIsEnabled(() => this.hooks.emit('hide', { userAction }));
+        }
+        this.state.visible = visible;
+    }
+    everyControllerDo(func) {
+        Object.values(this.controllers).forEach((controller) => {
+            if (controller)
+                func(controller);
+        });
+    }
+    handleDispose() {
+        Object.values(this.controllers).forEach((controller) => {
+            controller === null || controller === void 0 ? void 0 : controller.dispose();
+        });
+    }
+    actionIfStateIsEnabled(func, options) {
+        if (this.state.enabled)
+            return func();
+        else {
+            if (options === null || options === void 0 ? void 0 : options.warnLog)
+                disableWarnLog();
+        }
+    }
+}

package/libs/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/shared-utils/Object3DHelper/typings/Direction.js

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

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

@@ -0,0 +1,46 @@
+import type * as THREE from 'three';
+export declare type HelperEventMap = {
+    moveStart: () => void;
+    rotateStart: () => void;
+    scaleStart: () => void;
+    positionUpdate: (position: {
+        matrix4?: THREE.Matrix4;
+        position?: THREE.Vector3;
+    } | 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 State {
+    enabled: boolean;
+    visible: boolean;
+    disposed: boolean;
+}
+export declare type EventMap = {
+    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: State;
+        prevState?: State;
+    }) => void;
+};

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

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

package/libs/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/shared-utils/Object3DHelper/typings/Scissor.js

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