@anov/3d 0.0.1-alpha.0

package/README.md

@@ -0,0 +1,65 @@
+# anov-3d
+
+> anov 3d 核心包
+
+### usage
+
+install
+
+```bash
+pnpm add @anov/3d
+```
+
+init a base scene 「wip」
+
+```ts
+import { Anov3DMesh, Anove3DScene  } from '@anov/3d'
+import { BoxGeometry, MeshBasicMaterial } from 'three'
+
+const scene = new Anove3DScene({
+  orbitControls: true,
+})
+
+const geometry = new BoxGeometry(2, 2, 2)
+const material = new MeshBasicMaterial({ color: 0x00FF00 })
+const box = new Anov3DMesh(geometry, material)
+
+box.addNatureEventListener('pointerdown', (object3D) => {
+  (object3D.material as any).color.set(0xFF0000)
+})
+
+scene.add(box)
+
+scene.render(document.querySelector('#app')!)
+scene.startFrameAnimate()
+```
+
+base object3d motion 「wip」
+
+```ts
+import { Anov3DMesh, Anove3DScene, utils } from '@anov/3d'
+import { AxesHelper, BoxGeometry, GridHelper, MeshBasicMaterial } from 'three'
+
+const scene = new Anove3DScene({
+  orbitControls: true,
+})
+
+const geometry = new BoxGeometry(2, 2, 2)
+const material = new MeshBasicMaterial({ color: 0x00FF00 })
+const box = new Anov3DMesh(geometry, material)
+
+const geometry2 = new BoxGeometry(2, 2, 2)
+const materia2 = new MeshBasicMaterial({ color: '#ccc' })
+const box2 = new Anov3DMesh(geometry2, materia2)
+
+box.position.set(0, 0, 0)
+box2.position.set(10, 30, -30)
+
+scene.add(box)
+scene.add(box2)
+
+utils.moveWithRound(box2, 0.2, 100000)
+
+scene.render(document.querySelector('#app')!)
+scene.startFrameAnimate()
+```

package/dist/commonEnu.d.ts

@@ -0,0 +1,5 @@
+export declare enum ModelType {
+    GLTF = "gltf",
+    GLB = "glb",
+    FBX = "fbx"
+}

package/dist/commonEnu.js

@@ -0,0 +1,6 @@
+export var ModelType;
+(function (ModelType) {
+  ModelType["GLTF"] = "gltf";
+  ModelType["GLB"] = "glb";
+  ModelType["FBX"] = "fbx";
+})(ModelType || (ModelType = {}));

package/dist/core/camera.d.ts

@@ -0,0 +1,16 @@
+import type { Object3D, Vector3 } from 'three';
+import { PerspectiveCamera } from 'three';
+declare class Anov3DPerspectiveCamera extends PerspectiveCamera {
+    constructor(fov: number, aspect: number, near: number, far: number);
+    /**
+     * 向目标物体推进
+     * @param targetObject3D
+     * @param distance
+     * @param duration
+     * @param animationMethod
+     */
+    promote(targetObject3D: Object3D, distance: number, duration?: number, animationMethod?: string): void;
+    demote: (targetObject3D: Object3D<import("three").Event>, distance: number, animationMethod: string, duration: number) => void;
+    surround: (targetObject3D: Object3D<import("three").Event>, radius: number, toward: Vector3) => void;
+}
+export { Anov3DPerspectiveCamera };

package/dist/core/camera.js

