@aibee/owlly 1.0.26 → 1.0.29

package/lib/owlly/stage/owlly.js

@@ -0,0 +1,168 @@
+import TWEEN from '@tweenjs/tween.js';
+// #if WEB_ONLY
+// import Stats from 'stats.js';
+// #endif
+import { TimeProfiler } from '../utils/time-profiler';
+// #if WEB_ONLY
+import { Owlly2D } from '../owlly-2d';
+// #endif
+import { EventHub } from '../utils/event-hub';
+import { Events } from '../utils/events';
+import { EnvironmentUtils, Env } from '../utils/environment-utils';
+let frameTime;
+let timeSaver;
+let now;
+class Owlly {
+    constructor() {
+        this.stages = new Set();
+        this.screens = new Set();
+        this.controllers = new Set();
+        this.timeProfiler = new TimeProfiler();
+        this.selfManageTick = true;
+        // #if WEB_ONLY
+        // if (EnvironmentUtils.GetEnv() === Env.Web) {
+        //   this.stats = new Stats();
+        //   this.stats.showPanel(0);
+        //   this.stats.dom.style.setProperty('display', 'none');
+        //   this.statsEnabled = false;
+        //   if (document) document.body.appendChild(this.stats.dom);
+        // }
+        // #endif
+        this.listeners = {
+            windowResizeListener: () => { this.onWindowResize(); },
+            windowUnloadListener: () => { this.beforeWindowUnload(); },
+            onTick: this.tick.bind(this),
+        };
+        this.registerEvents();
+        if (EnvironmentUtils.GetEnv() === Env.Web && requestAnimationFrame) {
+            this.setRequestAnimationFrameFunction(requestAnimationFrame);
+        }
+    }
+    static GetSharedInstance() {
+        if (!this.SHARED_INSTANCE)
+            this.SHARED_INSTANCE = new Owlly();
+        return this.SHARED_INSTANCE;
+    }
+    /**
+     * 时钟函数
+     * @param time 距离上一帧的时间, ms
+     */
+    tick(time) {
+        this.timeProfiler.tick(time);
+        // EventHub.emit(Events.FPS_UPDATED, this.timeProfiler.getFPS());
+        EventHub.emit(Events.TICK);
+        const screenNeedsUpdate = Array.from(this.screens).reduce((tf, screen) => (screen.update() || tf), false);
+        const controllersNeedsUpdate = Array.from(this.controllers).reduce((tf, controller) => (controller.update() || tf), false);
+        const elementsNeedsUpdate = Array.from(this.stages).reduce((tf, stage) => (stage.tick() || tf), false);
+        if (this.forceRender || screenNeedsUpdate || controllersNeedsUpdate || elementsNeedsUpdate) {
+            this.screens.forEach((screen) => {
+                screen.renderScreen();
+            });
+        }
+        TWEEN.update();
+        // #if WEB_ONLY
+        // if (this.statsEnabled) {
+        //   this.stats.end();
+        //   this.stats.begin();
+        // }
+        // #endif
+        if (this.selfManageTick)
+            Owlly.RequestAnimationFrame(this.listeners.onTick);
+    }
+    registerEvents() {
+        if (EnvironmentUtils.GetEnv() === Env.Web)
+            window.addEventListener('resize', this.listeners.windowResizeListener);
+    }
+    onWindowResize() {
+        this.screens.forEach((screen) => {
+            screen.resize(window.innerWidth, window.innerHeight);
+        });
+        this.forceRender = true;
+        // #if WEB_ONLY
+        if (Owlly2D.initialized)
+            Owlly2D.resize();
+        // #endif
+    }
+    beforeWindowUnload() {
+        Array.from(this.stages).forEach((s) => {
+            s.dispose();
+        });
+        if (window)
+            window.removeEventListener('resize', this.listeners.windowResizeListener);
+        // #if WEB_ONLY
+        if (Owlly2D.initialized)
+            Owlly2D.dispose();
+        // if (document) document.body.removeChild(this.stats.dom);
+        // #endif
+    }
+    registerStage(stage) {
+        this.stages.add(stage);
+    }
+    unregisterStage(stage) {
+        this.stages.delete(stage);
+    }
+    registerScreen(screen) {
+        this.screens.add(screen);
+    }
+    unregisterScreen(screen) {
+        this.screens.delete(screen);
+    }
+    registerController(controller) {
+        this.controllers.add(controller);
+    }
+    unregisterController(controller) {
+        this.controllers.delete(controller);
+    }
+    setStatsEnabled(value) {
+        if (EnvironmentUtils.GetEnv() !== Env.Web)
+            return;
+        // #if WEB_ONLY
+        this.statsEnabled = value;
+        // this.stats.dom.style.setProperty('display', value ? 'block' : 'none');
+        // #endif
+    }
+    setRequestAnimationFrameFunction(requestAnimationFrame) {
+        // if (Owlly.RequestAnimationFrame) return;
+        Owlly.RequestAnimationFrame = requestAnimationFrame.bind(
+        // TODO: 此处小程序可能存在问题
+        // eslint-disable-next-line no-nested-ternary
+        EnvironmentUtils.GetEnv() === Env.Web
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ? (window.IS_DELEGATE ? window.delegateWindow : window) : this);
+        if (this.selfManageTick)
+            Owlly.RequestAnimationFrame(this.listeners.onTick);
+    }
+    toggleTickSelfManagement(value) {
+        if (this.selfManageTick === value)
+            return;
+        this.selfManageTick = value;
+        if (this.selfManageTick)
+            Owlly.RequestAnimationFrame(this.listeners.onTick);
+    }
+    renderNextFrame() {
+        this.forceRender = true;
+    }
+}
+function updateTick() {
+    const owlly = Owlly.GetSharedInstance();
+    if (!timeSaver) {
+        frameTime = 0;
+        timeSaver = Date.now();
+    }
+    now = Date.now();
+    frameTime += now - timeSaver;
+    owlly.tick(frameTime);
+    timeSaver = now;
+}
+function forceRender() {
+    const owlly = Owlly.GetSharedInstance();
+    owlly.renderNextFrame();
+}
+// only for debugging
+// declare global {
+//   interface Window {
+//     Owlly: any; // eslint-disable-line
+//   }
+// }
+// if (window) window.Owlly = Owlly;
+export { Owlly, updateTick, forceRender };

