@aibee/owlly 1.0.26 → 1.0.29

package/lib/owlly/controller/aerial-element-controller.d.ts

@@ -0,0 +1,65 @@
+import { OrthographicView } from '../view/orthographic-view';
+import { Element } from '../element/element';
+import { Controller } from './controller';
+/**
+ * 俯视图元素控制器, 不应再被维护
+ * @deprecated
+ */
+declare class AerialElementController extends Controller {
+    private controls;
+    private view;
+    private renderFrame;
+    private elements;
+    private target;
+    private enabled;
+    private mouseRatio;
+    private mouseDownRatio;
+    private elementMouseCorrection;
+    private state;
+    private listeners;
+    private targetElement;
+    private elementMovable;
+    private movingNewElement;
+    private intersectables;
+    /**
+     * @param view 平行视图
+     */
+    constructor(view: OrthographicView);
+    /**
+     * 绑定视图到当前控制器
+     * @param view 需要绑定的视图
+     */
+    bindView(view: OrthographicView): void;
+    unbind(): void;
+    /**
+     * @ignore
+     */
+    update(): boolean;
+    private onPointerDown;
+    private onPointerUpOrLeave;
+    private onPointerMove;
+    bindElement(element: Element | Element[]): void;
+    unbindElement(element: Element | Element[]): void;
+    /**
+     * 启用/禁用该控制器
+     * @param enabled 目标值
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 移动目标元素, 调用该函数后目标元素会吸附到鼠标.
+     * 若setElementMovable(false);, 该函数无效.
+     * @param element 需要移动的元素
+     * @returns 需要移除的元素
+     */
+    moveElement(element: Element, isNewElement?: boolean): void;
+    /**
+     * 取消正在移动的元素
+     */
+    cancelMoveElement(): void;
+    /**
+     * 设置是否允许鼠标控制元素移动
+     * @param value 开关值
+     */
+    setElementMovable(value: boolean): void;
+}
+export { AerialElementController };

package/lib/owlly/controller/aerial-element-controller.js

