three-base 1.0.81 → 1.0.82

package/lib/ThreeBase.js

@@ -4,6 +4,66 @@
  * @Last Modified by: xiaosihan
  * @Last Modified time: 2023-03-16 14:31:32
  */
+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 __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 { round } from "lodash";
 import { AxesHelper, EventDispatcher, GridHelper, LinearFilter, Mesh, MOUSE, NoBlending, NormalBlending, PerspectiveCamera, RGBAFormat, Scene, TOUCH, Vector2, Vector3, WebGLRenderer, WebGLRenderTarget } from "three";
 import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
@@ -14,79 +74,128 @@ import ThreeMouse from "./ThreeMouse";
 import threeUtils from "./threeUtils";
 import Transition from "./Transition";
 // three.js 的基础对象
-export default class ThreeBase extends EventDispatcher {
-    constructor() {
-        super();
-        this.init();
+var ThreeBase = /** @class */ (function (_super) {
+    __extends(ThreeBase, _super);
+    function ThreeBase() {
+        var _this = _super.call(this) || this;
+        // 公用渲染目标1
+        _this.renderTarget = new WebGLRenderTarget(128, 128, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
+        // 渲染目标2
+        _this.renderTarget2 = new WebGLRenderTarget(128, 128, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
+        // 公用二维向量
+        _this.tempVector2 = new Vector2();
+        // 公用的三维向量
+        _this.tempVector3 = new Vector3();
+        //渲染器的尺寸
+        _this.size = new Vector2(0, 0);
+        // 渲染器对象
+        _this.renderer = (function () {
+            var renderer = new WebGLRenderer({
+                alpha: true,
+                antialias: true,
+                precision: "highp",
+                logarithmicDepthBuffer: true,
+                preserveDrawingBuffer: false,
+                stencil: false, // 模版
+            });
+            renderer.domElement.id = generateUUID();
+            renderer.localClippingEnabled = true;
+            renderer.setPixelRatio(window.devicePixelRatio);
+            renderer.autoClear = false;
+            threeLoader.setAnisotropy(renderer.capabilities.getMaxAnisotropy());
+            return renderer;
+        })();
+        //透视相机
+        _this.camera = new PerspectiveCamera(45, 1, 0.0001, 10000);
+        // 场景对象
+        _this.scene = new Scene();
+        ///鼠标事件对象
+        _this.threeMouse = new ThreeMouse(_this.renderer, _this.camera, _this.scene);
+        // 轨道控制器
+        _this.controls = (function () {
+            var controls = new OrbitControls(_this.camera, _this.renderer.domElement);
+            controls.addEventListener("change", function () {
+                _this.needRender = true;
+            });
+            controls.rotateSpeed = 0.2;
+            controls.maxPolarAngle = Math.PI;
+            controls.enableDamping = true;
+            controls.dampingFactor = 0.1;
+            controls.screenSpacePanning = true;
+            return controls;
+        })();
+        // 上下文是否被销毁了
+        _this.isRendererContextLost = false;
+        // 控制器的位置缓动的计算的顶点对象
+        _this.controlsPosition = (function () {
+            var controlsPosition = new Transition({ x: 100, y: 100, z: 100 });
+            controlsPosition.setDuration(1000);
+            controlsPosition.onChange(function (_a) {
+                var x = _a.x, y = _a.y, z = _a.z;
+                _this.camera.position.set(x, y, z);
+                _this.camera.lookAt(_this.controls.target);
+                _this.needRender = true;
+            });
+            return controlsPosition;
+        })();
+        // 控制器的 朝向带缓动的计算的顶点对象
+        _this.controlsCenter = (function () {
+            var controlsCenter = new Transition({ x: 0, y: 0, z: 0 });
+            controlsCenter.setDuration(1000);
+            controlsCenter.onChange(function (_a) {
+                var x = _a.x, y = _a.y, z = _a.z;
+                _this.controls.target.set(x, y, z);
+                _this.camera.lookAt(_this.controls.target);
+                _this.needRender = true;
+            });
+            return controlsCenter;
+        })();
+        // 控制器类型
+        _this.controlType = "OrbitControls";
+        // 记录一下空间平移方式 在切换控制器的时候保留一下平移方式
+        _this.originScreenSpacePanning = false;
+        // 是否自动渲染
+        _this.autoRender = true;
+        //是否需要渲染, 当autoRender=false的时候就需要 手动触发渲染
+        _this.needRender = false;
+        _this.renderBindThis = _this.render.bind(_this);
+        _this._preMesh = new Mesh();
+        _this._preRT = new WebGLRenderTarget(128, 128, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
+        _this.init();
+        return _this;
     }
-    // 公用渲染目标1
-    renderTarget = new WebGLRenderTarget(128, 128, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
-    // 渲染目标2
-    renderTarget2 = new WebGLRenderTarget(128, 128, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
-    // 公用二维向量
-    tempVector2 = new Vector2();
-    // 公用的三维向量
-    tempVector3 = new Vector3();
-    //渲染器的尺寸
-    size = new Vector2(0, 0);
-    // 渲染器对象
-    renderer = (() => {
-        const renderer = new WebGLRenderer({
-            alpha: true,
-            antialias: true,
-            precision: "highp",
-            logarithmicDepthBuffer: true,
-            preserveDrawingBuffer: false,
-            stencil: false, // 模版
-        });
-        renderer.domElement.id = generateUUID();
-        renderer.localClippingEnabled = true;
-        renderer.setPixelRatio(window.devicePixelRatio);
-        renderer.autoClear = false;
-        threeLoader.setAnisotropy(renderer.capabilities.getMaxAnisotropy());
-        return renderer;
-    })();
-    //透视相机
-    camera = new PerspectiveCamera(45, 1, 0.0001, 10000);
-    // 场景对象
-    scene = new Scene();
-    ///鼠标事件对象
-    threeMouse = new ThreeMouse(this.renderer, this.camera, this.scene);
-    // 轨道控制器
-    controls = (() => {
-        const controls = new OrbitControls(this.camera, this.renderer.domElement);
-        controls.addEventListener("change", () => {
-            this.needRender = true;
-        });
-        controls.rotateSpeed = 0.2;
-        controls.maxPolarAngle = Math.PI;
-        controls.enableDamping = true;
-        controls.dampingFactor = 0.1;
-        controls.screenSpacePanning = true;
-        return controls;
-    })();
-    // 上下文是否被销毁了
-    isRendererContextLost = false;
     // 设置 dom 容器
-    async setContainer(div) {
-        if (div) {
-            div.innerHTML = "";
-            div.append(this.renderer.domElement);
-            // 如果上下文被销毁了,  就恢复上下文
-            if (this.isRendererContextLost) {
-                this.renderer.forceContextRestore();
-                await new Promise(resolve => requestAnimationFrame(resolve));
-                await new Promise(resolve => requestAnimationFrame(resolve));
-                this.renderer.domElement.style.opacity = "1";
-            }
-            this.setsize(div.clientWidth, div.clientHeight);
-            // 开启时时渲染
-            threeUtils.removeEventListener("requestAnimationFrame", this.renderBindThis);
-            threeUtils.addEventListener("requestAnimationFrame", this.renderBindThis);
-        }
-    }
+    ThreeBase.prototype.setContainer = function (div) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!div) return [3 /*break*/, 4];
+                        div.innerHTML = "";
+                        div.append(this.renderer.domElement);
+                        if (!this.isRendererContextLost) return [3 /*break*/, 3];
+                        this.renderer.forceContextRestore();
+                        return [4 /*yield*/, new Promise(function (resolve) { return requestAnimationFrame(resolve); })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, new Promise(function (resolve) { return requestAnimationFrame(resolve); })];
+                    case 2:
+                        _a.sent();
+                        this.renderer.domElement.style.opacity = "1";
+                        _a.label = 3;
+                    case 3:
+                        this.setsize(div.clientWidth, div.clientHeight);
+                        // 开启时时渲染
+                        threeUtils.removeEventListener("requestAnimationFrame", this.renderBindThis);
+                        threeUtils.addEventListener("requestAnimationFrame", this.renderBindThis);
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
     // 修改尺寸
-    setsize(width, height) {
+    ThreeBase.prototype.setsize = function (width, height) {
         if (this.camera instanceof PerspectiveCamera) {
             this.camera.aspect = width / height;
             this.camera.updateProjectionMatrix();
@@ -97,45 +206,25 @@ export default class ThreeBase extends EventDispatcher {
         // 渲染场景
         this.renderer.clear();
         this.renderer.render(this.scene, this.camera);
-    }
-    // 控制器的位置缓动的计算的顶点对象
-    controlsPosition = (() => {
-        const controlsPosition = new Transition({ x: 100, y: 100, z: 100 });
-        controlsPosition.setDuration(1000);
-        controlsPosition.onChange(({ x, y, z }) => {
-            this.camera.position.set(x, y, z);
-            this.camera.lookAt(this.controls.target);
-            this.needRender = true;
-        });
-        return controlsPosition;
-    })();
-    // 控制器的 朝向带缓动的计算的顶点对象
-    controlsCenter = (() => {
-        const controlsCenter = new Transition({ x: 0, y: 0, z: 0 });
-        controlsCenter.setDuration(1000);
-        controlsCenter.onChange(({ x, y, z }) => {
-            this.controls.target.set(x, y, z);
-            this.camera.lookAt(this.controls.target);
-            this.needRender = true;
-        });
-        return controlsCenter;
-    })();
-    init() {
+    };
+    ThreeBase.prototype.init = function () {
+        var _this = this;
         // 非开发模式添加网格辅助线
         if (threeUtils.isDev) {
-            const gridHelper = new GridHelper(1000, 100, 0x303030, 0x303030);
+            var gridHelper = new GridHelper(1000, 100, 0x303030, 0x303030);
             gridHelper.position.set(0, -0.001, 0);
             this.scene.add(gridHelper);
-            const axesHelper = new AxesHelper(10000);
+            var axesHelper = new AxesHelper(10000);
             this.scene.add(axesHelper);
         }
         // 资源加载进度有更新时, 需要渲染
-        threeLoader.addEventListener("progress", () => {
-            this.needRender = true;
+        threeLoader.addEventListener("progress", function () {
+            _this.needRender = true;
         });
-    }
+    };
     // 重置控制器的位置
-    resetLookAt({ position, center, }) {
+    ThreeBase.prototype.resetLookAt = function (_a) {
+        var position = _a.position, center = _a.center;
         // 停止控制器的惯性
         this.controls.enableDamping = false;
         this.controls.saveState();
@@ -145,57 +234,85 @@ export default class ThreeBase extends EventDispatcher {
         position && this.controlsPosition.reset({ x: position.x, y: position.y, z: position.z });
         center && this.controlsCenter.reset({ x: center.x, y: center.y, z: center.z });
         this.needRender = true;
-    }
+    };
     // 设置控制器的位置 以动画的方式移动控制器
-    async setLookAt({ position, center, duration = 1000 }) {
-        // 停止控制器的惯性
-        this.controls.enableDamping = false;
-        this.controls.saveState();
-        this.controls.update();
-        this.controls.reset();
-        this.controls.enableDamping = true;
-        let currentPosition = this.camera.position.clone();
-        let currentCenter = this.controls.target.clone();
-        // 等待动画执行完成
-        await Promise.all([
-            new Promise(async (resolve, reject) => {
-                if (position) {
-                    this.controlsPosition.setDuration(duration).reset({ x: currentPosition.x, y: currentPosition.y, z: currentPosition.z });
-                    await this.controlsPosition.set({ x: position.x, y: position.y, z: position.z });
+    ThreeBase.prototype.setLookAt = function (_a) {
+        var position = _a.position, center = _a.center, _b = _a.duration, duration = _b === void 0 ? 1000 : _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var currentPosition, currentCenter;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        // 停止控制器的惯性
+                        this.controls.enableDamping = false;
+                        this.controls.saveState();
+                        this.controls.update();
+                        this.controls.reset();
+                        this.controls.enableDamping = true;
+                        currentPosition = this.camera.position.clone();
+                        currentCenter = this.controls.target.clone();
+                        // 等待动画执行完成
+                        return [4 /*yield*/, Promise.all([
+                                new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                if (!position) return [3 /*break*/, 2];
+                                                this.controlsPosition.setDuration(duration).reset({ x: currentPosition.x, y: currentPosition.y, z: currentPosition.z });
+                                                return [4 /*yield*/, this.controlsPosition.set({ x: position.x, y: position.y, z: position.z })];
+                                            case 1:
+                                                _a.sent();
+                                                _a.label = 2;
+                                            case 2:
+                                                resolve();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); }),
+                                new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                if (!center) return [3 /*break*/, 2];
+                                                this.controlsCenter.setDuration(duration).reset({ x: currentCenter.x, y: currentCenter.y, z: currentCenter.z });
+                                                return [4 /*yield*/, this.controlsCenter.set({ x: center.x, y: center.y, z: center.z })];
+                                            case 1:
+                                                _a.sent();
+                                                _a.label = 2;
+                                            case 2:
+                                                resolve();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); }),
+                            ])];
+                    case 1:
+                        // 等待动画执行完成
+                        _c.sent();
+                        return [2 /*return*/];
                 }
-                resolve();
-            }),
-            new Promise(async (resolve, reject) => {
-                if (center) {
-                    this.controlsCenter.setDuration(duration).reset({ x: currentCenter.x, y: currentCenter.y, z: currentCenter.z });
-                    await this.controlsCenter.set({ x: center.x, y: center.y, z: center.z });
-                }
-                resolve();
-            }),
-        ]);
-    }
+            });
+        });
+    };
     // 获取控制的位置和朝向 保留3位小数
-    getLookAt() {
-        const position = this.camera.position.toArray().map(v => round(v, 3));
-        const center = this.controls.target.toArray().map(v => round(v, 3));
+    ThreeBase.prototype.getLookAt = function () {
+        var position = this.camera.position.toArray().map(function (v) { return round(v, 3); });
+        var center = this.controls.target.toArray().map(function (v) { return round(v, 3); });
         return {
-            center: new Vector3(...center),
-            position: new Vector3(...position),
-            centerPosition: `center: new Vector3(${center.join(",")}),position: new Vector3(${position.join(",")})`
+            center: new (Vector3.bind.apply(Vector3, __spreadArray([void 0], center, false)))(),
+            position: new (Vector3.bind.apply(Vector3, __spreadArray([void 0], position, false)))(),
+            centerPosition: "center: new Vector3(".concat(center.join(","), "),position: new Vector3(").concat(position.join(","), ")")
         };
-    }
+    };
     // 三维向量转化成屏幕上的2维向量
-    v3tov2(v3) {
+    ThreeBase.prototype.v3tov2 = function (v3) {
         v3.project(this.camera);
-        const v2 = new Vector2((v3.x + 1) * this.size.x * 0.5, (-v3.y + 1) * this.size.y * 0.5);
+        var v2 = new Vector2((v3.x + 1) * this.size.x * 0.5, (-v3.y + 1) * this.size.y * 0.5);
         return v2;
-    }
-    // 控制器类型
-    controlType = "OrbitControls";
-    // 记录一下空间平移方式 在切换控制器的时候保留一下平移方式
-    originScreenSpacePanning = false;
+    };
     //改变控制器的类型
-    setControlType(controlType) {
+    ThreeBase.prototype.setControlType = function (controlType) {
         if (controlType === "OrbitControls") {
             this.controls.screenSpacePanning = this.originScreenSpacePanning;
             this.controls.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN };
@@ -210,22 +327,18 @@ export default class ThreeBase extends EventDispatcher {
             this.controls.touches.ONE = TOUCH.PAN;
             this.controls.touches.TWO = TOUCH.DOLLY_ROTATE;
         }
-    }
-    // 是否自动渲染
-    autoRender = true;
-    //是否需要渲染, 当autoRender=false的时候就需要 手动触发渲染
-    needRender = false;
+    };
     // 停止渲染
-    stopRender() {
+    ThreeBase.prototype.stopRender = function () {
         threeUtils.removeEventListener("requestAnimationFrame", this.renderBindThis);
         this.renderer.forceContextLoss();
         // 标记上下文被销毁了
         this.isRendererContextLost = true;
         this.setsize(100, 100);
         this.renderer.domElement.style.opacity = "0";
-    }
+    };
     // 渲染场景
-    render() {
+    ThreeBase.prototype.render = function () {
         // 控制器在移动时鼠标不能操作
         this.controls.enabled = (this.controlsPosition.isDone() || this.controlsCenter.isDone());
         // canvas 没有在页面上面的话 就跳过渲染
@@ -234,7 +347,7 @@ export default class ThreeBase extends EventDispatcher {
             return;
         }
         //判断尺寸发生改变时重置尺寸
-        const parentNode = this.renderer.domElement.parentNode;
+        var parentNode = this.renderer.domElement.parentNode;
         if (parentNode.clientWidth !== this.size.x || parentNode.clientHeight !== this.size.y) {
             this.setsize(parentNode.clientWidth, parentNode.clientHeight);
         }
@@ -253,58 +366,79 @@ export default class ThreeBase extends EventDispatcher {
         this.dispatchEvent({ type: "beforeRender" });
         this.renderer.render(this.scene, this.camera);
         this.dispatchEvent({ type: "afterRender" });
-    }
-    renderBindThis = this.render.bind(this);
+    };
     // 下载渲染图
-    download(fileName = "download") {
+    ThreeBase.prototype.download = function (fileName) {
+        if (fileName === void 0) { fileName = "download"; }
         this.render();
-        const base64 = this.renderer.domElement.toDataURL('image/png');
-        let saveLink = document.createElement("a");
-        saveLink.download = `${fileName}.png`;
+        var base64 = this.renderer.domElement.toDataURL('image/png');
+        var saveLink = document.createElement("a");
+        saveLink.download = "".concat(fileName, ".png");
         saveLink.href = base64;
         document.body.append(saveLink);
         saveLink.click();
-    }
-    _preMesh = new Mesh();
-    _preRT = new WebGLRenderTarget(128, 128, { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat });
+    };
     //预加载纹理图片
-    async preloadTexture(src) {
-        const texture = threeLoader.getTexture(src);
-        while (texture && !texture.image || !texture.image.complete) {
-            await new Promise(resolve => setTimeout(resolve, 50));
-        }
-        // 添加到计划任务中去
-        threeUtils.addWork(() => {
-            const originRenderTarget = this.renderer.getRenderTarget();
-            this.renderer.setRenderTarget(this._preRT);
-            this._preMesh.material.map = texture;
-            this.renderer.render(this._preMesh, this.camera);
-            this.renderer.setRenderTarget(originRenderTarget);
+    ThreeBase.prototype.preloadTexture = function (src) {
+        return __awaiter(this, void 0, void 0, function () {
+            var texture;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        texture = threeLoader.getTexture(src);
+                        _a.label = 1;
+                    case 1:
+                        if (!(texture && !texture.image || !texture.image.complete)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 50); })];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 3:
+                        // 添加到计划任务中去
+                        threeUtils.addWork(function () {
+                            var originRenderTarget = _this.renderer.getRenderTarget();
+                            _this.renderer.setRenderTarget(_this._preRT);
+                            _this._preMesh.material.map = texture;
+                            _this.renderer.render(_this._preMesh, _this.camera);
+                            _this.renderer.setRenderTarget(originRenderTarget);
+                        });
+                        return [2 /*return*/];
+                }
+            });
         });
-    }
+    };
     //预加载网格
