@aibee/owlly 1.0.26 → 1.0.29

package/lib/owlly/element/element.js

@@ -0,0 +1,75 @@
+import { NS_THREE } from '../stage/externals';
+import { EventHub } from '../utils/event-hub';
+import { OwllyEvents, Events } from '../utils/events';
+/** @ignore */
+class ElementFrameContext {
+    constructor(element, needsUpdate = false) {
+        this.element = element;
+        this.needUpdate = needsUpdate;
+        this.shouldPlaceElement = false;
+    }
+}
+/** 元素类 */
+class Element extends NS_THREE.Object3D {
+    constructor() {
+        super();
+        this.elementListeners = {
+            onElementSelected: this.onElementSelected.bind(this),
+        };
+        this.eventMap = new Map();
+        EventHub.on(OwllyEvents.ELEMENT_SELECTED, this.elementListeners.onElementSelected);
+    }
+    onElementSelected(e) {
+        if (e === this)
+            EventHub.emit(Events.ELEMENT_SELECTED, e);
+    }
+    /**
+     * 获取元素的uuid
+     */
+    getUUID() {
+        return this.universalId;
+    }
+    /**
+     * 设置元素的uuid
+     * @param uuid 配置的uuid
+     */
+    setUUID(uuid) {
+        this.universalId = uuid;
+    }
+    dispose() {
+        EventHub.off(OwllyEvents.ELEMENT_SELECTED, this.elementListeners.onElementSelected);
+    }
+    /**
+     * 注册事件监听
+     * @param event 事件名
+     * @param callback 回调函数
+     */
+    on(event, callback) {
+        if (!this.eventMap.has(event))
+            this.eventMap.set(event, new Set());
+        const callbacks = this.eventMap.get(event);
+        if (callbacks) {
+            callbacks.add(callback);
+            this.eventMap.set(event, callbacks);
+        }
+    }
+    emit(event, ...args) {
+        const callbacks = this.eventMap.get(event);
+        if (callbacks) {
+            callbacks.forEach((callback) => { callback(...args); });
+        }
+        EventHub.emit(event, ...args);
+    }
+    /**
+     * 注销事件监听
+     * @param event 事件名
+     * @param callback 回调函数
+     */
+    off(event, callback) {
+        const callbacks = this.eventMap.get(event);
+        if (!callbacks)
+            throw Error(`Target event '${event}' not found`);
+        callbacks.delete(callback);
+    }
+}
+export { Element, ElementFrameContext };

package/lib/owlly/element/floor-model.d.ts

@@ -0,0 +1,83 @@
+import { NS_THREE } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { View } from '../view/view';
+import { BVHTree, IntersectResult } from '../utils/bvh-tree';
+interface FloorModelViewConfiguration {
+    targetView: View;
+    visible: boolean;
+    meshMaterial?: NS_THREE.Material | NS_THREE.Material[];
+}
+/**
+ * 地面参数
+ */
+interface GroundParameters {
+    /** 铅垂方向向量(必须) */
+    downDirection: NS_THREE.Vector3;
+    /** 地面平面系数(可选): a * x + b * y + c * z + d = 0 */
+    groundPlane?: {
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+    };
+}
+/**
+ * 楼层模型元素
+ * @noInheritDoc
+ */
+declare class FloorModel extends Element {
+    private modelInitialized;
+    private modelLoaded;
+    private mesh;
+    private bvh;
+    private raycaster;
+    private groundParams;
+    private meshMaterial;
+    private viewConfigurations;
+    private globalScale;
+    boundingBoxMesh: NS_THREE.Mesh;
+    private reloadTimes;
+    /**
+     * @param url Mesh模型地址
+     */
+    constructor(url: string, useBVH?: boolean, globalScale?: number);
+    /**
+     * 设置地面参数
+     * @param params 地面参数
+     */
+    setGroundParameters(params: GroundParameters): void;
+    /**
+     * 读取Mesh模型
+     * @param url Mesh模型地址
+     */
+    load(url: string, useBVH?: boolean, index?: number): void;
+    isModelLoaded(): boolean;
+    /** @ignore */
+    update(): ElementFrameContext;
+    render(): void;
+    /**
+     * 配置在不同view中的显示状态
+     * @param configuration 配置
+     */
+    addViewConfiguration(configuration: FloorModelViewConfiguration): void;
+    addMeshMaterial(meshMaterial: NS_THREE.Material | NS_THREE.Material[]): void;
+    dispose(): void;
+    getBVHTree(): BVHTree;
+    /**
+     * 给定射线与模型的相交测试结果
+     * @param rayOrigin 射线起点
+     * @param rayDirection 射线方向
+     * @param backfaceCulling 是否忽略背面
+     */
+    intersectRay(rayOrigin: NS_THREE.Vector3, rayDirection: NS_THREE.Vector3, backfaceCulling: boolean): IntersectResult[] | null;
+    static intersectWithGroundPlane(p: NS_THREE.Vector3, groundParams: GroundParameters): NS_THREE.Vector3 | null;
+    private nearestIntersectionWithRaycaster;
+    /**
+     * 给定参考点处对应的模型地面上的点
+     * 如果有地面参数则进行简化计算，否则使用射线求交点
+     * @param p 参考点
+     */
+    intersectGround(p: NS_THREE.Vector3): NS_THREE.Vector3 | null;
+    getMeshMaterial(): NS_THREE.Material | NS_THREE.Material[];
+}
+export { FloorModel, FloorModelViewConfiguration, GroundParameters };

