@anov/3d 0.0.1 → 0.0.2

package/dist/core/group.d.ts

@@ -1,8 +1,53 @@
-import { Group } from 'three';
-declare class Anov3DGroup extends Group {
+import type { Intersection, Object3D } from 'three';
+import { Group as TGroup } from 'three';
+import type { CubeEventType, EventHandleFn } from '../type';
+declare class Group extends TGroup {
+    private natureEventMap;
+    private object3d;
     constructor();
+    /**
+     * add model
+     * @param object
+     */
+    addModel(object: Object3D): void;
+    /**
+     * addNatureEventListener
+     * @param type
+     * @param handlefn
+     */
+    addNatureEventListener<T extends CubeEventType>(type: T, handlefn: EventHandleFn<T>): void;
+    /**
+     * removeNatureEventListener
+     * @param type
+     * @param handlefn
+     */
+    removeNatureEventListener<T extends CubeEventType>(type: T, handlefn: EventHandleFn<T>): void;
+    /**
+     * removeAllNatureEventListener
+     */
+    removeAllNatureEventListener(): void;
+    /**
+     * handle intersect event
+     * @param intersects
+     * @param eventType
+    */
+    private handleClick;
+    /**
+     * handle pointermove event
+     * @param intersects
+     * @param natureEvent
+     */
+    private handlePointerMove;
+    /**
+     * handle pointerleave event
+     * @param intersects
+     * @param natureEvent
+     */
+    private handlePointerleave;
+    /**
+     * raycastGroup
+     * handle intersect event
+     */
+    raycastGroup(intersets: Intersection<Object3D<Event>>[]): void;
 }
-/**
- *
- */
-export default Anov3DGroup;
+export default Group;

package/dist/core/group.js

@@ -1,9 +1,9 @@
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
@@ -11,17 +11,125 @@ function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) ===
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-import { Group } from 'three';
-var Anov3DGroup = /*#__PURE__*/function (_Group) {
-  _inherits(Anov3DGroup, _Group);
-  var _super = _createSuper(Anov3DGroup);
-  function Anov3DGroup() {
-    _classCallCheck(this, Anov3DGroup);
-    return _super.call(this);
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { Group as TGroup } from 'three';
+import globalObjectManage from "./global/global";
+var Group = /*#__PURE__*/function (_TGroup) {
+  _inherits(Group, _TGroup);
+  var _super = _createSuper(Group);
+  function Group() {
+    var _this;
+    _classCallCheck(this, Group);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "natureEventMap", new Map());
+    _defineProperty(_assertThisInitialized(_this), "object3d", []);
+    globalObjectManage.addCatch(_assertThisInitialized(_this));
+    return _this;
   }
-  return _createClass(Anov3DGroup);
-}(Group);
-/**
- *
- */
-export default Anov3DGroup;
+
+  /**
+   * add model
+   * @param object
+   */
+  _createClass(Group, [{
+    key: "addModel",
+    value: function addModel(object) {
+      _get(_getPrototypeOf(Group.prototype), "add", this).call(this, object);
+      this.object3d.push(object);
+    }
+
+    /**
+     * addNatureEventListener
+     * @param type
+     * @param handlefn
+     */
+  }, {
+    key: "addNatureEventListener",
+    value: function addNatureEventListener(type, handlefn) {
+      if (!this.natureEventMap.has(type)) this.natureEventMap.set(type, []);
+      this.natureEventMap.get(type).push(handlefn);
+    }
+
+    /**
+     * removeNatureEventListener
+     * @param type
+     * @param handlefn
+     */
+  }, {
+    key: "removeNatureEventListener",
+    value: function removeNatureEventListener(type, handlefn) {
+      if (!this.natureEventMap.has(type)) return;
+      var handlefns = this.natureEventMap.get(type);
+      var index = handlefns.findIndex(function (fn) {
+        return fn === handlefn;
+      });
+      if (index > -1) handlefns.splice(index, 1);
+    }
+
+    /**
+     * removeAllNatureEventListener
+     */
+  }, {
+    key: "removeAllNatureEventListener",
+    value: function removeAllNatureEventListener() {
+      this.natureEventMap.clear();
+    }
+
+    /**
+     * handle intersect event
+     * @param intersects
+     * @param eventType
+    */
+  }, {
+    key: "handleClick",
+    value: function handleClick(natureEvent) {
+      if (!globalObjectManage.triggerClick) return;
+
+      // get nature event
+      natureEvent.forEach(function (handlefn) {
+        // handlefn(this)
+      });
+    }
+
+    /**
+     * handle pointermove event
+     * @param intersects
+     * @param natureEvent
+     */
+  }, {
+    key: "handlePointerMove",
+    value: function handlePointerMove(natureEvent) {
+      natureEvent.forEach(function (handlefn) {
+        // handlefn(this)
+      });
+    }
+
+    /**
+     * handle pointerleave event
+     * @param intersects
+     * @param natureEvent
+     */
+  }, {
+    key: "handlePointerleave",
+    value: function handlePointerleave() {
+      var pointerleaveCallback = this.natureEventMap.get('pointerleave');
+      pointerleaveCallback && pointerleaveCallback.length > 0 && pointerleaveCallback.forEach(function (handlefn) {
+        // handlefn(this)
+      });
+    }
+
+    /**
+     * raycastGroup
+     * handle intersect event
+     */
+  }, {
+    key: "raycastGroup",
+    value: function raycastGroup(intersets) {
+      console.log('raycastGroup', intersets);
+    }
+  }]);
+  return Group;
+}(TGroup);
+export default Group;