@@ -0,0 +1,235 @@
+import { OrbitControls } from '../../external/orbit-controls';
+import { Externals } from '../stage/externals';
+import { Element } from '../element/element';
+import { Controller } from './controller';
+import { OwllyEvents, Events } from '../utils/events';
+/** @ignore */
+var STATE;
+(function (STATE) {
+    STATE[STATE["IDLE"] = 0] = "IDLE";
+    STATE[STATE["TO_MOVE_ELEMENT"] = 1] = "TO_MOVE_ELEMENT";
+    STATE[STATE["MOVE_ELEMENT"] = 2] = "MOVE_ELEMENT";
+})(STATE || (STATE = {}));
+/**
+ * 俯视图元素控制器, 不应再被维护
+ * @deprecated
+ */
+class AerialElementController extends Controller {
+    /**
+     * @param view 平行视图
+     */
+    constructor(view) {
+        super();
+        const { THREE } = Externals.getInstance();
+        this.elements = new Set();
+        this.enabled = false;
+        this.mouseRatio = new THREE.Vector2();
+        this.mouseDownRatio = new THREE.Vector2();
+        this.elementMouseCorrection = new THREE.Vector3();
+        this.state = STATE.IDLE;
+        this.targetElement = null;
+        this.elementMovable = true;
+        this.listeners = {
+            pointerdown: (e) => { this.onPointerDown(e); },
+            pointerup: () => { this.onPointerUpOrLeave(); },
+            pointerleave: () => { this.onPointerUpOrLeave(); },
+            pointermove: (e) => { this.onPointerMove(e); },
+        };
+        this.intersectables = [];
+        if (view)
+            this.bindView(view);
+    }
+    /**
+     * 绑定视图到当前控制器
+     * @param view 需要绑定的视图
+     */
+    bindView(view) {
+        if (!view.camera || !view.renderer) {
+            throw new Error('No Camera or Renderer found in view');
+        }
+        const { THREE } = Externals.getInstance();
+        this.view = view;
+        this.controls = new OrbitControls(view.camera, view.renderer.domElement);
+        this.controls.addEventListener('start', () => { this.renderFrame = true; });
+        this.controls.addEventListener('end', () => { this.renderFrame = true; });
+        this.controls.addEventListener('change', () => { this.renderFrame = true; });
+        this.controls.enableKeys = false;
+        this.controls.enableDamping = false;
+        this.controls.enableRotate = false;
+        this.controls.mouseButtons = {
+            LEFT: THREE.MOUSE.ROTATE,
+            MIDDLE: THREE.MOUSE.DOLLY,
+            RIGHT: THREE.MOUSE.PAN,
+        };
+        this.controls.update();
+        this.target = view.renderer.domElement;
+        this.setEnabled(true);
+    }
+    unbind() {
+        super.unbind();
+        this.controls.dispose();
+    }
+    /**
+     * @ignore
+     */
+    update() {
+        this.controls.update();
+        let result = true;
+        if (!this.enabled || !this.renderFrame)
+            result = false;
+        this.renderFrame = false;
+        return result;
+    }
+    onPointerDown(e) {
+        const { offsetX, offsetY, button } = e;
+        if (button !== 0)
+            return;
+        const { clientWidth, clientHeight } = this.target;
+        this.mouseDownRatio.x = offsetX / clientWidth - 0.5;
+        this.mouseDownRatio.y = -offsetY / clientHeight + 0.5;
+        e.stopPropagation();
+        e.preventDefault();
+        if (this.state !== STATE.IDLE)
+            return;
+        if (this.view.camera) {
+            const { THREE } = Externals.getInstance();
+            const { x, y } = this.mouseDownRatio;
+            const raycaster = new THREE.Raycaster();
+            const pointerPosition = this.view.camera.position.clone();
+            const { zoom } = this.view.camera;
+            pointerPosition.set(pointerPosition.x + this.view.getViewWidth() * x / zoom, pointerPosition.y + this.view.getViewHeight() * y / zoom, pointerPosition.z);
+            raycaster.set(pointerPosition, new THREE.Vector3(0, 0, -1));
+            const intersections = raycaster.intersectObjects(this.intersectables.map(({ object }) => object));
+            if (!intersections || !intersections.length)
+                return;
+            let target = null;
+            let index = 0;
+            while (!(target instanceof Element) && index < intersections.length) {
+                target = intersections[index].object;
+                while (!(target instanceof Element) && target.parent)
+                    target = target.parent;
+                index += 1;
+            }
+            this.targetElement = target;
+            this.elementMouseCorrection = this.targetElement.position.clone().add(pointerPosition.clone().multiplyScalar(-1));
+            this.emit(OwllyEvents.ELEMENT_SELECTED, this.targetElement);
+            this.renderFrame = true;
+            if (this.elementMovable)
+                this.state = STATE.TO_MOVE_ELEMENT;
+        }
+    }
+    onPointerUpOrLeave() {
+        if (this.state === STATE.IDLE)
+            return;
+        if (this.state === STATE.MOVE_ELEMENT) {
+            this.emit(Events.ELEMENT_POSITION_UPDATED, this.targetElement.position.clone(), this.targetElement, this.targetElement.getUUID());
+        }
+        this.state = STATE.IDLE;
+        this.movingNewElement = false;
+    }
+    onPointerMove(e) {
+        const { offsetX, offsetY } = e;
+        const { clientWidth, clientHeight } = this.target;
+        this.mouseRatio.x = offsetX / clientWidth - 0.5;
+        this.mouseRatio.y = -offsetY / clientHeight + 0.5;
+        e.stopPropagation();
+        e.preventDefault();
+        if (!this.targetElement)
+            return;
+        if (this.state === STATE.TO_MOVE_ELEMENT) {
+            this.targetElement.visible = true;
+            this.state = STATE.MOVE_ELEMENT;
+        }
+        if (this.state === STATE.MOVE_ELEMENT) {
+            const { x, y } = this.mouseRatio;
+            const cameraPosition = this.view.camera.position.clone();
+            const { zoom } = this.view.camera;
+            this.targetElement.position.set(cameraPosition.x + this.view.getViewWidth() * x / zoom + this.elementMouseCorrection.x, cameraPosition.y + this.view.getViewHeight() * y / zoom + this.elementMouseCorrection.y, this.targetElement.position.z);
+        }
+    }
+    bindElement(element) {
+        if (element instanceof Array) {
+            element.forEach((e) => { this.bindElement(e); });
+        }
+        else {
+            this.elements.add(element);
+            if (element.intersectables && element.intersectables.length) {
+                element.intersectables.forEach((object) => {
+                    this.intersectables.push({ object, parent: element });
+                });
+            }
+            else {
+                element.children.filter((c) => c.isMesh).forEach((object) => {
+                    this.intersectables.push({ object, parent: element });
+                });
+            }
+        }
+    }
+    unbindElement(element) {
+        if (element instanceof Array) {
+            element.forEach((e) => { this.unbindElement(e); });
+        }
+        else {
+            this.elements.delete(element);
+            this.intersectables = this.intersectables.filter((i) => i.parent !== element);
+        }
+    }
+    /**
+     * 启用/禁用该控制器
+     * @param enabled 目标值
+     */
+    setEnabled(enabled) {
+        if (!this.target)
+            return;
+        this.enabled = enabled;
+        if (enabled) {
+            Object.entries(this.listeners).forEach(([e, callback]) => {
+                this.target.addEventListener(e, callback);
+            });
+            this.renderFrame = true;
+        }
+        else {
+            Object.entries(this.listeners).forEach(([e, callback]) => {
+                this.target.removeEventListener(e, callback);
+            });
+        }
+    }
+    /**
+     * 移动目标元素, 调用该函数后目标元素会吸附到鼠标.
+     * 若setElementMovable(false);, 该函数无效.
+     * @param element 需要移动的元素
+     * @returns 需要移除的元素
+     */
+    moveElement(element, isNewElement) {
+        if (!this.elementMovable)
+            return;
+        if (this.targetElement)
+            this.cancelMoveElement();
+        if (!this.elements.has(element))
+            this.elements.add(element);
+        element.visible = false;
+        this.state = STATE.TO_MOVE_ELEMENT;
+        this.targetElement = element;
+        this.emit(OwllyEvents.ELEMENT_SELECTED, this.targetElement);
+        this.movingNewElement = isNewElement;
+    }
+    /**
+     * 取消正在移动的元素
+     */
+    cancelMoveElement() {
+        if (this.state !== STATE.IDLE && this.movingNewElement) {
+            this.emit(OwllyEvents.DISPOSE_ELEMENT, this.targetElement);
+        }
+        if (this.targetElement)
+            this.targetElement = null;
+        this.state = STATE.IDLE;
+    }
+    /**
+     * 设置是否允许鼠标控制元素移动
+     * @param value 开关值
+     */
+    setElementMovable(value) {
+        this.elementMovable = value;
+    }
+}
+export { AerialElementController };