package/lib/owlly/stage/stage.d.ts

@@ -0,0 +1,108 @@
+import { NS_THREE } from './externals';
+import { Element } from '../element/element';
+import { View } from '../view';
+import { Controller } from '../controller';
+/**
+ * 场景类, 所有元素应当置于场景中, 视图与场景绑定后可渲染内容
+ */
+declare class Stage {
+    /**
+     * Stage 所使用的 THREE Scene
+     */
+    scene: NS_THREE.Scene;
+    private elements;
+    private lights;
+    private axesHelper;
+    private stageListeners;
+    private disposed;
+    constructor();
+    private registerEvents;
+    private initLights;
+    /**
+     * 旧的时钟函数, 后期应删除
+     * @deprecated
+     */
+    tick(): boolean;
+    /**
+     * 时钟钩子函数
+     * @returns 是否需要重新渲染
+     */
+    update(): boolean;
+    private handleElementUpdate;
+    /**
+     * 绑定视图至场景
+     * @param view 需要添加的视图
+     */
+    bindView(view: View): void;
+    /**
+     * 销毁视图
+     * @param view 需要销毁的视图
+     */
+    disposeView(view: View): void;
+    /**
+     * 绑定一个新的控制器到场景
+     * @param controller 添加的控制器
+     */
+    bindController(controller: Controller): void;
+    /**
+     * 销毁控制器
+     * @param controller 销毁的控制器
+     */
+    disposeController(controller?: Controller): Promise<void>;
+    /**
+     * 绑定元素至场景
+     * @param element 需要绑定的元素
+     */
+    bindElement(element: Element): void;
+    /**
+     * 销毁元素
+     * @param element 需要销毁的元素
+     */
+    disposeElement(element: Element): void;
+    /**
+     * 解绑元素, 元素仅会从 Stage 中移除而非销毁
+     * @param element 需要解绑的元素
+     */
+    unbindElement(element: Element): void;
+    /**
+     * (调试用) 开关性能统计
+     * @param value 开关值
+     */
+    setStatsEnabled(value: boolean): void;
+    /**
+     * (调试用) 开关场景xyz轴指示器
+     * @param value 开关值
+     */
+    setAxesEnabled(value: boolean): void;
+    /**
+     * 强制渲染
+     * @deprecated
+     */
+    render(): void;
+    /**
+     * 销毁场景
+     */
+    dispose(): void;
+    resizeElements(viewWidth: number, viewHeight: number): void;
+    renderElements(): void;
+    /**
+     * 强制重新计算绘制区域
+     * @deprecated
+     */
+    forceResize(): void;
+    /**
+     * 设置全场景背景色
+     * @param hexColor 颜色, 可以使用字符串
+     */
+    setBackgroundColor(hexColor: number | string): void;
+    /**
+     * 设置帧函数
+     * @param requestAnimationFrame
+     */
+    setFrameTickFunction(requestAnimationFrame: Function): void;
+    /**
+     * @ignore
+     */
+    toggleTickSelfManagement(value: boolean): void;
+}
+export { Stage };

