three-base 1.0.81 → 1.0.82

package/lib/Transition.js

@@ -4,15 +4,60 @@
  * @Last Modified by: xiaosihan
  * @Last Modified time: 2022-06-22 19:44:23
  */
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 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;
+    var ut = 1 - t;
+    var a1 = arr[1] * ut + arr[2] * t;
+    var 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 {
+var Transition = /** @class */ (function () {
     /**
      *Creates an instance of transition.
      * @param {{ [key: string]: number }} // 初始值
@@ -20,46 +65,55 @@ export default class Transition {
      * @param {number} [duration=1000]  // 过渡时间
      * @memberof transition
      */
-    constructor(param = {}, bezier = [0.8, 0, 0.2, 1], duration = 500) {
+    function Transition(param, bezier, duration) {
+        if (param === void 0) { param = {}; }
+        if (bezier === void 0) { bezier = [0.8, 0, 0.2, 1]; }
+        if (duration === void 0) { duration = 500; }
+        // 所有的 key 的枚举
+        this._keys = [];
+        // 贝塞尔曲线
+        this._bezier = [0.8, 0, 0.2, 1];
+        // x轴贝塞尔
+        this._Xbezier = [0, 0.8, 0.2, 1];
+        // y轴贝塞尔
+        this._Ybezier = [0, 0, 1, 1];
+        // 当前时间戳
+        this.timeTemp = performance.now();
+        // 过渡时间
+        this._duration = 0;
+        //延时
+        this._delay = 0;
+        // 存储 每个参数的 起始位置 起始时间 终止位置  终止时间
+        this._ = {};
+        this.onChangeCall = function (josn) { };
+        this.runbindThis = this.run.bind(this);
+        this._isDone = false;
         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];
+    Transition.prototype.setBezier = function (bezier) {
+        if (bezier === void 0) { bezier = [0.8, 0, 0.2, 1]; }
+        this._bezier = __spreadArray([], bezier, true);
         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) {
+    Transition.prototype.setDuration = function (duration) {
+        if (duration === void 0) { duration = 500; }
         this._duration = duration;
         return this;
-    }
+    };
     // 设置延时
-    setDelay(delay = 0) {
+    Transition.prototype.setDelay = function (delay) {
+        if (delay === void 0) { delay = 0; }
         this._delay = delay;
         return this;
-    }
-    // 存储 每个参数的 起始位置 起始时间 终止位置  终止时间
-    _ = {};
-    onChangeCall = (josn) => { };
+    };
     // 执行过度动画
-    run({ timeTemp }) {
+    Transition.prototype.run = function (_a) {
+        var timeTemp = _a.timeTemp;
         this.timeTemp = timeTemp;
         if (!this.onChangeCall || this.isDone()) {
             threeUtils.removeEventListener("requestAnimationFrame", this.runbindThis);
@@ -68,23 +122,22 @@ export default class Transition {
             this.onChangeCall(this.getJson());
         }
         return this;
-    }
-    runbindThis = this.run.bind(this);
+    };
     // 设置动画对象的回调事件
-    onChange(onChangeCall) {
+    Transition.prototype.onChange = function (onChangeCall) {
         this.onChangeCall = onChangeCall;
         this.onChangeCall(this.getJson());
         return this;
-    }
+    };
     // 计算当前 key 的值
-    get(key) {
+    Transition.prototype.get = function (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));
+            var start = this._[key + "_start"];
+            var end = this._[key + "_end"];
+            var timeProgress = Math.min(1, Math.max(0, (this.timeTemp - this._[key + "_startTime"]) / this._duration));
             // 斜率
-            let t = 0;
+            var t = 0;
             // 微分法 求斜率t
             while (bezier(this._Xbezier, t + 0.1) < timeProgress) {
                 t += 0.1;
@@ -104,45 +157,56 @@ export default class Transition {
         }
         // `没有 ${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;
-    }
+    };
+    Transition.prototype.set = function (param) {
+        return __awaiter(this, void 0, void 0, function () {
+            var timetemp, key;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        timetemp = performance.now() + this._delay;
+                        ;
+                        for (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) return [3 /*break*/, 2];
+                        threeUtils.removeEventListener("requestAnimationFrame", this.runbindThis);
+                        threeUtils.addEventListener("requestAnimationFrame", this.runbindThis);
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, _this._duration + 50); })];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, this];
+                }
+            });
+        });
+    };
     // 重置起始和终止位置