@@ -0,0 +1,61 @@
+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 _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); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+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); }
+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 { PerspectiveCamera } from 'three';
+import { Direction, moveTo } from "../utils/move";
+
+/**
+ * 向目标物体后退
+ * @param targetObject3D
+ * @param distance
+ * @param animationMethod
+ * @param duration
+ */
+var demote = function demote(targetObject3D, distance, animationMethod, duration) {};
+
+/**
+ * 相机围绕目标物体旋转
+ * @param targetObject3D
+ * @param radius
+ * @param toward
+ */
+var surround = function surround(targetObject3D, radius, toward) {};
+var Anov3DPerspectiveCamera = /*#__PURE__*/function (_PerspectiveCamera) {
+  _inherits(Anov3DPerspectiveCamera, _PerspectiveCamera);
+  var _super = _createSuper(Anov3DPerspectiveCamera);
+  function Anov3DPerspectiveCamera(fov, aspect, near, far) {
+    var _this;
+    _classCallCheck(this, Anov3DPerspectiveCamera);
+    _this = _super.call(this, fov, aspect, near, far);
+    _defineProperty(_assertThisInitialized(_this), "demote", demote);
+    _defineProperty(_assertThisInitialized(_this), "surround", surround);
+    return _this;
+  }
+
+  /**
+   * 向目标物体推进
+   * @param targetObject3D
+   * @param distance
+   * @param duration
+   * @param animationMethod
+   */
+  _createClass(Anov3DPerspectiveCamera, [{
+    key: "promote",
+    value: function promote(targetObject3D, distance, duration, animationMethod) {
+      moveTo(this, targetObject3D, distance, Direction.plus, duration, animationMethod);
+    }
+  }]);
+  return Anov3DPerspectiveCamera;
+}(PerspectiveCamera);
+export { Anov3DPerspectiveCamera };

package/dist/core/global.d.ts

@@ -0,0 +1,8 @@
+import type { Scene } from 'three';
+declare class GlobalObjectManage {
+    scene: Scene | null;
+    constructor();
+    addScene(object3d: Scene): void;
+}
+declare const _default: GlobalObjectManage;
+export default _default;

package/dist/core/global.js

@@ -0,0 +1,21 @@
+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 _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); }
+var GlobalObjectManage = /*#__PURE__*/function () {
+  function GlobalObjectManage() {
+    _classCallCheck(this, GlobalObjectManage);
+    _defineProperty(this, "scene", null);
+  }
+  _createClass(GlobalObjectManage, [{
+    key: "addScene",
+    value: function addScene(object3d) {
+      this.scene = object3d;
+    }
+  }]);
+  return GlobalObjectManage;
+}();
+export default new GlobalObjectManage();

package/dist/core/globalControl.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+interface CallbackType {
+    cb: () => void;
+    duration: number;
+}
+declare class GlobalControl {
+    callback: CallbackType;
+    task: Map<() => void, NodeJS.Timer>;
+    constructor();
+    update(): void;
+    add(cb: () => void, duration?: number): void;
+    remove(cb: () => void): void;
+    start(): void;
+    private timerControl;
+}
+declare const _default: GlobalControl;
+export default _default;

package/dist/core/globalControl.js

@@ -0,0 +1,63 @@
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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 _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); }
+var GlobalControl = /*#__PURE__*/function () {
+  function GlobalControl() {
+    _classCallCheck(this, GlobalControl);
+    _defineProperty(this, "callback", {});
+    _defineProperty(this, "task", new Map());
+  }
+  _createClass(GlobalControl, [{
+    key: "update",
+    value: function update() {
+      if (this.task.size > 0) {
+        // @ts-ignore
+        _toConsumableArray(this.task.keys()).forEach(function (cb) {
+          cb();
+        });
+      }
+    }
+  }, {
+    key: "add",
+    value: function add(cb, duration) {
+      this.callback.cb = cb;
+      this.callback.duration = duration || 1000;
+    }
+  }, {
+    key: "remove",
+    value: function remove(cb) {
+      if (this.task.get(cb)) {
+        clearTimeout(this.task.get(cb));
+        this.task.delete(cb);
+      }
+    }
+  }, {
+    key: "start",
+    value: function start() {
+      if (!this.task.get(this.callback.cb)) {
+        var timer = this.timerControl();
+        this.task.set(this.callback.cb, timer);
+      }
+    }
+  }, {
+    key: "timerControl",
+    value: function timerControl() {
+      var _this = this;
+      return setTimeout(function () {
+        _this.task.delete(_this.callback.cb);
+      }, this.callback.duration);
+    }
+  }]);
+  return GlobalControl;
+}();
+export default new GlobalControl();

package/dist/core/group.d.ts

@@ -0,0 +1,5 @@
+import { Group } from 'three';
+declare class Anov3DGroup extends Group {
+    constructor();
+}
+export default Anov3DGroup;

package/dist/core/group.js