package/lib/owlly/stage/stage.js

@@ -0,0 +1,234 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Externals } from './externals';
+import { EventHub } from '../utils/event-hub';
+import { OwllyEvents, Events } from '../utils/events';
+import { Owlly } from './owlly';
+/**
+ * 场景类, 所有元素应当置于场景中, 视图与场景绑定后可渲染内容
+ */
+class Stage {
+    constructor() {
+        const { THREE } = Externals.getInstance();
+        this.scene = new THREE.Scene();
+        this.elements = new Set();
+        this.lights = new THREE.Group();
+        this.initLights();
+        this.scene.add(this.lights);
+        this.axesHelper = new THREE.AxesHelper(10);
+        this.axesHelper.visible = false;
+        this.scene.add(this.axesHelper);
+        this.disposed = false;
+        this.stageListeners = {
+            onDisposeElement: (element) => {
+                if (Array.isArray(element)) {
+                    element.forEach((e) => { this.stageListeners.onDisposeElement(e); });
+                }
+                else {
+                    this.disposeElement(element);
+                }
+            },
+            onElementLoaded: (element) => {
+                EventHub.emit(Events.ELEMENT_LOADED, element);
+            },
+        };
+        this.registerEvents();
+        Owlly.GetSharedInstance().registerStage(this);
+    }
+    registerEvents() {
+        EventHub.on(OwllyEvents.DISPOSE_ELEMENT, this.stageListeners.onDisposeElement);
+        EventHub.on(OwllyEvents.ELEMENT_LOADED, this.stageListeners.onElementLoaded);
+    }
+    initLights() {
+        const { THREE } = Externals.getInstance();
+        const hemisphereLight = new THREE.HemisphereLight(0xffffff, 0xffffff, 0.75);
+        // hemisphereLight.color.setHSL(0.6, 0.75, 0.5);
+        // hemisphereLight.groundColor.setHSL(0.095, 0.5, 0.5);
+        hemisphereLight.position.set(0, 50, 0);
+        this.lights.add(hemisphereLight);
+        const directionalLight = new THREE.DirectionalLight(0xffffff, 0.23);
+        directionalLight.color.setHSL(0.1, 1, 0.95);
+        directionalLight.position.set(-0.5, 1, 0.75);
+        directionalLight.position.multiplyScalar(50);
+        // directionalLight.position.set(-50, 60, 50);
+        // directionalLight.castShadow = true;
+        // directionalLight.shadow.camera.bottom = -200;
+        // directionalLight.shadow.camera.top = 200;
+        // directionalLight.shadow.camera.left = -200;
+        // directionalLight.shadow.camera.right = 200;
+        this.lights.add(directionalLight);
+        this.lights.add(directionalLight.target);
+        directionalLight.target.updateMatrixWorld();
+        const directionalLight2 = new THREE.DirectionalLight(0xffffff, 0.23);
+        directionalLight2.color.setHSL(0.1, 1, 0.95);
+        directionalLight2.position.set(0.5, -1, 0.75);
+        directionalLight2.position.multiplyScalar(50);
+        this.lights.add(directionalLight2);
+        this.lights.add(directionalLight2.target);
+        directionalLight2.target.updateMatrixWorld();
+    }
+    /**
+     * 旧的时钟函数, 后期应删除
+     * @deprecated
+     */
+    tick() {
+        return this.update();
+    }
+    /**
+     * 时钟钩子函数
+     * @returns 是否需要重新渲染
+     */
+    update() {
+        if (this.disposed)
+            return false;
+        const elements = Array.from(this.elements);
+        const elementsNeedsUpdate = elements.reduce((tf, e) => (this.handleElementUpdate(e.update()) || tf), false);
+        return elementsNeedsUpdate;
+    }
+    handleElementUpdate(context) {
+        if (context.shouldPlaceElement) {
+            this.scene.add(context.element);
+        }
+        return context.needUpdate;
+    }
+    /**
+     * 绑定视图至场景
+     * @param view 需要添加的视图
+     */
+    bindView(view) {
+        view.bindStage(this);
+    }
+    /**
+     * 销毁视图
+     * @param view 需要销毁的视图
+     */
+    disposeView(view) {
+        view.dispose();
+    }
+    /**
+     * 绑定一个新的控制器到场景
+     * @param controller 添加的控制器
+     */
+    bindController(controller) {
+        if (controller.initWithScene)
+            controller.initWithScene(this.scene);
+    }
+    /**
+     * 销毁控制器
+     * @param controller 销毁的控制器
+     */
+    disposeController(controller) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    /**
+     * 绑定元素至场景
+     * @param element 需要绑定的元素
+     */
+    bindElement(element) {
+        this.elements.add(element);
+        // if (element.resize) this.forceResize();
+    }
+    /**
+     * 销毁元素
+     * @param element 需要销毁的元素
+     */
+    disposeElement(element) {
+        this.unbindElement(element);
+        if (element)
+            element.dispose();
+    }
+    /**
+     * 解绑元素, 元素仅会从 Stage 中移除而非销毁
+     * @param element 需要解绑的元素
+     */
+    unbindElement(element) {
+        if (!this.elements.has(element))
+            return;
+        this.scene.remove(element);
+        this.elements.delete(element);
+    }
+    /**
+     * (调试用) 开关性能统计
+     * @param value 开关值
+     */
+    setStatsEnabled(value) {
+        Owlly.GetSharedInstance().setStatsEnabled(value);
+    }
+    /**
+     * (调试用) 开关场景xyz轴指示器
+     * @param value 开关值
+     */
+    setAxesEnabled(value) {
+        this.axesHelper.visible = value;
+    }
+    /**
+     * 强制渲染
+     * @deprecated
+     */
+    render() {
+        throw new Error('[Owlly] This function is no longer being used. Use forceRender() exported from Owlly directly instead.');
+    }
+    /**
+     * 销毁场景
+     */
+    dispose() {
+        const elements = Array.from(this.elements);
+        elements.forEach((e) => {
+            this.elements.delete(e);
+            e.dispose();
+        });
+        EventHub.off(OwllyEvents.DISPOSE_ELEMENT, this.stageListeners.onDisposeElement);
+        EventHub.off(OwllyEvents.ELEMENT_LOADED, this.stageListeners.onElementLoaded);
+        this.disposed = true;
+        Owlly.GetSharedInstance().unregisterStage(this);
+    }
+    resizeElements(viewWidth, viewHeight) {
+        this.elements.forEach((element) => {
+            if (element.resize)
+                element.resize(viewWidth, viewHeight);
+        });
+    }
+    renderElements() {
+        this.elements.forEach((element) => {
+            if (element.render)
+                element.render();
+        });
+    }
+    /**
+     * 强制重新计算绘制区域
+     * @deprecated
+     */
+    forceResize() {
+        throw new Error('[Owlly] This function is no longer being used. Use Screen.resize() instead.');
+    }
+    /**
+     * 设置全场景背景色
+     * @param hexColor 颜色, 可以使用字符串
+     */
+    setBackgroundColor(hexColor) {
+        const { THREE } = Externals.getInstance();
+        this.scene.background = new THREE.Color(hexColor);
+    }
+    /**
+     * 设置帧函数
+     * @param requestAnimationFrame
+     */
+    setFrameTickFunction(requestAnimationFrame) {
+        Owlly.GetSharedInstance().setRequestAnimationFrameFunction(requestAnimationFrame);
+    }
+    /**
+     * @ignore
+     */
+    toggleTickSelfManagement(value) {
+        Owlly.GetSharedInstance().toggleTickSelfManagement(value);
+    }
+}
+export { Stage };

