three-base 2.0.1 → 2.0.2

package/ThreeMouse.ts

@@ -0,0 +1,465 @@
+//
+//
+//
+//
+//
+// 启动鼠标事件
+import * as THREE from "three";
+import { Object3D, Raycaster, Scene } from "three";
+import type { Intersection } from "three";
+import { debounce } from "lodash";
+
+export interface ThreeMouseEvent extends Intersection {
+    renderer: THREE.Renderer;
+    camera: THREE.Camera;
+    type: string;
+    offsetX: number;
+    offsetY: number
+    x: number;
+    y: number;
+}
+
+
+/**
+ *  harp.gl 专用的鼠标拾取模型对象
+ */
+export default class ThreeMouse {
+
+    constructor(renderer: THREE.WebGLRenderer, camera: THREE.Camera, scene: THREE.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!: THREE.WebGLRenderer;
+
+    _camera!: THREE.Camera;
+
+    _scene!: Scene;
+
+    // 鼠标在渲染器上面的位置
+    _mosePosition = new THREE.Vector2(0, 0);
+
+    // 鼠标按下的位置 如果和鼠标弹起的位置相同 才算一次有效的点击事件
+    _mouseDownPosition = new THREE.Vector2(0, 0);
+
+    //当前鼠标指针上的对象
+    _mesh_on?: Object3D;
+
+    //鼠标按下的对象
+    _mesh_Down?: Object3D;
+
+    //射线拾取器
+    _raycaster = new Raycaster();
+
+    // 当前渲染的帧数 ( 鼠标滑动事件 一帧只需要执行费一次即可 )
+    _frame: number = 0;
+
+    //鼠标是否在渲染器上
+    _mouseInRenderer: boolean = false;
+
+    // 鼠标滑动的事件
+    _mousemoveEvent?: MouseEvent;
+
+    // 需要被拾取的对象数组
+    _object3ds: Object3D[] = [];
+
+    // 点击次数
+    _click_num = 0;
+
+    // 获取拾取到的对象
+    _getSelected(object3ds: Object3D[]): Intersection | undefined {
+        let intersection: Intersection | undefined;
+
+        if (object3ds.length) {
+            intersection = this._raycaster.intersectObjects(object3ds, false)[0];
+        }
+
+        return intersection;
+    };
+
+    // 判断对象上面是否有事件
+    hasEvent(object?: Object3D, types: Array<"leftclick" | "rightclick" | "click" | "dbclick" | "mouseenter" | "mouseleave" | "mousemove" | "mousedown" | "mouseup"> = []) {
+
+        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?: Object3D) {
+        if (!object) {
+            return false;
+        }
+        // 如果 启用事件为关闭的话就不执行事件
+        if (object["userData"] && object["userData"]["enableEvent"] === false) {
+            return false;
+        }
+        if (object["userData"] && object["userData"]["cursor"]) {
+            return true;
+        }
+    }
+
+    // 分发鼠标拾取事件
+    dispatchEvent() {
+        // 提取有事件的对象
+        const meshs: Object3D[] = [];
+
+        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 { face, object } = intersection;
+            face && face.normal.applyMatrix4(object.matrixWorld);
+            const MouseEvent: ThreeMouseEvent = 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 as Object3D,
+                    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: MouseEvent) => {
+        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 as Object3D,
+                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: MouseEvent) => {
+
+        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: MouseEvent) => {
+        // 记录按下的位置
+        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 as Object3D;
+
+        // 触发鼠标按下事件
+        if (this.hasEvent(this._mesh_Down, ["mousedown"])) {
+
+            this._mesh_Down.dispatchEvent({
+                ...intersection,
+                renderer: this._renderer,
+                camera: this._camera,
+                object: intersection.object as Object3D,
+                type: "mousedown",
+                offsetX: this._mousemoveEvent.offsetX,
+                offsetY: this._mousemoveEvent.offsetY,
+                x: this._mousemoveEvent.x,
+                y: this._mousemoveEvent.y
+            });
+
+        }
+
+    }
+
+    // 鼠标弹起事件
+    _mouseup = debounce(async (e: PointerEvent) => {
+
+        // 提取有事件的对象
+        const meshs: Object3D[] = [];
+
+        let intersection = this._getSelected(this._object3ds);
+
+        if (!intersection || !this._mousemoveEvent) {
+            return;
+        }
+
+        this._mesh_on = intersection.object as Object3D;
+
+        if (this.hasEvent(this._mesh_Down, ["mouseup"])) {
+
+            this._mesh_on.dispatchEvent({
+                ...intersection,
+                renderer: this._renderer,
+                camera: this._camera,
+                object: intersection.object as Object3D,
+                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 as Object3D,
+                            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 as Object3D,
+                            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 as Object3D,
+                            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 as Object3D,
+                            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 as Object3D,
+                        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 as Object3D,
+                        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 as Object3D,
+                        type: "rightclick",
+                        offsetX: this._mousemoveEvent.offsetX,
+                        offsetY: this._mousemoveEvent.offsetY,
+                        x: this._mousemoveEvent.x,
+                        y: this._mousemoveEvent.y
+                    });
+                }
+
+            }
+
+            this._click_num = 0;
+
+        }
+
+    })
+
+
+
+
+}

package/Transition.d.ts

@@ -0,0 +1,43 @@
+interface TParam {
+    [key: string]: number;
+}
+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?: TParam, bezier?: [number, number, number, number], duration?: number);
+    _keys: Array<string>;
+    _bezier: [number, number, number, number];
+    _Xbezier: [number, number, number, number];
+    _Ybezier: [number, number, number, number];
+    setBezier(bezier?: [number, number, number, number]): this;
+    timeTemp: number;
+    _duration: number;
+    _delay: number;
+    setDuration(duration?: number): this;
+    setDelay(delay?: number): this;
+    _: {
+        [key: string]: number;
+    };
+    private onChangeCall;
+    run({ timeTemp }: any): this;
+    runbindThis: any;
+    onChange(onChangeCall: (josn: {
+        [key: string]: number;
+    }) => void): this;
+    get(key: string | number): number;
+    set(param: TParam): Promise<this>;
+    reset(param: TParam): this;
+    getKeys(): string[];
+    hasKey(key: string): boolean;
+    getJson(): {
+        [key: string]: number;
+    };
+    _isDone: boolean;
+    isDone(): boolean;
+}
+export {};

package/Transition.js

@@ -0,0 +1,196 @@
+/*
+ * @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.reset(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 = (josn) => { };
+    // 执行过度动画
+    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;
+        this.onChangeCall(this.getJson());
+        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;
+        }
+        if (!this._isDone) {
+            threeUtils.removeEventListener("requestAnimationFrame", this.runbindThis);
+            threeUtils.addEventListener("requestAnimationFrame", this.runbindThis);
+            await new Promise(resolve => setTimeout(resolve, this._duration + 50));
+        }
+        return this;
+    }
+    // 重置起始和终止位置
+    reset(param) {
+        for (let key in param) {
+            if (!this._keys.includes(key)) {
+                this._keys.push(key);
+            }
+            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;
+    }
+}