package/dist/core/line.d.ts

@@ -0,0 +1,13 @@
+import { CatmullRomCurve3, Line, Vector3 } from 'three';
+import type { TransformControls } from './control/transformControls';
+declare type CatmullRomCurve3WithMesh = CatmullRomCurve3 & {
+    mesh: Line;
+};
+/**
+ * 可控制曲线
+ * @param points
+ * @param transformControl
+ * @returns
+ */
+export declare const createControlLine: (points: Vector3[], transformControl: TransformControls) => CatmullRomCurve3WithMesh;
+export {};

package/dist/core/line.js

@@ -0,0 +1,83 @@
+import { BoxGeometry, BufferAttribute, BufferGeometry, CatmullRomCurve3, Line, LineBasicMaterial, MeshBasicMaterial, Vector3 } from 'three';
+import Mesh from "./mesh";
+import globalObjectManage from "./global/global";
+var point = new Vector3(0, 0, 0);
+
+/**
+ * create control mesh
+ * @param position
+ * @param transformControl
+ * @param width
+ * @param height
+ * @param depth
+ * @returns
+ */
+var createSplineControlObject3d = function createSplineControlObject3d(position, transformControl) {
+  var width = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  var height = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+  var depth = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
+  var boxGeometry = new BoxGeometry(width, height, depth);
+  var material = new MeshBasicMaterial({
+    color: Math.random() * 0xFFFFFF
+  });
+  var object = new Mesh(boxGeometry, material);
+  object.addNatureEventListener('pointermove', function (mesh) {
+    transformControl.attach(mesh);
+  });
+  object.position.copy(position);
+  globalObjectManage.scene.add(object);
+  return object;
+};
+
+/**
+ * create line
+ * @param positions
+ * @returns
+ */
+var createCatmullRomCurve3 = function createCatmullRomCurve3(positions) {
+  var geometry = new BufferGeometry();
+  var attr = new BufferAttribute(new Float32Array(200 * 3), 3);
+  geometry.setAttribute('position', attr);
+  var curve = new CatmullRomCurve3(positions);
+  curve.mesh = new Line(geometry.clone(), new LineBasicMaterial({
+    color: 'red',
+    opacity: 1
+  }));
+  return curve;
+};
+
+/**
+ * uodate line
+ * @param curve
+ */
+var updateCatmullRomCurve3 = function updateCatmullRomCurve3(curve) {
+  var splineMesh = curve.mesh;
+  var position = splineMesh.geometry.attributes.position;
+
+  // update 200 points
+  for (var i = 0; i < 200; i++) {
+    var t = i / (200 - 1);
+    curve.getPoint(t, point);
+    position.setXYZ(i, point.x, point.y, point.z);
+  }
+  position.needsUpdate = true;
+};
+
+/**
+ * 可控制曲线
+ * @param points
+ * @param transformControl
+ * @returns
+ */
+export var createControlLine = function createControlLine(points, transformControl) {
+  var splineControlObject3d = [];
+  points.forEach(function (point) {
+    splineControlObject3d.push(createSplineControlObject3d(point, transformControl));
+  });
+  var curve = createCatmullRomCurve3(points);
+  updateCatmullRomCurve3(curve);
+  transformControl.addEventListener('objectChange', function () {
+    updateCatmullRomCurve3(curve);
+  });
+  return curve;
+};