-    async preloadGeometry(geometry) {
-        // 添加到计划任务中去
-        threeUtils.addWork(() => {
-            const originRenderTarget = this.renderer.getRenderTarget();
-            this.renderer.setRenderTarget(this._preRT);
-            this._preMesh.geometry = geometry;
-            this.renderer.render(this._preMesh, this.camera);
-            this.renderer.setRenderTarget(originRenderTarget);
+    ThreeBase.prototype.preloadGeometry = function (geometry) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                // 添加到计划任务中去
+                threeUtils.addWork(function () {
+                    var originRenderTarget = _this.renderer.getRenderTarget();
+                    _this.renderer.setRenderTarget(_this._preRT);
+                    _this._preMesh.geometry = geometry;
+                    _this.renderer.render(_this._preMesh, _this.camera);
+                    _this.renderer.setRenderTarget(originRenderTarget);
+                });
+                return [2 /*return*/];
+            });
         });
-    }
+    };
     // 清理渲染目标
-    clearRendererTargte(rendererTarget) {
-        const originTarget = this.renderer.getRenderTarget();
+    ThreeBase.prototype.clearRendererTargte = function (rendererTarget) {
+        var originTarget = this.renderer.getRenderTarget();
         this.renderer.setRenderTarget(rendererTarget);
         fullScreenMesh.material = clearShader;
         fullScreenMesh.render(this.renderer);
         this.renderer.clearDepth();
         this.renderer.setRenderTarget(originTarget);
-    }
+    };
     // 拷贝纹理到渲染目标