@@ -0,0 +1,24 @@
+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 _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 _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); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+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);
+  }
+  return _createClass(Anov3DGroup);
+}(Group);
+export default Anov3DGroup;

package/dist/core/mesh.d.ts

@@ -0,0 +1,44 @@
+import type { Intersection, Raycaster } from 'three';
+import { Mesh } from 'three';
+import type { CubeEventType, EventHandleFn } from '../type';
+declare class Anov3DMesh extends Mesh {
+    private natureEventMap;
+    private isMove;
+    constructor(geometry?: ConstructorParameters<typeof Mesh>[0], material?: ConstructorParameters<typeof Mesh>[1]);
+    /**
+     * 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 eventHandle;
+    private debounceEventHandle;
+    /**
+     * handle pointerleave event
+     * @param intersects
+     * @param natureEvent
+     */
+    private handlePointerleave;
+    /**
+     * handle mesh raycaster
+     * @param raycaster
+     * @param intersects
+     */
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+}
+export default Anov3DMesh;

package/dist/core/mesh.js

@@ -0,0 +1,142 @@
+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 _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); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+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); }
+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) {
+    var _this;
+    _classCallCheck(this, Anov3DMesh);
+    _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));
+    return _this;
+  }
+
+  /**
+   * addNatureEventListener
+   * @param type
+   * @param handlefn
+   */
+  _createClass(Anov3DMesh, [{
+    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: "eventHandle",
+    value: function eventHandle(intersects, natureEvent) {
+      var intersect = intersects[0];
+      var object = intersect.object;
+      if (object === this) {
+        // get nature event
+        natureEvent.forEach(function (handlefn) {
+          handlefn(object);
+        });
+      }
+    }
+  }, {
+    key: "handlePointerleave",
+    value:
+    /**
+     * 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);
+        });
+      }
+    }
+
+    /**
+     * handle mesh raycaster
+     * @param raycaster
+     * @param intersects
+     */
+  }, {
+    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);
+      var pointerupCallback = this.natureEventMap.get('pointerup');
+      var pointerdownCallback = this.natureEventMap.get('pointerdown');
+      var pointermoveCallback = this.natureEventMap.get('pointermove');
+      var pointerleaveCallback = this.natureEventMap.get('pointerleave');
+      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);
+          }
+        });
+      } else {
+        emitter.on('pointerleave', function () {
+          if (pointerleaveCallback && pointerleaveCallback.length > 0 && _this3.isMove) _this3.handlePointerleave(intersects, pointerleaveCallback);
+        });
+      }
+    }
+  }]);
+  return Anov3DMesh;
+}(Mesh);
+export default Anov3DMesh;

package/dist/core/model.d.ts

@@ -0,0 +1,21 @@
+import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+declare class Anov3DModelLoader {
+    /**
+     * load gltf model
+     * @param url
+     * @param onLoad
+     * @param onProgress
+     * @param onError
+     * @returns
+     */
+    loadGLTF(url: string, onLoad?: (result: GLTF) => GLTF, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): Promise<unknown>;
+    /**
+     * fbx model loader
+     * @param url
+     * @param onLoad
+     * @param onProgress
+     * @param onError
+     */
+    loadFbx(url: string, onLoad?: (result: GLTF) => GLTF, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+}
+export default Anov3DModelLoader;

package/dist/core/model.js

@@ -0,0 +1,58 @@
+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); }
+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);
+  }
+  _createClass(Anov3DModelLoader, [{
+    key: "loadGLTF",
+    value:
+    /**
+     * load gltf model
+     * @param url
+     * @param onLoad
+     * @param onProgress
+     * @param onError
+     * @returns
+     */
+    function loadGLTF(url, onLoad, onProgress, onError) {
+      var loader = new GLTFLoader();
+      var dracoLoader = new DRACOLoader();
+      dracoLoader.setDecoderPath('./draco/');
+      dracoLoader.setDecoderConfig({
+        type: 'js'
+      });
+      dracoLoader.preload();
+      loader.setDRACOLoader(dracoLoader);
+      return new Promise(function (resolve, reject) {
+        loader.load(url, function (gltf) {
+          onLoad ? resolve(onLoad(gltf)) : resolve(gltf);
+        }, function (xhr) {
+          onProgress && onProgress(xhr);
+        }, function (err) {
+          onError && onError(err);
+          reject(err);
+        });
+      });
+    }
+
+    /**
+     * fbx model loader
+     * @param url
+     * @param onLoad
+     * @param onProgress
+     * @param onError
+     */
+  }, {
+    key: "loadFbx",
+    value: function loadFbx(url, onLoad, onProgress, onError) {}
+  }]);
+  return Anov3DModelLoader;
+}();
+export default Anov3DModelLoader;

