@anov/3d 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# anov-3d
+
+anov 3d 核心包

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,5 @@
+import { PerspectiveCamera } from 'three';
+declare class Anov3DPerspectiveCamera extends PerspectiveCamera {
+    constructor(fov: number | undefined, aspect: number | undefined, near: 0.1, far?: number);
+}
+export { Anov3DPerspectiveCamera };

package/dist/core/camera.js

@@ -0,0 +1,64 @@
+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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+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 _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 { PerspectiveCamera } from 'three';
+
+/**
+ * 向目标物体推进
+ * @param targetObject3D
+ * @param distance
+ * @param animationMethod
+ * @param duration
+ */
+var promote = function promote(targetObject3D, distance, animationMethod, duration) {};
+
+/**
+ * 向目标物体后退
+ * @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() {
+    var fov = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 50;
+    var aspect = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    var near = arguments.length > 2 ? arguments[2] : undefined;
+    var far = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 2000;
+    _classCallCheck(this, Anov3DPerspectiveCamera);
+    return _super.call(this, fov, aspect, near, far);
+  }
+  return _createClass(Anov3DPerspectiveCamera);
+}(PerspectiveCamera);
+Anov3DPerspectiveCamera.prototype.promote = _objectSpread(_objectSpread({}, Anov3DPerspectiveCamera.prototype), {}, {
+  promote: promote,
+  demote: demote,
+  surround: surround
+});
+var a = new Anov3DPerspectiveCamera(50, 1, 0.1, 2000);
+console.log(a);
+export { Anov3DPerspectiveCamera };

package/dist/core/group.d.ts

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

package/dist/core/group.js

@@ -0,0 +1,27 @@
+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,145 @@
+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
+        console.log(intersect.object);
+        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');
+      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);
+          }
+        });
+      } else {
+        console.log('pointerleave');
+        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,116 @@
+import type { Color, Object3D } from 'three';
+import { PerspectiveCamera, Raycaster, Scene, Vector3, WebGLRenderer } from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+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;
+    /**
+     * if need ambient light
+     */
+    ambientLight?: boolean;
+    /**
+     * on demand render scene, 按需渲染
+     */
+    onDemand?: boolean;
+}
+declare class Anov3DScene {
+    private opts;
+    private pointer;
+    scene: Scene | null;
+    raycaster: Raycaster | null;
+    camera: PerspectiveCamera | null;
+    renderer: WebGLRenderer | null;
+    controls: OrbitControls | null;
+    constructor(opts: Anov3DSceneOptions);
+    /**
+     * init scene
+     * @param camera
+     * @param renderer
+     */
+    resetScene(camera: PerspectiveCamera, 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,235 @@
+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, PerspectiveCamera, Raycaster, Scene, Vector2, Vector3, WebGLRenderer } from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+import { emitter } from "../utils";
+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, "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();
+  }
+
+  /**
+   * init scene
+   * @param camera
+   * @param renderer
+   */
+  _createClass(Anov3DScene, [{
+    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);
+      this.renderer = renderer;
+      return renderer;
+    }
+
+    /**
+     * init default camera
+     */
+  }, {
+    key: "initDefaultPerspectiveCamera",
+    value: function initDefaultPerspectiveCamera() {
+      var rendererOps = this.opts.defCameraOps || {};
+      var camera = new PerspectiveCamera(rendererOps.fov || 90, window.innerWidth / window.innerHeight, rendererOps.near || 0.1, rendererOps.far || 1000);
+      var position = rendererOps.position || new Vector3(0, 3, 10);
+      camera.position.set(position.x, position.y, position.z);
+      this.camera = camera;
+      this.scene.add(camera);
+      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);
+      } else {
+        this.controls && this.controls.update();
+        this.renderer.render(this.scene, this.camera);
+      }
+      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;
+      var camera = this.initDefaultPerspectiveCamera();
+      var renderer = this.initRenderer();
+      if (this.opts.orbitControls) this.controls = new OrbitControls(camera, renderer.domElement);
+      if (this.opts.ambientLight) {
+        var ambientLight = this.initAmbientLight();
+        this.scene.add(ambientLight);
+      }
+      target.appendChild(renderer.domElement);
+      this.registerEvent(renderer.domElement);
+      target.addEventListener('resize', function () {
+        return _this3.resetScene(camera, 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,6 @@
+import Anove3DScene from './core/scene';
+import Anov3DMesh from './core/mesh';
+import { Anov3DPerspectiveCamera } from './core/camera';
+import Anov3DModelLoader from './core/model';
+import { ModelType } from './commonEnu';
+export { Anove3DScene, Anov3DMesh, Anov3DPerspectiveCamera, Anov3DModelLoader, ModelType, };

package/dist/index.js

@@ -0,0 +1,6 @@
+import Anove3DScene from "./core/scene";
+import Anov3DMesh from "./core/mesh";
+import { Anov3DPerspectiveCamera } from "./core/camera";
+import Anov3DModelLoader from "./core/model";
+import { ModelType } from "./commonEnu";
+export { Anove3DScene, Anov3DMesh, Anov3DPerspectiveCamera, Anov3DModelLoader, ModelType };

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/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@anov/3d",
+  "version": "0.0.1",
+  "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": {
+    "lodash": "^4.17.21",
+    "mitt": "^3.0.1"
+  },
+  "scripts": {
+    "build": "father build",
+    "build:deps": "father prebundle",
+    "test": "jest --maxWorkers 2"
+  }
+}