-    reset(param) {
-        for (let key in param) {
+    Transition.prototype.reset = function (param) {
+        for (var key in param) {
             if (!this._keys.includes(key)) {
                 this._keys.push(key);
             }
@@ -155,32 +219,32 @@ export default class Transition {
         }
         this._isDone = true;
         return this;
-    }
+    };
     // 获取过渡对象上面的key
-    getKeys() {
-        return [...this._keys];
-    }
+    Transition.prototype.getKeys = function () {
+        return __spreadArray([], this._keys, true);
+    };
     // 判断是否有这个参数
-    hasKey(key) {
+    Transition.prototype.hasKey = function (key) {
         return this._keys.includes(key);
-    }
+    };
     // 获取全部参数
-    getJson() {
-        let keys = this.getKeys();
-        let json = {};
-        keys.map(key => {
-            json[key] = this.get(key);
+    Transition.prototype.getJson = function () {
+        var _this = this;
+        var keys = this.getKeys();
+        var json = {};
+        keys.map(function (key) {
+            json[key] = _this.get(key);
         });
         return json;
-    }
-    _isDone = false;
+    };
     // 是否执行完成了
-    isDone() {
+    Transition.prototype.isDone = function () {
         if (this._isDone) {
             return true;
         }
-        let isisDone = false;
-        for (let i in this._keys) {
+        var isisDone = false;
+        for (var i in this._keys) {
             isisDone = this._[this._keys[i] + "_startTime"] + this._duration < this.timeTemp;
             // 只要有一个没有完成 都算没有完成 过渡
             if (!isisDone) {
@@ -192,5 +256,7 @@ export default class Transition {
             return false;
         }
         return true;
-    }
-}
+    };
+    return Transition;
+}());
+export default Transition;

package/lib/keyContorls.js

@@ -4,6 +4,32 @@
  * @Last Modified by: xiaosihan
  * @Last Modified time: 2022-09-30 00:12:28
  */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import { throttle } from "lodash";
 import { EventDispatcher, Vector3 } from "three";
 import { generateUUID } from "three/src/math/MathUtils";
@@ -13,86 +39,88 @@ import { generateUUID } from "three/src/math/MathUtils";
  * @class KeyContorls
  * @extends {EventDispatcher}
  */
-class KeyContorls extends EventDispatcher {
-    constructor() {
-        super();
-        this.addEvent();
+var KeyContorls = /** @class */ (function (_super) {
+    __extends(KeyContorls, _super);
+    function KeyContorls() {
+        var _this = _super.call(this) || this;
+        _this.uuid = generateUUID();
+        _this.direction = new Vector3(0, 0, 0);
+        _this.keyDown = function (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
+            });
+        };
+        // 节流 删除事件监听
+        _this.removeEvent = throttle(function (type) {
+            _this._listeners = undefined;
+        }, 1000, { trailing: false });
+        _this.addEvent();
+        return _this;
     }
-    uuid = generateUUID();
-    direction = new Vector3(0, 0, 0);
     // 添加事件需要由外部实现
-    add(e) {
-        this.dispatchEvent({ ...e, type: "add" });
-    }
+    KeyContorls.prototype.add = function (e) {
+        this.dispatchEvent(__assign(__assign({}, e), { type: "add" }));
+    };
     // 删除事件
-    delete(e) {
-        this.dispatchEvent({ ...e, type: "delete" });
-    }
+    KeyContorls.prototype.delete = function (e) {
+        this.dispatchEvent(__assign(__assign({}, 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
-        });
+    KeyContorls.prototype.enter = function (e) {
+        this.dispatchEvent(__assign(__assign({}, e), { type: "enter" }));
     };
-    _listeners;
-    // 节流 删除事件监听
-    removeEvent = throttle((type) => {
-        this._listeners = undefined;
-    }, 1000, { trailing: false });
-    addEventListener(type, listener) {
+    KeyContorls.prototype.addEventListener = function (type, listener) {
         this.removeEvent(type);
-        super.addEventListener(type, listener);
-    }
-    addEvent() {
+        _super.prototype.addEventListener.call(this, type, listener);
+    };
+    KeyContorls.prototype.addEvent = function () {
         document.addEventListener("keydown", this.keyDown);
-    }
-    dispose() {
+    };
+    KeyContorls.prototype.dispose = function () {
         document.removeEventListener("keydown", this.keyDown);
-    }
-}
-const keyContorls = new KeyContorls();
+    };
+    return KeyContorls;
+}(EventDispatcher));
+var keyContorls = new KeyContorls();
 export default keyContorls;