package/dist/core/scene.d.ts

@@ -0,0 +1,122 @@
+import type { Color, Object3D } from 'three';
+import { AmbientLight, Raycaster, Scene, Vector3, WebGLRenderer } from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+import { Anov3DPerspectiveCamera } from './camera';
+interface Anov3DSceneOptions {
+    /**
+     * renderer options
+     */
+    rendererOps?: {
+        antialias?: boolean;
+        logarithmicDepthBuffer?: boolean;
+    };
+    /**
+     * default camera options
+     */
+    defCameraOps?: {
+        position?: Vector3;
+        fov?: number;
+        aspect?: number;
+        near?: number;
+        far?: number;
+    };
+    /**
+     * default ambient light options
+     */
+    defAmbientLightOps?: {
+        position?: Vector3;
+        color?: Color;
+        intensity?: number;
+    };
+    /**
+     * controls
+     */
+    orbitControls?: boolean;
+    /**
+     * 是否需要默认环境光
+     */
+    ambientLight?: boolean;
+    /**
+     * on demand render scene, 按需渲染
+     */
+    onDemand?: boolean;
+}
+declare class Anov3DScene {
+    private opts;
+    private pointer;
+    scene: Scene | null;
+    raycaster: Raycaster | null;
+    ambientLight: AmbientLight | null;
+    camera: Anov3DPerspectiveCamera | null;
+    renderer: WebGLRenderer | null;
+    controls: OrbitControls | null;
+    constructor(opts?: Anov3DSceneOptions);
+    /**
+     * init default scene components
+     */
+    private defaultInit;
+    /**
+     * init scene
+     * @param camera
+     * @param renderer
+     */
+    resetScene(camera: Anov3DPerspectiveCamera, renderer: WebGLRenderer): void;
+    /**
+     * init renderer
+     */
+    private initRenderer;
+    /**
+     * init default camera
+     */
+    private initDefaultPerspectiveCamera;
+    /**
+     * init ambient light
+     * @param position
+     * @param color
+     * @param intensity
+     * @returns
+     */
+    private initAmbientLight;
+    /**
+     * frame render
+     */
+    startFrameAnimate(frameAnimate?: (renderer: WebGLRenderer) => void): void;
+    /**
+     * scene add object3d
+     * @param object3d
+     */
+    add(object3d: Object3D): void;
+    /**
+     * update raycaster
+     */
+    private updateRaycaster;
+    private getPointerPosition;
+    /**
+     * handle pointerup event
+     * @param event
+     */
+    private onPointerPointerup;
+    /**
+     * handle pointerdown event
+     * @param event
+     */
+    private onPointerDown;
+    /**
+     * handle pointermove event
+     * @param event
+     */
+    private onPointerMove;
+    /**
+     * handle pointerleave event
+     * @param event
+     */
+    private onPointerLeave;
+    /**
+     * handle event register
+     * @param target
+     */
+    private registerEvent;
+    render(target: HTMLElement): void;
+    destroy(): void;
+}
+export default Anov3DScene;

package/dist/core/scene.js