package/lib/owlly/element/floor-model.js

@@ -0,0 +1,227 @@
+import { GLTFLoader } from '../../external/loaders/gltf-loader';
+import { Externals } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { BasicTools } from '../utils/basic-tools';
+import { Events } from '../utils/events';
+import { BVHTree } from '../utils/bvh-tree';
+/**
+ * 楼层模型元素
+ * @noInheritDoc
+ */
+class FloorModel extends Element {
+    /**
+     * @param url Mesh模型地址
+     */
+    constructor(url, useBVH = true, globalScale = 1) {
+        super();
+        this.reloadTimes = 3;
+        const { THREE } = Externals.getInstance();
+        this.modelInitialized = false;
+        this.modelLoaded = false;
+        this.globalScale = globalScale;
+        this.setGroundParameters({ downDirection: new THREE.Vector3(0, 0, -1) });
+        this.viewConfigurations = new Map();
+        // this.eventListeners = {
+        //   onCurrentViewChanged: (view: View): void => {
+        //     let conf = {
+        //       visible: true,
+        //     } as FloorModelViewConfiguration;
+        //     if (this.viewConfigurations.has(view)) conf = this.viewConfigurations.get(view)!;
+        //     this.visible = conf.visible;
+        //     if (this.mesh) {
+        //       this.mesh.material = conf.meshMaterial || this.meshMaterial;
+        //     }
+        //   },
+        // };
+        // EventHub.on(OwllyEvents.RENDERING_VIEW_CHANGED, this.eventListeners.onCurrentViewChanged);
+        this.boundingBoxMesh = new THREE.Mesh();
+        this.boundingBoxMesh.visible = false;
+        this.add(this.boundingBoxMesh);
+        if (url)
+            this.load(url, useBVH);
+    }
+    /**
+     * 设置地面参数
+     * @param params 地面参数
+     */
+    setGroundParameters(params) {
+        this.groundParams = params;
+    }
+    /**
+     * 读取Mesh模型
+     * @param url Mesh模型地址
+     */
+    load(url, useBVH = true, index = 0) {
+        this.modelInitialized = false;
+        this.modelLoaded = false;
+        const { THREE } = Externals.getInstance();
+        const loader = new GLTFLoader();
+        loader.load(url, (gltf) => {
+            // this.modelNode = gltf.scene;
+            this.add(gltf.scene);
+            this.modelLoaded = true;
+            // this.needUpdate = true;
+            gltf.scene.traverse((obj) => {
+                if (obj instanceof THREE.Mesh) {
+                    this.mesh = obj;
+                    this.meshMaterial = obj.material;
+                    obj.geometry.scale(this.globalScale, this.globalScale, this.globalScale);
+                }
+            });
+            if (useBVH) {
+                this.bvh = BVHTree.createBVHTree(gltf.scene);
+            }
+            else {
+                this.raycaster = new THREE.Raycaster();
+            }
+            const box = new THREE.Box3().setFromObject(gltf.scene);
+            const { max, min } = box;
+            this.boundingBoxMesh.geometry = new THREE.BoxBufferGeometry(max.x - min.x, max.y - min.y, max.z - min.z);
+            this.boundingBoxMesh.position.copy(max.clone().add(min.clone()).multiplyScalar(0.5));
+            this.emit(Events.ELEMENT_LOADED, this);
+        }, undefined, (error) => {
+            const nextIndex = index + 1;
+            if (nextIndex > this.reloadTimes) {
+                this.emit(Events.ELEMENT_LOADED_ERROR, this, error);
+            }
+            else {
+                this.load(url, useBVH, nextIndex);
+            }
+        });
+    }
+    isModelLoaded() {
+        return this.modelLoaded;
+    }
+    /** @ignore */
+    update() {
+        const frameContext = new ElementFrameContext(this);
+        if (!this.modelInitialized && this.modelLoaded) {
+            this.modelInitialized = true;
+            frameContext.needUpdate = true;
+        }
+        if (this.modelInitialized && !this.parent) {
+            frameContext.shouldPlaceElement = true;
+        }
+        return frameContext;
+    }
+    // renderingViewChanged(view: View): void {
+    //   let conf = {
+    //     visible: true,
+    //   } as FloorModelViewConfiguration;
+    //   if (this.viewConfigurations.has(view)) conf = this.viewConfigurations.get(view)!;
+    //   this.visible = conf.visible;
+    //   if (this.mesh) {
+    //     this.mesh.material = conf.meshMaterial || this.meshMaterial;
+    //   }
+    // }
+    render() {
+        if (this.mesh) {
+            if (this.meshMaterial !== this.mesh.material) {
+                const last = this.mesh.material;
+                this.mesh.material = this.meshMaterial;
+                if (last instanceof Array) {
+                    last.forEach((l) => {
+                        l.dispose();
+                    });
+                }
+                else {
+                    last.dispose();
+                }
+            }
+        }
+    }
+    /**
+     * 配置在不同view中的显示状态
+     * @param configuration 配置
+     */
+    addViewConfiguration(configuration) {
+        const prevConfig = this.viewConfigurations.get(configuration.targetView);
+        if (!configuration.meshMaterial && prevConfig) {
+            configuration.meshMaterial = prevConfig.meshMaterial;
+        }
+        this.viewConfigurations.set(configuration.targetView, configuration);
+    }
+    addMeshMaterial(meshMaterial) {
+        this.meshMaterial = meshMaterial;
+    }
+    dispose() {
+        super.dispose();
+        BasicTools.dispose(this, true);
+        // EventHub.off(OwllyEvents.RENDERING_VIEW_CHANGED, this.eventListeners.onCurrentViewChanged);
+    }
+    getBVHTree() {
+        return this.bvh;
+    }
+    /**
+     * 给定射线与模型的相交测试结果
+     * @param rayOrigin 射线起点
+     * @param rayDirection 射线方向
+     * @param backfaceCulling 是否忽略背面
+     */
+    intersectRay(rayOrigin, rayDirection, backfaceCulling) {
+        if (!this.bvh) {
+            return null;
+        }
+        const results = this.bvh.intersectRay(rayOrigin, rayDirection, backfaceCulling);
+        return results;
+    }
+    static intersectWithGroundPlane(p, groundParams) {
+        const direction = groundParams.downDirection;
+        const { THREE } = Externals.getInstance();
+        if (groundParams.groundPlane) {
+            // a * x + b * y + c * z + d = 0
+            const { a, b, c, d, } = groundParams.groundPlane;
+            const den = a * direction.x + b * direction.y + c * direction.z;
+            const num = -a * p.x - b * p.y - c * p.z - d;
+            const t = num / den;
+            if (!Number.isNaN(t) && Number.isFinite(t)) {
+                const intersection = new THREE.Vector3(p.x + t * direction.x, p.y + t * direction.y, p.z + t * direction.z);
+                if (intersection.clone().sub(p).dot(direction) >= 0) {
+                    return intersection;
+                }
+            }
+        }
+        return null;
+    }
+    nearestIntersectionWithRaycaster(rayOrigin, rayDirection) {
+        this.raycaster.set(rayOrigin, rayDirection);
+        const intersection = this.raycaster.intersectObject(this.children[0], true);
+        if (intersection.length === 0)
+            return null;
+        let ret = null;
+        let minDist = Number.MAX_VALUE;
+        for (let i = 0; i < intersection.length; i += 1) {
+            const item = intersection[i];
+            const dist = item.distance;
+            if (dist >= 0.0 && dist < minDist) {
+                ret = item.point.clone();
+                minDist = dist;
+            }
+        }
+        return ret;
+    }
+    /**
+     * 给定参考点处对应的模型地面上的点
+     * 如果有地面参数则进行简化计算，否则使用射线求交点
+     * @param p 参考点
+     */
+    intersectGround(p) {
+        let ret = FloorModel.intersectWithGroundPlane(p, this.groundParams);
+        if (ret)
+            return ret;
+        if (this.bvh) {
+            const intersection = this.bvh.nearestIntersection(p, this.groundParams.downDirection);
+            if (intersection) {
+                ret = intersection.intersectionPoint;
+            }
+        }
+        else if (this.raycaster) {
+            ret = this.nearestIntersectionWithRaycaster(p, this.groundParams.downDirection);
+        }
+        return ret;
+    }
+    getMeshMaterial() {
+        return this.mesh.material;
+    }
+}
+export { FloorModel };