package/dist/core/mesh.d.ts

@@ -1,10 +1,10 @@
 import type { Intersection, Raycaster } from 'three';
-import { Mesh } from 'three';
+import { Mesh as TMesh } from 'three';
 import type { CubeEventType, EventHandleFn } from '../type';
-declare class Anov3DMesh extends Mesh {
+declare class Mesh extends TMesh {
     private natureEventMap;
-    private isMove;
-    constructor(geometry?: ConstructorParameters<typeof Mesh>[0], material?: ConstructorParameters<typeof Mesh>[1]);
+    private entered;
+    constructor(geometry?: ConstructorParameters<typeof TMesh>[0], material?: ConstructorParameters<typeof TMesh>[1]);
     /**
      * addNatureEventListener
      * @param type
@@ -26,8 +26,13 @@ declare class Anov3DMesh extends Mesh {
      * @param intersects
      * @param eventType
      */
-    private eventHandle;
-    private debounceEventHandle;
+    private handleClick;
+    /**
+     * handle pointermove event
+     * @param intersects
+     * @param natureEvent
+     */
+    private handlePointerMove;
     /**
      * handle pointerleave event
      * @param intersects
@@ -41,4 +46,4 @@ declare class Anov3DMesh extends Mesh {
      */
     raycast(raycaster: Raycaster, intersects: Intersection[]): void;
 }
-export default Anov3DMesh;
+export default Mesh;

package/dist/core/mesh.js

@@ -14,19 +14,17 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-import { Mesh } from 'three';
-import { debounce } from 'lodash';
-import { emitter } from "../utils";
-var Anov3DMesh = /*#__PURE__*/function (_Mesh) {
-  _inherits(Anov3DMesh, _Mesh);
-  var _super = _createSuper(Anov3DMesh);
-  function Anov3DMesh(geometry, material) {
+import { Mesh as TMesh } from 'three';
+import globalObjectManage from "./global/global";
+var Mesh = /*#__PURE__*/function (_TMesh) {
+  _inherits(Mesh, _TMesh);
+  var _super = _createSuper(Mesh);
+  function Mesh(geometry, material) {
     var _this;
-    _classCallCheck(this, Anov3DMesh);
+    _classCallCheck(this, Mesh);
     _this = _super.call(this, geometry, material);
     _defineProperty(_assertThisInitialized(_this), "natureEventMap", new Map());
-    _defineProperty(_assertThisInitialized(_this), "isMove", false);
-    _defineProperty(_assertThisInitialized(_this), "debounceEventHandle", debounce(_this.eventHandle, 50));
+    _defineProperty(_assertThisInitialized(_this), "entered", false);
     return _this;
   }
 
@@ -35,7 +33,7 @@ var Anov3DMesh = /*#__PURE__*/function (_Mesh) {
    * @param type
    * @param handlefn
    */
-  _createClass(Anov3DMesh, [{
+  _createClass(Mesh, [{
     key: "addNatureEventListener",
     value: function addNatureEventListener(type, handlefn) {
       if (!this.natureEventMap.has(type)) this.natureEventMap.set(type, []);
@@ -73,34 +71,44 @@ var Anov3DMesh = /*#__PURE__*/function (_Mesh) {
      * @param eventType
      */
   }, {
-    key: "eventHandle",
-    value: function eventHandle(intersects, natureEvent) {
-      var intersect = intersects[0];
-      var object = intersect.object;
-      if (object === this) {
-        // get nature event
-        console.log(intersect.object);
-        natureEvent.forEach(function (handlefn) {
-          handlefn(object);
-        });
-      }
+    key: "handleClick",
+    value: function handleClick(natureEvent, intersect) {
+      var _this2 = this;
+      if (!globalObjectManage.triggerClick) return;
+
+      // get nature event
+      natureEvent.forEach(function (handlefn) {
+        handlefn(_this2, intersect);
+      });
     }
+
+    /**
+     * handle pointermove event
+     * @param intersects
+     * @param natureEvent
+     */
   }, {
-    key: "handlePointerleave",
-    value:
+    key: "handlePointerMove",
+    value: function handlePointerMove(natureEvent, intersect) {
+      var _this3 = this;
+      natureEvent.forEach(function (handlefn) {
+        handlefn(_this3, intersect);
+      });
+    }
+
     /**
      * handle pointerleave event
      * @param intersects
      * @param natureEvent
      */
-    function handlePointerleave(intersects, natureEvent) {
-      var _this2 = this;
-      if (this.isMove) {
-        this.isMove = false;
-        natureEvent.forEach(function (handlefn) {
-          handlefn(_this2);
-        });
-      }
+  }, {
+    key: "handlePointerleave",
+    value: function handlePointerleave() {
+      var _this4 = this;
+      var pointerleaveCallback = this.natureEventMap.get('pointerleave');
+      pointerleaveCallback && pointerleaveCallback.length > 0 && pointerleaveCallback.forEach(function (handlefn) {
+        handlefn(_this4);
+      });
     }
 
     /**
@@ -111,35 +119,28 @@ var Anov3DMesh = /*#__PURE__*/function (_Mesh) {
   }, {
     key: "raycast",
     value: function raycast(raycaster, intersects) {
-      var _this3 = this;
       if (this.natureEventMap.size === 0) return;
-      _get(_getPrototypeOf(Anov3DMesh.prototype), "raycast", this).call(this, raycaster, intersects);
+      _get(_getPrototypeOf(Mesh.prototype), "raycast", this).call(this, raycaster, intersects);
+      var clickCallback = this.natureEventMap.get('click');
       var pointerupCallback = this.natureEventMap.get('pointerup');
       var pointerdownCallback = this.natureEventMap.get('pointerdown');
       var pointermoveCallback = this.natureEventMap.get('pointermove');
-      var pointerleaveCallback = this.natureEventMap.get('pointerleave');
-      console.log(intersects);
-      if (intersects.length > 0) {
-        emitter.on('pointerup', function () {
-          return pointerupCallback && pointerupCallback.length > 0 && _this3.debounceEventHandle(intersects, pointerupCallback);
-        });
-        emitter.on('pointerdown', function () {
-          return pointerdownCallback && pointerdownCallback.length > 0 && _this3.debounceEventHandle(intersects, pointerdownCallback);
-        });
-        emitter.on('pointermove', function () {
-          if (pointermoveCallback && pointermoveCallback.length > 0) {
-            _this3.isMove = true;
-            _this3.eventHandle(intersects, pointermoveCallback);
-          }
-        });
+      var intersect = intersects[0];
+      var object = intersect && intersect.object;
+      if (object === this) {
+        this.entered = true;
+        clickCallback && clickCallback.length > 0 && this.handleClick(clickCallback, intersect);
+        pointerupCallback && pointerupCallback.length > 0 && this.handleClick(pointerupCallback, intersect);
+        pointerdownCallback && pointerdownCallback.length > 0 && this.handleClick(pointerdownCallback, intersect);
+        pointermoveCallback && pointermoveCallback.length > 0 && this.handlePointerMove(pointermoveCallback, intersect);
       } else {
-        console.log('pointerleave');
-        emitter.on('pointerleave', function () {
-          if (pointerleaveCallback && pointerleaveCallback.length > 0 && _this3.isMove) _this3.handlePointerleave(intersects, pointerleaveCallback);
-        });
+        if (this.entered) {
+          this.handlePointerleave();
+          this.entered = false;
+        }
       }
     }
   }]);
-  return Anov3DMesh;
-}(Mesh);
-export default Anov3DMesh;
+  return Mesh;
+}(TMesh);
+export default Mesh;

package/dist/core/model.d.ts

@@ -1,5 +1,6 @@
+import type { Group } from 'three';
 import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
-declare class Anov3DModelLoader {
+declare class ModelLoader {
     /**
      * load gltf model
      * @param url
@@ -16,6 +17,13 @@ declare class Anov3DModelLoader {
      * @param onProgress
      * @param onError
      */
-    loadFbx(url: string, onLoad?: (result: GLTF) => GLTF, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+    loadFbx(url: string, onLoad?: (result: Group) => Group, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): Promise<unknown>;
+    /**
+     * parse fbx buffer
+     * @param buffer
+     * @param path
+     * @returns
+     */
+    parseFbxBuffer(buffer: ArrayBuffer | string, path: string): Group;
 }
-export default Anov3DModelLoader;
+export default ModelLoader;

package/dist/core/model.js

@@ -6,11 +6,12 @@ function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _ty
 function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
-var Anov3DModelLoader = /*#__PURE__*/function () {
-  function Anov3DModelLoader() {
-    _classCallCheck(this, Anov3DModelLoader);
+import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader';
+var ModelLoader = /*#__PURE__*/function () {
+  function ModelLoader() {
+    _classCallCheck(this, ModelLoader);
   }
-  _createClass(Anov3DModelLoader, [{
+  _createClass(ModelLoader, [{
     key: "loadGLTF",
     value:
     /**
@@ -24,6 +25,8 @@ var Anov3DModelLoader = /*#__PURE__*/function () {
     function loadGLTF(url, onLoad, onProgress, onError) {
       var loader = new GLTFLoader();
       var dracoLoader = new DRACOLoader();
+
+      // todo: 调优
       dracoLoader.setDecoderPath('./draco/');
       dracoLoader.setDecoderConfig({
         type: 'js'
@@ -51,8 +54,32 @@ var Anov3DModelLoader = /*#__PURE__*/function () {
      */
   }, {
     key: "loadFbx",
-    value: function loadFbx(url, onLoad, onProgress, onError) {}
+    value: function loadFbx(url, onLoad, onProgress, onError) {
+      var fbxLoader = new FBXLoader();
+      return new Promise(function (resolve, reject) {
+        fbxLoader.load(url, function (fbx) {
+          onLoad ? resolve(onLoad(fbx)) : resolve(fbx);
+        }, function (xhr) {
+          onProgress && onProgress(xhr);
+        }, function (err) {
+          onError && onError(err);
+          reject(err);
+        });
+      });
+    }
+
+    /**
+     * parse fbx buffer
+     * @param buffer
+     * @param path
+     * @returns
+     */
+  }, {
+    key: "parseFbxBuffer",
+    value: function parseFbxBuffer(buffer, path) {
+      return new FBXLoader().parse(buffer, path);
+    }
   }]);
-  return Anov3DModelLoader;
+  return ModelLoader;
 }();
-export default Anov3DModelLoader;
+export default ModelLoader;