@@ -0,0 +1,250 @@
+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 _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 { ACESFilmicToneMapping, AmbientLight, Raycaster, Scene, Vector2, Vector3, WebGLRenderer } from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+import * as TWEEN from '@tweenjs/tween.js';
+import { emitter } from "../utils";
+import globalControl from "./globalControl";
+import globalObjectManage from "./global";
+import { Anov3DPerspectiveCamera } from "./camera";
+var Anov3DScene = /*#__PURE__*/function () {
+  function Anov3DScene(opts) {
+    _classCallCheck(this, Anov3DScene);
+    _defineProperty(this, "opts", {});
+    _defineProperty(this, "pointer", new Vector2());
+    _defineProperty(this, "scene", null);
+    _defineProperty(this, "raycaster", null);
+    _defineProperty(this, "ambientLight", null);
+    _defineProperty(this, "camera", null);
+    _defineProperty(this, "renderer", null);
+    _defineProperty(this, "controls", null);
+    this.opts = opts !== null && opts !== void 0 ? opts : {};
+    this.scene = new Scene();
+    this.raycaster = new Raycaster();
+    globalObjectManage.addScene(this.scene);
+    this.defaultInit();
+  }
+
+  /**
+   * init default scene components
+   */
+  _createClass(Anov3DScene, [{
+    key: "defaultInit",
+    value: function defaultInit() {
+      var camera = this.initDefaultPerspectiveCamera();
+      this.camera = camera;
+      this.scene.add(camera);
+      var renderer = this.initRenderer();
+      this.renderer = renderer;
+      if (this.opts.ambientLight) {
+        var ambientLight = this.initAmbientLight();
+        this.ambientLight = ambientLight;
+        this.scene.add(ambientLight);
+      }
+    }
+
+    /**
+     * init scene
+     * @param camera
+     * @param renderer
+     */
+  }, {
+    key: "resetScene",
+    value: function resetScene(camera, renderer) {
+      camera.aspect = window.innerWidth / window.innerHeight;
+      camera.updateProjectionMatrix();
+      renderer.setSize(window.innerWidth, window.innerHeight);
+      renderer.setPixelRatio(window.devicePixelRatio);
+    }
+
+    /**
+     * init renderer
+     */
+  }, {
+    key: "initRenderer",
+    value: function initRenderer() {
+      var _rendererOps$antialia, _rendererOps$logarith;
+      var rendererOps = this.opts.rendererOps || {};
+      var renderer = new WebGLRenderer({
+        antialias: (_rendererOps$antialia = rendererOps.antialias) !== null && _rendererOps$antialia !== void 0 ? _rendererOps$antialia : true,
+        logarithmicDepthBuffer: (_rendererOps$logarith = rendererOps.logarithmicDepthBuffer) !== null && _rendererOps$logarith !== void 0 ? _rendererOps$logarith : true
+      });
+      renderer.setSize(window.innerWidth, window.innerHeight);
+      renderer.shadowMap.enabled = true;
+      renderer.toneMapping = ACESFilmicToneMapping;
+      renderer.toneMappingExposure = 0.3;
+      renderer.setPixelRatio(window.devicePixelRatio);
+      return renderer;
+    }
+
+    /**
+     * init default camera
+     */
+  }, {
+    key: "initDefaultPerspectiveCamera",
+    value: function initDefaultPerspectiveCamera() {
+      var rendererOps = this.opts.defCameraOps || {};
+      var camera = new Anov3DPerspectiveCamera(rendererOps.fov || 90, window.innerWidth / window.innerHeight, rendererOps.near || 0.1, rendererOps.far || 1000);
+      var position = rendererOps.position || new Vector3(0, 10, 10);
+      camera.position.set(position.x, position.y, position.z);
+      return camera;
+    }
+
+    /**
+     * init ambient light
+     * @param position
+     * @param color
+     * @param intensity
+     * @returns
+     */
+  }, {
+    key: "initAmbientLight",
+    value: function initAmbientLight() {
+      var defConfigOps = this.opts.defAmbientLightOps || {};
+      var position = defConfigOps.position || new Vector3(0, 3, 10);
+      var ambientLight = new AmbientLight(defConfigOps.color || 0xFFFFFF, defConfigOps.intensity || 1);
+      ambientLight.position.set(position.x, position.y, position.z);
+      return ambientLight;
+    }
+
+    /**
+     * frame render
+     */
+  }, {
+    key: "startFrameAnimate",
+    value: function startFrameAnimate(frameAnimate) {
+      var _this = this;
+      if (!this.renderer || !this.scene || !this.camera) throw new Error('scene or camera or renderer is not init');
+      if (frameAnimate) frameAnimate(this.renderer);
+      this.renderer.render(this.scene, this.camera);
+      TWEEN.update();
+      globalControl.update();
+      this.controls && this.controls.update();
+      requestAnimationFrame(function () {
+        return _this.startFrameAnimate(frameAnimate);
+      });
+    }
+
+    /**
+     * scene add object3d
+     * @param object3d
+     */
+  }, {
+    key: "add",
+    value: function add(object3d) {
+      this.scene.add(object3d);
+    }
+
+    /**
+     * update raycaster
+     */
+  }, {
+    key: "updateRaycaster",
+    value: function updateRaycaster() {
+      this.raycaster.setFromCamera(this.pointer, this.camera);
+      this.raycaster.intersectObjects(this.scene.children);
+    }
+  }, {
+    key: "getPointerPosition",
+    value: function getPointerPosition(event) {
+      this.pointer.setX(event.clientX / window.innerWidth * 2 - 1);
+      this.pointer.setY(-(event.clientY / window.innerHeight) * 2 + 1);
+    }
+
+    /**
+     * handle pointerup event
+     * @param event
+     */
+  }, {
+    key: "onPointerPointerup",
+    value: function onPointerPointerup(event) {
+      this.getPointerPosition(event);
+      emitter.emit('pointerup');
+      this.updateRaycaster();
+    }
+
+    /**
+     * handle pointerdown event
+     * @param event
+     */
+  }, {
+    key: "onPointerDown",
+    value: function onPointerDown(event) {
+      this.getPointerPosition(event);
+      emitter.emit('pointerdown');
+      this.updateRaycaster();
+    }
+
+    /**
+     * handle pointermove event
+     * @param event
+     */
+  }, {
+    key: "onPointerMove",
+    value: function onPointerMove(event) {
+      this.getPointerPosition(event);
+      emitter.emit('pointermove');
+      this.updateRaycaster();
+    }
+
+    /**
+     * handle pointerleave event
+     * @param event
+     */
+  }, {
+    key: "onPointerLeave",
+    value: function onPointerLeave(event) {
+      this.getPointerPosition(event);
+      emitter.emit('pointerleave');
+      this.updateRaycaster();
+    }
+
+    /**
+     * handle event register
+     * @param target
+     */
+  }, {
+    key: "registerEvent",
+    value: function registerEvent(target) {
+      var _this2 = this;
+      target.addEventListener('pointerup', function (e) {
+        return _this2.onPointerPointerup(e);
+      });
+      target.addEventListener('pointerdown', function (e) {
+        return _this2.onPointerDown(e);
+      });
+      target.addEventListener('pointermove', function (e) {
+        return _this2.onPointerMove(e);
+      });
+      target.addEventListener('pointerleave', function (e) {
+        return _this2.onPointerLeave(e);
+      });
+    }
+  }, {
+    key: "render",
+    value: function render(target) {
+      var _this3 = this;
+      if (this.opts.orbitControls) this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+      target.appendChild(this.renderer.domElement);
+      this.registerEvent(this.renderer.domElement);
+      target.addEventListener('resize', function () {
+        return _this3.resetScene(_this3.camera, _this3.renderer);
+      });
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      var _this4 = this;
+      window.removeEventListener('resize', function () {
+        return _this4.resetScene(_this4.camera, _this4.renderer);
+      });
+    }
+  }]);
+  return Anov3DScene;
+}();
+export default Anov3DScene;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import Anove3DScene from './core/scene';
+import Anov3DMesh from './core/mesh';
+import { Anov3DPerspectiveCamera } from './core/camera';
+import Anov3DModelLoader from './core/model';
+import { ModelType } from './commonEnu';
+import { Direction } from './utils/move';
+declare const utils: {
+    moveTo: (currentObject3D: import("three").Object3D<import("three").Event>, targetObject3D: import("three").Object3D<import("three").Event>, distance: number, direction: Direction, duration?: number | undefined, animationMethod?: string | undefined) => void;
+    moveLine: (currentObject3D: import("three").Object3D<import("three").Event>, targetObject3D: import("three").Object3D<import("three").Event>) => void;
+    moveWithRound: (currentObject3d: import("three").Object3D<import("three").Event>, speed?: number, duration?: number | undefined) => void;
+};
+export { Anove3DScene, Anov3DMesh, Anov3DPerspectiveCamera, Anov3DModelLoader, ModelType, Direction, utils, };