-    copyTextureToRenderTarget(texture, rendererTarget, alpha = false, opactity = 1) {
-        const originTarget = this.renderer.getRenderTarget();
+    ThreeBase.prototype.copyTextureToRenderTarget = function (texture, rendererTarget, alpha, opactity) {
+        if (alpha === void 0) { alpha = false; }
+        if (opactity === void 0) { opactity = 1; }
+        var originTarget = this.renderer.getRenderTarget();
         if (rendererTarget) {
             this.renderer.getSize(this.tempVector2);
             rendererTarget.setSize(this.tempVector2.x, this.tempVector2.y);
@@ -316,20 +450,20 @@ export default class ThreeBase extends EventDispatcher {
         coptyShader.blending = alpha ? NoBlending : NormalBlending;
         fullScreenMesh.render(this.renderer);
         this.renderer.setRenderTarget(originTarget);
-    }
+    };
     // 把对象绘制到渲染目标中
-    object3dToRendererTarget(obj, rendererTarget) {
+    ThreeBase.prototype.object3dToRendererTarget = function (obj, rendererTarget) {
         this.clearRendererTargte(rendererTarget);
-        const originTarget = this.renderer.getRenderTarget();
+        var originTarget = this.renderer.getRenderTarget();
         this.renderer.setRenderTarget(rendererTarget);
         this.renderer.getSize(this.tempVector2);
         rendererTarget.setSize(this.tempVector2.x, this.tempVector2.y);
         this.renderer.render(obj, this.camera);
         this.renderer.setRenderTarget(originTarget);
-    }
+    };
     // 给渲染目标的内容加描边
-    rendererTagetAddStroke(rendererTarget, strockWidth, color, opacity) {
-        const originTarget = this.renderer.getRenderTarget();
+    ThreeBase.prototype.rendererTagetAddStroke = function (rendererTarget, strockWidth, color, opacity) {
+        var originTarget = this.renderer.getRenderTarget();
         this.clearRendererTargte(this.renderTarget2);
         this.renderer.setRenderTarget(this.renderTarget2);
         this.renderer.getSize(this.tempVector2);
@@ -343,16 +477,16 @@ export default class ThreeBase extends EventDispatcher {
         fullScreenMesh.render(this.renderer);
         this.copyTextureToRenderTarget(this.renderTarget2.texture, rendererTarget, true);
         this.renderer.setRenderTarget(originTarget);
-    }
+    };
     // 渲染对象的描边
-    renderObject3dStroke(obj, strockWidth, color, opacity) {
+    ThreeBase.prototype.renderObject3dStroke = function (obj, strockWidth, color, opacity) {
         this.object3dToRendererTarget(obj, this.renderTarget);
         this.rendererTagetAddStroke(this.renderTarget, strockWidth, color, opacity);
         this.copyTextureToRenderTarget(this.renderTarget.texture, null);
-    }
+    };
     //给渲染目标加上高斯模糊计算
-    renderTargetgaussBlur(rendererTarget, radius, opacity) {
-        const originTarget = this.renderer.getRenderTarget();
+    ThreeBase.prototype.renderTargetgaussBlur = function (rendererTarget, radius, opacity) {
+        var originTarget = this.renderer.getRenderTarget();
         this.clearRendererTargte(this.renderTarget2);
         this.renderer.setRenderTarget(this.renderTarget2);
         this.renderer.getSize(this.tempVector2);
@@ -365,22 +499,25 @@ export default class ThreeBase extends EventDispatcher {
         fullScreenMesh.render(this.renderer);
         this.copyTextureToRenderTarget(this.renderTarget2.texture, rendererTarget, true);
         this.renderer.setRenderTarget(originTarget);
-    }
+    };
     // 渲染目标上的纹理添加辉光效果
-    renderTargetAddGlow(renderTarget, width, color) {
+    ThreeBase.prototype.renderTargetAddGlow = function (renderTarget, width, color) {
         this.rendererTagetAddStroke(renderTarget, 1 * width, color, 0.3);
         this.rendererTagetAddStroke(renderTarget, 2 * width, color, 0.2);
         this.rendererTagetAddStroke(renderTarget, 3 * width, color, 0.05);
         this.renderTargetgaussBlur(renderTarget, 1, 1);
         this.renderTargetgaussBlur(renderTarget, 1, 1);
         this.renderTargetgaussBlur(renderTarget, 1, 1);
-    }
+    };
     // 渲染 渲染目标
-    renderRendererTarget(renderTarget, alpha = false) {
+    ThreeBase.prototype.renderRendererTarget = function (renderTarget, alpha) {
+        if (alpha === void 0) { alpha = false; }
         coptyShader.uniforms.map.value = renderTarget.texture;
         coptyShader.uniforms.opacity.value = 1.0;
         fullScreenMesh.material = coptyShader;
         coptyShader.blending = alpha ? NoBlending : NormalBlending;
         fullScreenMesh.render(this.renderer);
-    }
-}
+    };
+    return ThreeBase;
+}(EventDispatcher));
+export default ThreeBase;