package/lib/owlly/element/gif-kit/Gif.d.ts

@@ -0,0 +1,96 @@
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+
+ This product includes following software:
+ * GifWriter.js
+ - Copyright (c) 2013 NOBUOKA Yu
+ - https://github.com/nobuoka/GifWriter.js
+ - https://raw.github.com/nobuoka/GifWriter.js/master/LICENSE.txt
+ */
+import { GifFrame } from './GifFrame';
+import { GifVersion } from './GifVersion';
+import { GifImage } from './GifImage';
+export declare class Gif implements GifImage {
+    /**
+     * GIF Header block.
+     */
+    private _version;
+    /**
+     * GIF image width.
+     */
+    private _width;
+    /**
+     * GIF image height.
+     */
+    private _height;
+    /**
+     * The number of color in the Global Color Table.
+     */
+    private _globalTableSize;
+    colorResolution: number;
+    sortFlag: boolean;
+    bgColorIndex: number;
+    pixelAspectRatio: number;
+    /**
+     * The Global Color Table array.
+     */
+    private _globalColorTable;
+    frames: GifFrame[];
+    isLoop: boolean;
+    /**
+     * The number of animation iteration count.
+     * if this is 0, it is infinite.
+     */
+    private _loopCount;
+    frameIndex1: number;
+    frameIndex2: number;
+    /**
+     * Gif
+     */
+    constructor(skipDefault?: boolean);
+    /**
+     * Parse Gif image from ArrayBuffer.
+     *
+     * @return {Gif} parsed gif object
+     */
+    static parse(buffer: ArrayBuffer): Gif;
+    versionName(): string;
+    get version(): GifVersion;
+    set version(v: GifVersion);
+    get width(): number;
+    set width(width: number);
+    get height(): number;
+    set height(height: number);
+    get globalColorTable(): Uint8Array;
+    set globalColorTable(bytes: Uint8Array);
+    get globalTableSize(): number;
+    get loopCount(): number;
+    set loopCount(loopCount: number);
+    writeToArrayBuffer(): Uint8Array[];
+    /**
+     * Convert Gif to Uint8Array[].
+     *
+     * @return {Uint8Array[]} array of Uint8Array
+     */
+    static writeToArrayBuffer(gif: Gif): Uint8Array[];
+    /**
+     * TODO
+     **/
+    writeToArray(): number[];
+    /**
+     * Split the animated GIF image.
+     *
+     * @return {Gif[]} array of Gif object
+     */
+    split(overwrite: boolean): Gif[];
+    /**
+     * Playback the animated GIF image.
+     *
+     * @return {Gif} Gif object
+     */
+    playback(overwrite: boolean): Gif;
+    static compressWithLZW(actualCodes: Uint8Array, numBits: number): number[];
+}