package/dist/index.js

@@ -0,0 +1,12 @@
+import Anove3DScene from "./core/scene";
+import Anov3DMesh from "./core/mesh";
+import { Anov3DPerspectiveCamera } from "./core/camera";
+import Anov3DModelLoader from "./core/model";
+import { ModelType } from "./commonEnu";
+import { Direction, moveLine, moveTo, moveWithRound } from "./utils/move";
+var utils = {
+  moveTo: moveTo,
+  moveLine: moveLine,
+  moveWithRound: moveWithRound
+};
+export { Anove3DScene, Anov3DMesh, Anov3DPerspectiveCamera, Anov3DModelLoader, ModelType, Direction, utils };

package/dist/type.d.ts

@@ -0,0 +1,3 @@
+import type TwinsThreeMesh from './core/mesh';
+export declare type CubeEventType = 'pointerup' | 'pointerdown' | 'pointermove' | 'pointerleave';
+export declare type EventHandleFn<T> = (event: TwinsThreeMesh) => void;

package/dist/type.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,15 @@
+export declare const emitter: {
+    on: {
+        <Key extends import("mitt").EventType>(type: Key, handler: import("mitt").Handler<Record<import("mitt").EventType, unknown>[Key]>): void;
+        (type: "*", handler: import("mitt").WildcardHandler<Record<import("mitt").EventType, unknown>>): void;
+    };
+    off: {
+        <Key_1 extends import("mitt").EventType>(type: Key_1, handler?: import("mitt").Handler<Record<import("mitt").EventType, unknown>[Key_1]> | undefined): void;
+        (type: "*", handler: import("mitt").WildcardHandler<Record<import("mitt").EventType, unknown>>): void;
+    };
+    emit: {
+        <Key_2 extends import("mitt").EventType>(type: Key_2, event: Record<import("mitt").EventType, unknown>[Key_2]): void;
+        <Key_3 extends import("mitt").EventType>(type: undefined extends Record<import("mitt").EventType, unknown>[Key_3] ? Key_3 : never): void;
+    };
+    all: import("mitt").EventHandlerMap<Record<import("mitt").EventType, unknown>>;
+};