package/lib/owlly/controller/basic-controller.d.ts

@@ -0,0 +1,324 @@
+import { NS_THREE } from '../stage/externals';
+import { Controller } from './controller';
+import { OrthographicView } from '../view/orthographic-view';
+import { PerspectiveView } from '../view/perspective-view';
+declare type MouseButtons = {
+    LEFT: NS_THREE.MOUSE;
+    MIDDLE: NS_THREE.MOUSE;
+    RIGHT: NS_THREE.MOUSE;
+};
+declare type Touches = {
+    ONE: NS_THREE.TOUCH;
+    TWO: NS_THREE.TOUCH | 'map';
+};
+declare class BasicController extends Controller {
+    private bindingView;
+    private camera;
+    private target;
+    private enabled;
+    private state;
+    private eventListeners;
+    private needUpdate;
+    private enableDamping;
+    private dampingFactor;
+    private mouseButtons;
+    private touches;
+    private boundaryEnabled;
+    private boundary;
+    private lastTick;
+    private timeStart;
+    private timeEnd;
+    private touchCenter;
+    private inertiaFactor;
+    private enableRotate;
+    private rotateMode;
+    private rotateSpeed;
+    private rotateStart;
+    private rotateDelta;
+    private rotateEnd;
+    private rotateLineStart;
+    private rotateLineEnd;
+    private rotateInertiaType;
+    private spherical;
+    private sphericalDelta;
+    private maxSpherical;
+    private minSpherical;
+    private lastQuaternion;
+    private rotateInertiaDirection;
+    private rotateInertiaEnabled;
+    private rotateInertiaBase;
+    private rotateInertia;
+    private rotateInertiaDuration;
+    private enableZoom;
+    private dollyStart;
+    private dollyEnd;
+    private zoomMode;
+    private zoomDelta;
+    private zoomRange;
+    private fovRange;
+    private zoomInertiaEnabled;
+    private zoomInertiaBase;
+    private zoomInertia;
+    private zoomInertiaDuration;
+    private enablePan;
+    private panStart;
+    private panDelta;
+    private panEnd;
+    private panOffset;
+    private panSpeed;
+    private lastPosition;
+    private screenSpacePanning;
+    private panInertiaDirection;
+    private panInertiaEnabled;
+    private panInertiaBase;
+    private panInertia;
+    private panInertiaDuration;
+    zoomScale: number;
+    followMouse: boolean;
+    private mouseXY;
+    constructor(view: PerspectiveView | OrthographicView);
+    private registerEvents;
+    private unregisterEvents;
+    private onMouseDown;
+    private onMouseMove;
+    private onMouseUp;
+    private onMouseWheel;
+    private onContextMenu;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    private handleMouseDownRotate;
+    private handleMouseMoveSelfRotate;
+    private handleTouchStartRotate;
+    private handleTouchMoveSelfRotate;
+    private handleDownRotate;
+    private handleMoveRotate;
+    private handleRotateDelta;
+    private handleRotateSphericalDelta;
+    private handleUpRotate;
+    private handleMouseDownPan;
+    private handleMouseMovePan;
+    private handleTouchStartPan;
+    private handleTouchMovePan;
+    private handleDownPan;
+    private handleMovePan;
+    private handlePanDelta;
+    private handleUpPan;
+    private handleMouseWheel;
+    private handleZoom;
+    private handleUpZoom;
+    private handleMouseDownDolly;
+    private handleMouseMoveDolly;
+    private handleTouchStartDolly;
+    private handleTouchMoveDolly;
+    private handleTouchStartDollyRotate;
+    private handleTouchMoveDollyRotate;
+    private handleTouchStartDollyPan;
+    private handleTouchMoveDollyPan;
+    private handleTouchStartMap;
+    private handleTouchMoveAll;
+    private handleUpAll;
+    private resetVectors;
+    /** @ignore 暂缓开放 */
+    moveCameraTo(position: NS_THREE.Vector3, duration?: number, callbacks?: {
+        onUpdate?: (progress: number) => void;
+    }): Promise<void>;
+    /**
+     * 设置相机位置坐标
+     * @param position 位置坐标
+     * @param updateTarget 是否更新目标点坐标, 默认为true
+     */
+    setCameraPosition(position: NS_THREE.Vector3, updateTarget?: boolean): void;
+    /**
+     * 获取相机位置坐标
+     */
+    getCameraPosition(): NS_THREE.Vector3;
+    /**
+     * 设置当前相机看向目标位置
+     * @param target 目标点坐标
+     * @param updateCameraPosition 是否同步更新相机位置, 默认值为false
+     */
+    setCameraLookAt(target: NS_THREE.Vector3, updateCameraPosition?: boolean): void;
+    /**
+     * 获取相机看向目标位置
+     * @returns vec3
+     */
+    getCameraTarget(): NS_THREE.Vector3;
+    /**
+     * 设置当前相机视线方向
+     * @param direction 方向向量
+     * @param distance 目标距离, 默认值为1
+     */
+    setCameraLookAtVector(direction: NS_THREE.Vector3, distance?: number): void;
+    /**
+     * 设置是否开启阻尼
+     * @param enable 布尔值
+     */
+    setDampingEnabled(enable: boolean): void;
+    /**
+     * 设置阻尼系数, 默认值为0
+     * @param factor 阻尼系数
+     */
+    setDampingFactor(factor: number): void;
+    /**
+     * 获取阻尼系数
+     */
+    getDampingFactor(): number;
+    /**
+     * 设置是否激活缩放
+     * @param enable 布尔值
+     */
+    setZoomEnabled(enable: boolean): void;
+    /**
+     * 设置放大模式, 可选值: 'zoom': 使用变焦放大, 'fov': 使用fov放大
+     * @param mode 放大模式
+     */
+    setZoomMode(mode: 'zoom' | 'fov'): void;
+    /**
+     * 设置相机fov范围, 默认值为[60, 90]
+     * @param min 最小值
+     * @param max 最大值
+     */
+    setFovRange(min: number, max: number): void;
+    /**
+     * 设置当前相机fov, 仅限透视投影相机使用
+     * @param fov FOV值
+     */
+    setFov(fov: number): void;
+    /**
+     * 获取当前相机fov, 仅限透视投影相机使用
+     */
+    getFov(): number | null;
+    /**
+     * 设置变焦倍数范围, 默认值为[0, 10]
+     * @param min 最小值
+     * @param max 最大值
+     */
+    setZoomRange(min: number, max: number): void;
+    /**
+     * 设置当前变焦倍数, 倍数受倍数范围影响
+     * @param zoom 变焦倍数
+     */
+    setZoom(zoom: number): void;
+    /**
+     * 获取当前变焦倍数
+     */
+    getZoom(): number;
+    /**
+     * 设置是否激活变焦的惯性
+     * @param enabled 布尔值
+     */
+    setZoomInertiaEnabled(enabled: boolean): void;
+    /**
+     * 设置是否激活旋转
+     * @param enable 布尔值
+     */
+    setRotateEnabled(enable: boolean): void;
+    /**
+     * 设置旋转模式, 可选值 'self':自转, 'orbit': 公转
+     * @param mode 旋转模式
+     */
+    setRotateMode(mode: 'self' | 'orbit'): void;
+    /**
+     * 设置旋转速度
+     * @param speed 旋转速度倍数
+     */
+    setRotateSpeed(speed: number): void;
+    /**
+     * 获取旋转速度
+     */
+    getRotateSpeed(): number;
+    /**
+     * 设置是否激活旋转运动的惯性
+     * @param enabled 布尔值
+     */
+    setRotateInertiaEnabled(enabled: boolean): void;
+    /**
+     * 设置横向转动角度
+     * @param azimuth 弧度
+     */
+    setAzimuthAngle(azimuth: number): void;
+    /**
+     * 获取当前横向转动值, 范围区间为[-2 * PI, 2 * PI]
+     */
+    getAzimuthAngle(): number;
+    /**
+     * 设置纵向旋转角度
+     * @param polar 弧度
+     */
+    setPolarAngle(polar: number): void;
+    /**
+     * 获取当前纵向转动值
+     */
+    getPolarAngle(): number;
+    /**
+     * 设置横向转动范围, 范围区间为[-2 * PI, 2 * PI]
+     * @param min 最小值
+     * @param max 最大值
+     */
+    setAzimuthRange(min: number, max: number): void;
+    /**
+     * 设置纵向旋转范围, 范围区间为[0, PI]
+     * @param min 最小值
+     * @param max 最大值
+     */
+    setPolarRange(min: number, max: number): void;
+    /**
+     * 设置是否激活摇镜运动的惯性
+     * @param enabled 布尔值
+     */
+    setPanInertiaEnabled(enabled: boolean): void;
+    /**
+     * 设置惯性系数
+     * @param factor 惯性系数
+     */
+    setInertiaFactor(factor: number): void;
+    /**
+     * 设置是否激活摇镜(移动)
+     * @param enable 布尔值
+     */
+    setPanEnabled(enable: boolean): void;
+    /**
+     * 设置摇镜操作是否跟随屏幕空间朝向
+     * @param enabled 布尔值
+     */
+    setScreenSpacePanning(enabled: boolean): void;
+    /**
+     * 设置鼠标操作关联
+     * @param mouseButtons 鼠标操作关联
+     */
+    setMouseButtons(mouseButtons: MouseButtons): void;
+    /**
+     * 设置触摸操作关联
+     * @param touches 触摸操作关联
+     */
+    setTouches(touches: Touches): void;
+    /**
+     * 设置是否限制相机运动范围
+     * @param enable 是否限制
+     */
+    setBoundaryEnabled(enable: boolean): void;
+    /**
+     * 设置相机运动范围, 范围是一个包围盒, 使用最小值点与最大值点描述
+     * @param min 包围盒最小值点坐标, 默认值为无限小
+     * @param max 包围盒最大值点坐标, 默认值为无限大
+     */
+    setBoundary(min: NS_THREE.Vector3, max: NS_THREE.Vector3): void;
+    /**
+     * 设置BasicController是否激活可用
+     * @param enabled 是否激活
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 获取当前激活状态
+     */
+    getEnabled(): boolean;
+    /** @ignore */
+    bindView(view: PerspectiveView | OrthographicView): void;
+    /** @ignore */
+    update(): boolean;
+    /** @ignore */
+    unbind(): void;
+    unbindView(): void;
+}
+export { BasicController };