package/lib/owlly/utils/alignment-utils.d.ts

@@ -0,0 +1,20 @@
+import { View } from '../view/view';
+declare class AlignmentUtils {
+    /**
+     * 获取2d与3d之间的对齐参数
+     * @param view 基准视图
+     * @param baseImageScale 底图缩放等级, 绝对值
+     * @param offset 底图整体偏移, 结构为 [ number, number ], 对应x, y轴偏移值
+     * @param imageSize 底图图片尺寸, 结构为 [ number, number ], 对应宽度, 高度
+     * @returns { upTrans: number[]; downTrans: number[]; matrixWorld: number[]; } 三个矩阵,
+     *  uptrans: 2d转3d, downTrans: 3d转2d, matrixWorld: 相机自身参数, 重设时使用
+     */
+    static getTransformMatrices(view: View, baseImageScale: number, offset: [number, number], imageSize: [number, number]): {
+        upTransOrigin: number[];
+        downTransOrigin: number[];
+        upTrans: number[];
+        downTrans: number[];
+        matrixWorld: number[];
+    };
+}
+export { AlignmentUtils };

package/lib/owlly/utils/alignment-utils.js

@@ -0,0 +1,63 @@
+import { Externals } from '../stage/externals';
+class AlignmentUtils {
+    /**
+     * 获取2d与3d之间的对齐参数
+     * @param view 基准视图
+     * @param baseImageScale 底图缩放等级, 绝对值
+     * @param offset 底图整体偏移, 结构为 [ number, number ], 对应x, y轴偏移值
+     * @param imageSize 底图图片尺寸, 结构为 [ number, number ], 对应宽度, 高度
+     * @returns { upTrans: number[]; downTrans: number[]; matrixWorld: number[]; } 三个矩阵,
+     *  uptrans: 2d转3d, downTrans: 3d转2d, matrixWorld: 相机自身参数, 重设时使用
+     */
+    static getTransformMatrices(view, baseImageScale, offset, imageSize) {
+        if (!view.camera || !view.renderer)
+            throw new Error('Cannot find Camera or Renderer object in view');
+        const c = view.camera;
+        const r = view.renderer;
+        const { THREE } = Externals.getInstance();
+        const raycaster = new THREE.Raycaster();
+        raycaster.setFromCamera({ x: -1, y: -1 }, c);
+        const from = raycaster.ray.origin.clone().x;
+        raycaster.setFromCamera({ x: 1, y: 1 }, c);
+        const to = raycaster.ray.origin.clone().x;
+        const ratio = Math.abs(to - from) / r.domElement.clientWidth * baseImageScale; // * r.getPixelRatio()
+        const camera = new THREE.Camera();
+        const rotation = new THREE.Euler().setFromQuaternion(c.quaternion.clone()).z;
+        const offsetX = ratio * (offset[0] * Math.cos(rotation) + offset[1] * Math.sin(rotation));
+        const offsetY = ratio * (-offset[0] * Math.sin(rotation) + offset[1] * Math.cos(rotation));
+        camera.copy(c);
+        camera.position.add(new THREE.Vector3(offsetX, -offsetY, 0));
+        camera.updateMatrixWorld();
+        const preScaleMatrix = new THREE.Matrix4();
+        const preScaleArray = new Array(16).fill(0);
+        preScaleArray[0] = 1 / baseImageScale;
+        preScaleArray[5] = 1 / baseImageScale;
+        preScaleArray[10] = 1;
+        preScaleArray[15] = 1;
+        preScaleMatrix.fromArray(preScaleArray);
+        const postTransformMatrix = new THREE.Matrix4();
+        const postTransformArray = new Array(16).fill(0);
+        postTransformArray[0] = imageSize[0] / 2;
+        postTransformArray[5] = -imageSize[1] / 2;
+        postTransformArray[10] = 1;
+        postTransformArray[12] = imageSize[0] / 2;
+        postTransformArray[13] = imageSize[1] / 2;
+        postTransformArray[15] = 1;
+        postTransformMatrix.fromArray(postTransformArray);
+        const downTransOrigin = camera.projectionMatrix.clone()
+            .multiply(preScaleMatrix)
+            .multiply(camera.matrixWorldInverse);
+        const upTransOrigin = downTransOrigin.clone().invert();
+        const downTrans = postTransformMatrix.clone().multiply(downTransOrigin);
+        const upTrans = downTrans.clone().invert();
+        const matrixWorld = camera.matrixWorld.elements.slice();
+        return {
+            upTransOrigin: upTransOrigin.elements.slice(),
+            downTransOrigin: downTransOrigin.elements.slice(),
+            upTrans: upTrans.elements.slice(),
+            downTrans: downTrans.elements.slice(),
+            matrixWorld,
+        };
+    }
+}
+export { AlignmentUtils };

package/lib/owlly/utils/basic-calc.d.ts

@@ -0,0 +1,18 @@
+interface Coord2d {
+    x: number;
+    y: number;
+}
+interface TurningInfo {
+    point: number[];
+    angle: number;
+    startTPoint: number[];
+    endTPoint: number[];
+    startIndex: number;
+    endIndex: number;
+}
+declare class BasicCalcTool {
+    static getLineCross(line1_p1: Coord2d, line1_p2: Coord2d, line2_p1: Coord2d, line2_p2: Coord2d): boolean;
+    static calcTurning(linePoints: [number, number][], turningStandard?: number[]): TurningInfo[];
+    static chunk(items: any[], size: number): any[][];
+}
+export { BasicCalcTool, TurningInfo };