package/dist/utils/index.js

@@ -0,0 +1,8 @@
+import mitt from 'mitt';
+var emitterHandle = mitt();
+export var emitter = {
+  on: emitterHandle.on,
+  off: emitterHandle.off,
+  emit: emitterHandle.emit,
+  all: emitterHandle.all
+};

package/dist/utils/move.d.ts

@@ -0,0 +1,39 @@
+import type { Object3D, Vector3 } from 'three';
+export declare enum Direction {
+    plus = "plus",
+    minus = "minus"
+}
+/**
+ * moveTo 直线移动
+ * @param currentObject3D
+ * @param targetObject3D
+ * @param direction
+ * @param distance
+ * @param duration
+ * @param animationMethod
+ */
+export declare const moveTo: (currentObject3D: Object3D, targetObject3D: Object3D, distance: number, direction: Direction, duration?: number, animationMethod?: string) => void;
+export declare const moveWithLine: (points: Vector3[], duration?: number) => void;
+/**
+ * 圆周运动
+ * 1. 一个法向量
+ * 2. 一个半径
+ * 3. 圆心位置
+ * 4. 需要运动的物体
+ * 5. 运动的时间
+ * 6. 运动的方式
+ */
+/**
+ * base 圆周运动
+ * @param currentObject3d
+ * @param speed
+ * @param duration
+ */
+export declare const moveWithRound: (currentObject3d: Object3D, speed?: number, duration?: number) => void;
+/**
+ * move 方法2 移动辅助线
+ * todo bug待修复
+ * @param currentObject3D
+ * @param targetObject3D
+ */
+export declare const moveLine: (currentObject3D: Object3D, targetObject3D: Object3D) => void;

package/dist/utils/move.js

