three-base 1.0.62 → 1.0.64

package/lib/ThreeMouse.js

@@ -0,0 +1,357 @@
+//
+//
+//
+//
+//
+// 启动鼠标事件
+import * as THREE from "three";
+import { Raycaster } from "three";
+import { debounce } from "lodash";
+/**
+ *  harp.gl 专用的鼠标拾取模型对象
+ */
+export default class ThreeMouse {
+    constructor(renderer, camera, scene) {
+        this._renderer = renderer;
+        this._camera = camera;
+        this._scene = scene;
+        this._frame = this._renderer.info.render.frame;
+        this._renderer.domElement.addEventListener("mouseenter", () => { this._mouseInRenderer = true; }, true); //鼠标进入开启拾取
+        this._renderer.domElement.addEventListener("mouseleave", this._mouseleave, true); //鼠标离开停止拾取
+        this._renderer.domElement.addEventListener("mousemove", this._mousemove, true); //鼠标移动监听事件
+        this._renderer.domElement.addEventListener("pointerdown", this._mousedown, true); //鼠标按下监听事件
+        this._renderer.domElement.addEventListener("pointerup", this._mouseup, true); //鼠标弹起监听事件
+    }
+    // 渲染器
+    _renderer;
+    _camera;
+    _scene;
+    // 鼠标在渲染器上面的位置
+    _mosePosition = new THREE.Vector2(0, 0);
+    // 鼠标按下的位置 如果和鼠标弹起的位置相同 才算一次有效的点击事件
+    _mouseDownPosition = new THREE.Vector2(0, 0);
+    //当前鼠标指针上的对象
+    _mesh_on;
+    //鼠标按下的对象
+    _mesh_Down;
+    //射线拾取器
+    _raycaster = new Raycaster();
+    // 当前渲染的帧数 ( 鼠标滑动事件 一帧只需要执行费一次即可 )
+    _frame = 0;
+    //鼠标是否在渲染器上
+    _mouseInRenderer = false;
+    // 鼠标滑动的事件
+    _mousemoveEvent;
+    // 需要被拾取的对象数组
+    _object3ds = [];
+    // 点击次数
+    _click_num = 0;
+    // 获取拾取到的对象
+    _getSelected(object3ds) {
+        let intersection;
+        if (object3ds.length) {
+            intersection = this._raycaster.intersectObjects(object3ds, false)[0];
+        }
+        return intersection;
+    }
+    ;
+    // 判断对象上面是否有事件
+    hasEvent(object, types = []) {
+        if (!object) {
+            return false;
+        }
+        // 如果 启用事件为关闭的话就不执行事件
+        if (object["userData"] && object["userData"]["enableEvent"] === false) {
+            return false;
+        }
+        const hasevent = types.some(type => {
+            //@ts-ignore
+            if (object["_listeners"] && object["_listeners"][type] && object["_listeners"][type][0]) {
+                return true;
+            }
+            // if (object["userData"] && object["userData"]["cursor"]) {
+            //     return true;
+            // }
+            return false;
+        });
+        return hasevent;
+    }
+    // 判断对象上是否有鼠标样式
+    hasCursor(object) {
+        if (!object) {
+            return false;
+        }
+        // 如果 启用事件为关闭的话就不执行事件
+        if (object["userData"] && object["userData"]["enableEvent"] === false) {
+            return false;
+        }
+        if (object["userData"] && object["userData"]["cursor"]) {
+            return true;
+        }
+    }
+    // 分发鼠标拾取事件
+    dispatchEvent() {
+        // 提取有事件的对象
+        const meshs = [];
+        this._scene.traverseVisible(mesh => {
+            // 判断对象是否有指定的事件
+            if (this.hasCursor(mesh) || this.hasEvent(mesh, ["leftclick", "rightclick", "click", "dbclick", "mouseenter", "mouseleave", "mousemove", "mousedown", "mouseup"])) {
+                meshs.push(mesh);
+            }
+        });
+        this._object3ds = meshs;
+        // 没有鼠标事件就不往下执行了
+        if (!this._mousemoveEvent || !this._mouseInRenderer) {
+            return;
+        }
+        // 拾取模型
+        let intersection = this._getSelected(meshs);
+        if (intersection) {
+            const MouseEvent = Object.assign(intersection, {
+                renderer: this._renderer,
+                camera: this._camera,
+                object: intersection.object,
+                type: this._mousemoveEvent.type,
+                offsetX: this._mousemoveEvent.offsetX,
+                offsetY: this._mousemoveEvent.offsetY,
+                x: this._mousemoveEvent.x,
+                y: this._mousemoveEvent.y
+            });
+            // 触发滑动事件
+            if (this._mesh_on === MouseEvent.object) {
+                if (this.hasEvent(MouseEvent.object, ["mousemove"])) {
+                    MouseEvent.type = "mousemove";
+                    MouseEvent.object.dispatchEvent(MouseEvent);
+                }
+                // 鼠标划入滑出事件
+            }
+            else if (this._mesh_on !== MouseEvent.object) {
+                if (this.hasEvent(this._mesh_on, ["mouseleave"])) {
+                    MouseEvent.type = "mouseleave";
+                    this._mesh_on.dispatchEvent(MouseEvent);
+                }
+                if (this.hasEvent(MouseEvent.object, ["mouseenter"])) {
+                    MouseEvent.type = "mouseenter";
+                    MouseEvent.object.dispatchEvent(MouseEvent);
+                }
+            }
+            this._mesh_on = MouseEvent.object || undefined; // 设置为当前鼠标上的对象
+            // 鼠标样式
+            if (this._mesh_on && this._mesh_on.userData && this._mesh_on.userData.cursor) {
+                this._renderer.domElement.style.cursor = this._mesh_on.userData.cursor;
+            }
+            else {
+                this._renderer.domElement.style.cursor = "auto";
+            }
+        }
+        else {
+            if (this.hasEvent(this._mesh_on, ["mouseleave"])) {
+                // 鼠标离开事件
+                this._mesh_on.dispatchEvent({
+                    renderer: this._renderer,
+                    camera: this._camera,
+                    object: this._mesh_on,
+                    type: "mouseleave",
+                    offsetX: this._mousemoveEvent.offsetX,
+                    offsetY: this._mousemoveEvent.offsetY,
+                    x: this._mousemoveEvent.x,
+                    y: this._mousemoveEvent.y
+                });
+            }
+            // 置空当前鼠标上面的对象
+            this._mesh_on = undefined;
+            this._renderer.domElement.style.cursor = "auto"; // 鼠标样式
+        }
+    }
+    // 鼠标离开事件
+    _mouseleave = (e) => {
+        this._mouseInRenderer = false;
+        // 鼠标离开事件
+        if (this._mousemoveEvent && this.hasEvent(this._mesh_on, ["mouseleave"])) {
+            this._mesh_on.dispatchEvent({
+                renderer: this._renderer,
+                camera: this._camera,
+                object: this._mesh_on,
+                type: "mouseleave",
+                offsetX: this._mousemoveEvent.offsetX,
+                offsetY: this._mousemoveEvent.offsetY,
+                x: this._mousemoveEvent.x,
+                y: this._mousemoveEvent.y
+            });
+        }
+        // 置空当前鼠标上面的对象
+        this._mesh_on = undefined;
+        this._renderer.domElement.style.cursor = "auto"; // 鼠标样式
+    };
+    // 鼠标滑动 设置鼠标位置
+    _mousemove = (e) => {
+        this._mousemoveEvent = e;
+        this._frame = this._renderer.info.render.frame;
+        if (document.pointerLockElement) { // 如果当前有元素 锁住了鼠标
+            this._mosePosition.set(0, 0); // 鼠标就指向canvas 的正中心
+        }
+        else {
+            this._mosePosition.x = (e.offsetX / this._renderer.domElement.offsetWidth) * 2 - 1;
+            this._mosePosition.y = -(e.offsetY / this._renderer.domElement.offsetHeight) * 2 + 1;
+        }
+        this._raycaster.setFromCamera(this._mosePosition, this._camera); // 设置射线拾取的参数
+    };
+    // 鼠标按下事件
+    _mousedown = (e) => {
+        // 记录按下的位置
+        this._mouseDownPosition.set(e.offsetX, e.offsetY);
+        this._mousemove(e);
+        let intersection = this._getSelected(this._object3ds);
+        if (!intersection || !this._mousemoveEvent) {
+            return;
+        }
+        this._mesh_Down = this._mesh_on = intersection.object;
+        // 触发鼠标按下事件
+        if (this.hasEvent(this._mesh_Down, ["mousedown"])) {
+            this._mesh_Down.dispatchEvent({
+                ...intersection,
+                renderer: this._renderer,
+                camera: this._camera,
+                object: intersection.object,
+                type: "mousedown",
+                offsetX: this._mousemoveEvent.offsetX,
+                offsetY: this._mousemoveEvent.offsetY,
+                x: this._mousemoveEvent.x,
+                y: this._mousemoveEvent.y
+            });
+        }
+    };
+    // 鼠标弹起事件
+    _mouseup = debounce(async (e) => {
+        // 提取有事件的对象
+        const meshs = [];
+        let intersection = this._getSelected(this._object3ds);
+        if (!intersection || !this._mousemoveEvent) {
+            return;
+        }
+        this._mesh_on = intersection.object;
+        if (this.hasEvent(this._mesh_Down, ["mouseup"])) {
+            this._mesh_on.dispatchEvent({
+                ...intersection,
+                renderer: this._renderer,
+                camera: this._camera,
+                object: intersection.object,
+                type: "mouseup",
+                offsetX: this._mousemoveEvent.offsetX,
+                offsetY: this._mousemoveEvent.offsetY,
+                x: this._mousemoveEvent.x,
+                y: this._mousemoveEvent.y
+            });
+        }
+        // 触发鼠标弹起事件
+        if (this._mesh_Down &&
+            this._mesh_Down === this._mesh_on &&
+            Math.abs(this._mouseDownPosition.x - e.offsetX) < 5 &&
+            Math.abs(this._mouseDownPosition.y - e.offsetY) < 5) {
+            // 是否有双击事件
+            if (this.hasEvent(this._mesh_Down, ["dbclick"])) {
+                this._click_num++;
+                await new Promise(resolve => setTimeout(resolve, 200));
+                // 只点击了一次
+                if (this._click_num === 1) {
+                    if (this.hasEvent(this._mesh_Down, ["click"])) {
+                        this._mesh_Down.dispatchEvent({
+                            ...intersection,
+                            renderer: this._renderer,
+                            camera: this._camera,
+                            object: intersection.object,
+                            type: "click",
+                            offsetX: this._mousemoveEvent.offsetX,
+                            offsetY: this._mousemoveEvent.offsetY,
+                            x: this._mousemoveEvent.x,
+                            y: this._mousemoveEvent.y
+                        });
+                    }
+                    if (this.hasEvent(this._mesh_Down, ["leftclick"]) && (e.button === 0)) {
+                        this._mesh_Down.dispatchEvent({
+                            ...intersection,
+                            renderer: this._renderer,
+                            camera: this._camera,
+                            object: intersection.object,
+                            type: "leftclick",
+                            offsetX: this._mousemoveEvent.offsetX,
+                            offsetY: this._mousemoveEvent.offsetY,
+                            x: this._mousemoveEvent.x,
+                            y: this._mousemoveEvent.y
+                        });
+                    }
+                    if (this.hasEvent(this._mesh_Down, ["rightclick"]) && (e.button === 2)) {
+                        this._mesh_Down.dispatchEvent({
+                            ...intersection,
+                            renderer: this._renderer,
+                            camera: this._camera,
+                            object: intersection.object,
+                            type: "rightclick",
+                            offsetX: this._mousemoveEvent.offsetX,
+                            offsetY: this._mousemoveEvent.offsetY,
+                            x: this._mousemoveEvent.x,
+                            y: this._mousemoveEvent.y
+                        });
+                    }
+                }
+                else if (this._click_num > 1) {
+                    if (this.hasEvent(this._mesh_Down, ["dbclick"]) && (new Date().valueOf() - this._click_num > 1) && (e.button === 0)) {
+                        this._mesh_Down.dispatchEvent({
+                            ...intersection,
+                            renderer: this._renderer,
+                            camera: this._camera,
+                            object: intersection.object,
+                            type: "dbclick",
+                            offsetX: this._mousemoveEvent.offsetX,
+                            offsetY: this._mousemoveEvent.offsetY,
+                            x: this._mousemoveEvent.x,
+                            y: this._mousemoveEvent.y
+                        });
+                    }
+                }
+            }
+            else {
+                if (this.hasEvent(this._mesh_Down, ["click"])) {
+                    this._mesh_Down.dispatchEvent({
+                        ...intersection,
+                        renderer: this._renderer,
+                        camera: this._camera,
+                        object: intersection.object,
+                        type: "click",
+                        offsetX: this._mousemoveEvent.offsetX,
+                        offsetY: this._mousemoveEvent.offsetY,
+                        x: this._mousemoveEvent.x,
+                        y: this._mousemoveEvent.y
+                    });
+                }
+                if (this.hasEvent(this._mesh_Down, ["leftclick"]) && (e.button === 0)) {
+                    this._mesh_Down.dispatchEvent({
+                        ...intersection,
+                        renderer: this._renderer,
+                        camera: this._camera,
+                        object: intersection.object,
+                        type: "leftclick",
+                        offsetX: this._mousemoveEvent.offsetX,
+                        offsetY: this._mousemoveEvent.offsetY,
+                        x: this._mousemoveEvent.x,
+                        y: this._mousemoveEvent.y
+                    });
+                }
+                if (this.hasEvent(this._mesh_Down, ["rightclick"]) && (e.button === 2)) {
+                    this._mesh_Down.dispatchEvent({
+                        ...intersection,
+                        renderer: this._renderer,
+                        camera: this._camera,
+                        object: intersection.object,
+                        type: "rightclick",
+                        offsetX: this._mousemoveEvent.offsetX,
+                        offsetY: this._mousemoveEvent.offsetY,
+                        x: this._mousemoveEvent.x,
+                        y: this._mousemoveEvent.y
+                    });
+                }
+            }
+            this._click_num = 0;
+        }
+    });
+}