@@ -0,0 +1,111 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { BufferGeometry, CatmullRomCurve3, Line, LineBasicMaterial } from 'three';
+import * as TWEEN from '@tweenjs/tween.js';
+import globalObjectManage from "../core/global";
+import globalControl from "../core/globalControl";
+var AnimationMethod;
+(function (AnimationMethod) {})(AnimationMethod || (AnimationMethod = {}));
+export var Direction;
+
+/**
+ * moveTo 直线移动
+ * @param currentObject3D
+ * @param targetObject3D
+ * @param direction
+ * @param distance
+ * @param duration
+ * @param animationMethod
+ */
+(function (Direction) {
+  Direction["plus"] = "plus";
+  Direction["minus"] = "minus";
+})(Direction || (Direction = {}));
+export var moveTo = function moveTo(currentObject3D, targetObject3D, distance, direction, duration, animationMethod) {
+  var targetPosition = targetObject3D.position;
+  var cameraPosition = currentObject3D.position;
+
+  // 单位方向向量
+  var toward = targetPosition.clone().sub(cameraPosition).normalize();
+  if (direction === Direction.minus) toward = toward.negate();
+  var target = cameraPosition.clone().add(toward.multiplyScalar(distance));
+  var totalDistance = cameraPosition.distanceTo(targetPosition);
+  var currentDistance = cameraPosition.distanceTo(target);
+  var lastPosition = target.clone();
+  if (direction === Direction.minus && currentDistance > totalDistance) lastPosition = targetPosition;
+  var tween = new TWEEN.Tween(cameraPosition);
+  tween.to(lastPosition, duration || 1000);
+  tween.start();
+};
+
+/**
+ * create line
+ * @param points
+ * @returns
+ */
+var createLine = function createLine(points) {
+  var curve = new CatmullRomCurve3(_toConsumableArray(points));
+  var curvePoints = curve.getPoints(50);
+  var geometry = new BufferGeometry().setFromPoints(curvePoints);
+  var material = new LineBasicMaterial({
+    opacity: 1
+  });
+  return [new Line(geometry, material), curve];
+};
+export var moveWithLine = function moveWithLine(points, duration) {
+  // const line = createLine(points)
+};
+
+/**
+ * 圆周运动
+ * 1. 一个法向量
+ * 2. 一个半径
+ * 3. 圆心位置
+ * 4. 需要运动的物体
+ * 5. 运动的时间
+ * 6. 运动的方式
+ */
+
+/**
+ * base 圆周运动
+ * @param currentObject3d
+ * @param speed
+ * @param duration
+ */
+export var moveWithRound = function moveWithRound(currentObject3d) {
+  var speed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.1;
+  var duration = arguments.length > 2 ? arguments[2] : undefined;
+  var angle = 0;
+  var x = 0;
+  var z = 0;
+  var handleCallback = function handleCallback() {
+    angle += speed;
+    x = 4 * Math.sin(angle);
+    z = 4 * Math.cos(angle);
+    currentObject3d.position.set(x, 0, z);
+  };
+  globalControl.add(handleCallback, duration);
+  globalControl.start();
+};
+
+/**
+ * move 方法2 移动辅助线
+ * todo bug待修复
+ * @param currentObject3D
+ * @param targetObject3D
+ */
+export var moveLine = function moveLine(currentObject3D, targetObject3D) {
+  var _createLine = createLine([currentObject3D.position, targetObject3D.position]),
+    _createLine2 = _slicedToArray(_createLine, 2),
+    curveObject = _createLine2[0],
+    curve = _createLine2[1];
+  globalObjectManage.scene.add(curveObject);
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@anov/3d",
+  "version": "0.0.1-alpha.0",
+  "description": "",
+  "author": "",
+  "license": "MIT",
+  "keywords": [],
+  "module": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "readme.md",
+    "package.json"
+  ],
+  "peerDependencies": {
+    "three": "^0.155.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.196",
+    "@types/three": "^0.155.0",
+    "three": "^0.155.0"
+  },
+  "dependencies": {
+    "@tweenjs/tween.js": "^21.0.0",
+    "lodash": "^4.17.21",
+    "mitt": "^3.0.1"
+  },
+  "scripts": {
+    "build": "father build",
+    "build:deps": "father prebundle",
+    "test": "jest --maxWorkers 2"
+  }
+}