package/lib/Transition.js

@@ -0,0 +1,193 @@
+/*
+ * @Author: xiaosihan
+ * @Date: 2021-04-10 02:44:01
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2022-06-22 19:44:23
+ */
+import threeUtils from "./threeUtils";
+function bezier(arr, t) {
+    const ut = 1 - t;
+    const a1 = arr[1] * ut + arr[2] * t;
+    const result = ((arr[0] * ut + arr[1] * t) * ut + a1 * t) * ut + (a1 * ut + (arr[2] * ut + arr[3] * t) * t) * t;
+    return result;
+}
+// 过渡动画插件
+export default class Transition {
+    /**
+     *Creates an instance of transition.
+     * @param {{ [key: string]: number }} // 初始值
+     * @param {[0.8, 0, 0.2, 1]} // 贝塞尔曲线
+     * @param {number} [duration=1000]  // 过渡时间
+     * @memberof transition
+     */
+    constructor(param = {}, bezier = [0.8, 0, 0.2, 1], duration = 500) {
+        this.setDuration(duration);
+        this.setBezier(bezier);
+        this.set(param);
+    }
+    // 所有的 key 的枚举
+    _keys = [];
+    // 贝塞尔曲线
+    _bezier = [0.8, 0, 0.2, 1];
+    // x轴贝塞尔
+    _Xbezier = [0, 0.8, 0.2, 1];
+    // y轴贝塞尔
+    _Ybezier = [0, 0, 1, 1];
+    setBezier(bezier = [0.8, 0, 0.2, 1]) {
+        this._bezier = [...bezier];
+        this._Xbezier = [0, bezier[0], bezier[2], 1];
+        this._Ybezier = [0, bezier[1], bezier[3], 1];
+        return this;
+    }
+    // 当前时间戳
+    timeTemp = performance.now();
+    // 过渡时间
+    _duration = 0;
+    //延时
+    _delay = 0;
+    // 设置过渡时间
+    setDuration(duration = 500) {
+        this._duration = duration;
+        return this;
+    }
+    // 设置延时
+    setDelay(delay = 0) {
+        this._delay = delay;
+        return this;
+    }
+    // 存储 每个参数的 起始位置 起始时间 终止位置  终止时间
+    _ = {};
+    onChangeCall;
+    // 执行过度动画
+    run({ timeTemp }) {
+        this.timeTemp = timeTemp;
+        if (!this.onChangeCall || this.isDone()) {
+            threeUtils.removeEventListener("requestAnimationFrame", this.runbindThis);
+        }
+        else {
+            this.onChangeCall(this.getJson());
+        }
+        return this;
+    }
+    runbindThis = this.run.bind(this);
+    // 设置动画对象的回调事件
+    onChange(onChangeCall) {
+        this.onChangeCall = onChangeCall;
+        threeUtils.addEventListener("requestAnimationFrame", this.runbindThis);
+        return this;
+    }
+    // 计算当前 key 的值
+    get(key) {
+        key = String(key);
+        if (this._keys.includes(key) && this.timeTemp < (this._[key + "_startTime"] + this._duration)) {
+            let start = this._[key + "_start"];
+            let end = this._[key + "_end"];
+            let timeProgress = Math.min(1, Math.max(0, (this.timeTemp - this._[key + "_startTime"]) / this._duration));
+            // 斜率
+            let t = 0;
+            // 微分法 求斜率t
+            while (bezier(this._Xbezier, t + 0.1) < timeProgress) {
+                t += 0.1;
+            }
+            while (bezier(this._Xbezier, t + 0.01) < timeProgress) {
+                t += 0.01;
+            }
+            while (bezier(this._Xbezier, t + 0.001) < timeProgress) {
+                t += 0.001;
+            }
+            t = Math.min(1, Math.max(0, t)); // 斜率最大为1
+            // 通过斜率求y值
+            return (bezier(this._Ybezier, t) * (end - start)) + start;
+        }
+        else if (this._keys.includes(key) && this.timeTemp >= (this._[key + "_startTime"] + this._duration)) {
+            return this._[key + "_end"];
+        }
+        // `没有 ${key} 的值`;
+        return 0;
+    }
+    async set(param) {
+        let timetemp = performance.now() + this._delay;
+        ;
+        for (let key in param) {
+            // 有就赋值
+            if (this._keys.includes(key) && Math.abs(param[key] - this._[key + "_end"]) > 0.001) {
+                this._[key + "_start"] = this.get(key);
+                this._[key + "_end"] = param[key];
+                // 起始时间
+                this._[key + "_startTime"] = timetemp;
+                // 执行状态未完成
+                this._isDone = false;
+                // 没有就添加一个
+            }
+            else if (!this._keys.includes(key)) {
+                this._[key + "_start"] = param[key];
+                this._[key + "_end"] = param[key];
+                // 起始时间
+                this._[key + "_startTime"] = timetemp - this._duration;
+                // 执行状态未完成
+                this._isDone = false;
+            }
+            if (!this._keys.includes(key)) {
+                this._keys.push(key);
+            }
+            // // 执行状态未完成
+            // this._isDone = false;
+        }
+        threeUtils.removeEventListener("requestAnimationFrame", this.runbindThis);
+        threeUtils.addEventListener("requestAnimationFrame", this.runbindThis);
+        if (!this._isDone) {
+            await new Promise(resolve => setTimeout(resolve, this._duration + 50));
+        }
+        return this;
+    }
+    // 重置起始和终止位置
+    reset(param) {
+        for (let key in param) {
+            this._[key + "_start"] = param[key];
+            this._[key + "_end"] = param[key];
+            this._[key + "_startTime"] = -this._duration;
+        }
+        if (this.onChangeCall) {
+            this.onChangeCall(this.getJson());
+        }
+        this._isDone = true;
+        return this;
+    }
+    // 获取过渡对象上面的key
+    getKeys() {
+        return [...this._keys];
+    }
+    // 判断是否有这个参数
+    hasKey(key) {
+        return this._keys.includes(key);
+    }
+    // 获取全部参数
+    getJson() {
+        let keys = this.getKeys();
+        let json = {};
+        keys.map(key => {
+            json[key] = this.get(key);
+        });
+        return json;
+    }
+    _isDone = false;
+    // 是否执行完成了
+    isDone() {
+        if (this._isDone) {
+            return true;
+        }
+        let isisDone = false;
+        for (let i in this._keys) {
+            isisDone = this._[this._keys[i] + "_startTime"] + this._duration < this.timeTemp;
+            // 只要有一个没有完成 都算没有完成 过渡
+            if (!isisDone) {
+                return false;
+            }
+        }
+        if (!this._isDone) {
+            this._isDone = true;
+            return false;
+        }
+        return true;
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,22 @@
+export { default } from "./lib/ThreeBase";
+export { default as EventMesh } from "./lib/EventMesh";
+export { default as ExtrudeMesh } from "./lib/ExtrudeMesh";
+export type { ExtrudePath } from "./lib/ExtrudeMesh";
+export type { ExtrudeMeshProps } from "./lib/ExtrudeMesh";
+export { default as KeyFrameAnimation } from "./lib/KeyFrameAnimation";
+export type { KeyframeAnimationProps } from "./lib/KeyFrameAnimation";
+export type { Keyframe } from "./lib/KeyFrameAnimation";
+export { default as InstancedGroupMesh } from "./lib/InstancedGroupMesh";
+export { default as PointLight } from "./lib/PointLight";
+export { default as Sky } from "./lib/Sky/Sky";
+export { default as keyContorls } from "./lib/keyContorls";
+export { default as Transition } from "./lib/Transition";
+export { default as threeUtils } from "./lib/threeUtils";
+export { default as threeLoader } from "./lib/threeLoader";
+export { default as FPScontrol } from "./lib/FPScontrol";
+export { default as PlaneText } from "./lib/PlaneText";
+export { default as SpriteText } from "three-spritetext";
+export { default as SpriteModal1 } from "./lib/spriteModal1/SpriteModal1";
+export { default as PlaneModal1 } from "./lib/planeModal1/PlaneModal1";
+export { default as Text3D } from "./lib/Text3D/Text3D";
+export type { Text3DProps } from "./lib/Text3D/Text3D";

package/lib/keyContorls.js

@@ -0,0 +1,98 @@
+/*
+ * @Author: xiaosihan
+ * @Date: 2022-03-20 14:48:33
+ * @Last Modified by: xiaosihan
+ * @Last Modified time: 2022-09-30 00:12:28
+ */
+import { throttle } from "lodash";
+import { EventDispatcher, Vector3 } from "three";
+import { generateUUID } from "three/src/math/MathUtils";
+/**
+ * 键盘 使用 ↑↓←→ 控制 x z 方向, 小键盘 1 0 控制 y 方向
+ *
+ * @class KeyContorls
+ * @extends {EventDispatcher}
+ */
+class KeyContorls extends EventDispatcher {
+    constructor() {
+        super();
+        this.addEvent();
+    }
+    uuid = generateUUID();
+    direction = new Vector3(0, 0, 0);
+    // 添加事件需要由外部实现
+    add(e) {
+        this.dispatchEvent({ ...e, type: "add" });
+    }
+    // 删除事件
+    delete(e) {
+        this.dispatchEvent({ ...e, type: "delete" });
+    }
+    // 回车按钮
+    enter(e) {
+        this.dispatchEvent({ ...e, type: "enter" });
+    }
+    keyDown = (e) => {
+        switch (e.keyCode) {
+            case 46: // 删除按钮
+                this.delete(e);
+                return;
+            case 13: // 回车按钮
+                this.enter(e);
+                return;
+            case 97: // 小键盘1
+                this.direction.set(0, 1, 0);
+                break;
+            case 96: // 小键盘0
+                this.direction.set(0, -1, 0);
+                break;
+            case 35: // 
+                this.direction.set(0, 0.001, 0);
+                break;
+            case 45:
+                this.direction.set(0, -0.001, 0);
+                break;
+            case 38: // 前
+                this.direction.set(0, 0, -1);
+                break;
+            case 37: // 后
+                this.direction.set(-1, 0, 0);
+                break;
+            case 40: // 左
+                this.direction.set(0, 0, 1);
+                break;
+            case 39: // 右
+                this.direction.set(1, 0, 0);
+                break;
+            default:
+                return;
+        }
+        if (e.shiftKey) {
+            this.direction.multiplyScalar(0.001);
+        }
+        if (e.ctrlKey) {
+            this.direction.multiplyScalar(0.1);
+        }
+        this.dispatchEvent({
+            type: "change",
+            direction: this.direction
+        });
+    };
+    _listeners;
+    // 节流 删除事件监听
+    removeEvent = throttle((type) => {
+        this._listeners = undefined;
+    }, 1000, { trailing: false });
+    addEventListener(type, listener) {
+        this.removeEvent(type);
+        super.addEventListener(type, listener);
+    }
+    addEvent() {
+        document.addEventListener("keydown", this.keyDown);
+    }
+    dispose() {
+        document.removeEventListener("keydown", this.keyDown);
+    }
+}
+const keyContorls = new KeyContorls();
+export default keyContorls;

package/lib/lib/ApngTexture.d.ts

@@ -0,0 +1,13 @@
+import { APNG } from "apng-js";
+import Player from "apng-js/types/library/player";
+import { CanvasTexture } from "three";
+export default class ApngTexture extends CanvasTexture {
+    constructor(url: string);
+    static TimeTemp: number;
+    preUpdate: number;
+    player?: Player;
+    apng?: APNG;
+    onUpdate: () => void;
+    getUuid(): number | "";
+    loadApng(url: string): Promise<void>;
+}