@realsee/dnalogel 0.1.0

package/plugins/PanoTVVideoPlugin/index.js

@@ -0,0 +1,351 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.PanoTVVideoPlugin = void 0;
+
+var THREE = _interopRequireWildcard(require("three"));
+
+var _five = require("@realsee/five");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+var PanoTVVideoPlugin = function PanoTVVideoPlugin(five, parameters) {
+  var state = {
+    enabled: true,
+    rectPoints: undefined,
+    videoTextureEnabled: false,
+    videoSource: '',
+    videoTexture: undefined,
+    imageTexture: undefined,
+    videoElement: parameters.videoElement
+  };
+  var videoMeshes = [];
+
+  var getImageTexture = function getImageTexture(source) {
+    var texture = new THREE.TextureLoader().load(source);
+    texture.minFilter = THREE.LinearFilter;
+    texture.magFilter = THREE.LinearFilter;
+    texture.format = THREE.RGBFormat;
+    return texture;
+  };
+
+  var getVideoTexture = function getVideoTexture(source, video) {
+    return new Promise(function (resolve, reject) {
+      var xhr = new XMLHttpRequest();
+
+      xhr.onreadystatechange = function () {
+        if (xhr.readyState == 4) {
+          if (xhr.status == 200) {
+            var url = window.URL || window.webkitURL;
+            video = video || document.createElement('video');
+            video.crossOrigin = 'anonymous';
+            video.autoplay = true;
+            video.muted = true;
+            video.loop = true;
+            video.playsInline = true;
+            video.src = url.createObjectURL(xhr.response);
+            var texture = new THREE.VideoTexture(video);
+            texture.minFilter = THREE.LinearFilter;
+            texture.magFilter = THREE.LinearFilter;
+            texture.format = THREE.RGBFormat;
+            resolve(Object.assign(texture, {
+              videoSource: source
+            }));
+          } else {
+            reject(new Error('Video download Error: ' + xhr.status));
+          }
+        }
+      };
+
+      xhr.onerror = function (error) {
+        return reject(error);
+      };
+
+      xhr.open('GET', source);
+      xhr.responseType = 'blob';
+      xhr.send();
+    });
+  };
+
+  var getPoints = function getPoints(panoIndex) {
+    if (!state.rectPoints) return [];
+    var rectPoints_ = state.rectPoints[panoIndex];
+    if (!rectPoints_) return [];
+    return rectPoints_.map(function (rectPoints) {
+      var quaternion = five.work.observers[panoIndex].quaternion;
+      var position = five.work.observers[panoIndex].position;
+      var points = [new THREE.Vector3(rectPoints[1].position.x, rectPoints[1].position.y, rectPoints[1].position.z), new THREE.Vector3(rectPoints[2].position.x, rectPoints[2].position.y, rectPoints[2].position.z), new THREE.Vector3(rectPoints[3].position.x, rectPoints[3].position.y, rectPoints[3].position.z), new THREE.Vector3(rectPoints[0].position.x, rectPoints[0].position.y, rectPoints[0].position.z)];
+      points.forEach(function (point) {
+        return point.applyQuaternion(quaternion).add(position);
+      });
+      return points;
+    });
+  };
+
+  var createPanoVideoMeshes = function createPanoVideoMeshes(panoIndex) {
+    return getPoints(panoIndex).map(function (points, index) {
+      var geometry = new THREE.BufferGeometry();
+      var segments = 128;
+      var verticesArray = [];
+      verticesArray.push(points[0].x, points[0].y, points[0].z);
+
+      for (var i = 1; i < segments; i++) {
+        verticesArray.push(points[0].x + (points[1].x - points[0].x) * i / segments, points[0].y + (points[1].y - points[0].y) * i / segments, points[0].z + (points[1].z - points[0].z) * i / segments);
+      }
+
+      verticesArray.push(points[1].x, points[1].y, points[1].z);
+      verticesArray.push(points[2].x, points[2].y, points[2].z);
+
+      for (var _i = 1; _i < segments; _i++) {
+        verticesArray.push(points[2].x + (points[3].x - points[2].x) * _i / segments, points[2].y + (points[3].y - points[2].y) * _i / segments, points[2].z + (points[3].z - points[2].z) * _i / segments);
+      }
+
+      verticesArray.push(points[3].x, points[3].y, points[3].z);
+      var uvArray = [];
+      uvArray.push(0, 0);
+
+      for (var _i2 = 1; _i2 < segments; _i2++) {
+        uvArray.push(_i2 / segments, 0);
+      }
+
+      uvArray.push(1, 0);
+      uvArray.push(1, 1);
+
+      for (var _i3 = 1; _i3 < segments; _i3++) {
+        uvArray.push(1 - _i3 / segments, 1);
+      }
+
+      uvArray.push(0, 1);
+      var indicesArray = [];
+
+      for (var _i4 = 0; _i4 < segments; _i4++) {
+        indicesArray.push(_i4, _i4 + 1, segments * 2 - _i4, _i4, segments * 2 - _i4, segments * 2 + 1 - _i4);
+      }
+
+      geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(verticesArray), 3));
+      geometry.setAttribute('uv', new THREE.BufferAttribute(new Float32Array(uvArray), 2));
+      geometry.setIndex(new THREE.BufferAttribute(new Uint32Array(indicesArray), 1));
+      var material = new THREE.MeshBasicMaterial({
+        map: state.videoTextureEnabled ? state.videoTexture : state.imageTexture,
+        depthTest: false,
+        transparent: true,
+        side: THREE.DoubleSide
+      });
+      var mesh = new THREE.Mesh(geometry, material);
+      mesh.renderOrder = 1;
+      mesh.name = "video-".concat(panoIndex, "-").concat(index);
+      return mesh;
+    });
+  };
+
+  var enable = function enable() {
+    if (state.enabled) return;
+    state.enabled = true;
+    var panoIndex = five.panoIndex;
+
+    if (typeof panoIndex === 'number') {
+      var meshes = videoMeshes[panoIndex] = createPanoVideoMeshes(panoIndex);
+      meshes.forEach(function (mesh) {
+        return five.scene.add(mesh);
+      });
+
+      if (state.videoTexture && videoMeshes.length) {
+        state.videoTexture.image.play();
+      }
+
+      five.needsRender = true;
+    }
+  };
+
+  var disable = function disable() {
+    if (!state.enabled) return;
+    state.enabled = false;
+    videoMeshes.forEach(function (meshes, index) {
+      if (meshes) {
+        meshes.forEach(function (mesh) {
+          mesh.geometry.dispose();
+          mesh.material.dispose();
+          five.scene.remove(mesh);
+        });
+        videoMeshes[index] = undefined;
+        if (state.videoTexture) state.videoTexture.image.pause();
+      }
+    });
+    five.needsRender = true;
+  };
+
+  var load = function load(data, videoElement) {
+    var video_src = data.video_src,
+        video_poster_src = data.video_poster_src,
+        points = data.points;
+    state.videoSource = video_src;
+    state.rectPoints = points;
+    state.imageTexture = getImageTexture(video_poster_src);
+    if (videoElement) state.videoElement = videoElement;
+    var panoIndex = five.state.panoIndex;
+    var meshes = videoMeshes[panoIndex] = createPanoVideoMeshes(panoIndex);
+    meshes.forEach(function (mesh) {
+      return five.scene.add(mesh);
+    });
+    getVideoTexture(state.videoSource, state.videoElement).then(function (videoTexture_) {
+      if (videoTexture_.videoSource !== state.videoSource) return;
+      state.videoTexture = videoTexture_;
+
+      var timeupdate = function timeupdate() {
+        videoTexture_.image.removeEventListener('timeupdate', timeupdate);
+        state.videoTextureEnabled = true;
+        videoMeshes.forEach(function (meshes) {
+          if (!meshes) return;
+          meshes.forEach(function (mesh) {
+            if (mesh.material.map !== state.videoTexture) {
+              mesh.material.map = videoTexture_;
+            }
+          });
+        });
+      };
+
+      state.videoTexture.image.addEventListener('timeupdate', timeupdate);
+      if (state.enabled) state.videoTexture.image.play();
+    });
+  };
+
+  five.on('renderFrame', function () {
+    videoMeshes.forEach(function (meshes) {
+      if (meshes) meshes.forEach(function (mesh) {
+        //@ts-ignore
+        mesh.needsRender = true;
+      });
+    });
+  });
+  five.on('panoWillArrive', function (panoIndex) {
+    if (!state.enabled) return;
+    if (five.panoIndex === panoIndex) return;
+
+    if (!videoMeshes[panoIndex]) {
+      var meshes = videoMeshes[panoIndex] = createPanoVideoMeshes(panoIndex);
+      meshes.forEach(function (mesh) {
+        mesh.material.opacity = 0;
+        five.scene.add(mesh);
+      });
+    }
+
+    if (videoMeshes[panoIndex].length) {
+      if (state.videoTexture) state.videoTexture.image.play();
+    } else {
+      if (state.videoTexture) state.videoTexture.image.pause();
+    }
+  });
+  five.on('movingToPano', function (panoIndex, prevPanoIndex, progress) {
+    if (!state.enabled) return;
+    if (prevPanoIndex === panoIndex) return;
+    videoMeshes.forEach(function (meshes, index) {
+      var _progress = index === panoIndex ? progress : 1 - progress;
+
+      var opacity = Math.max(0, _progress * 21 - 20);
+
+      if (videoMeshes[index]) {
+        videoMeshes[index].forEach(function (mesh) {
+          return mesh.material.opacity = opacity;
+        });
+      }
+    });
+  });
+  five.on('panoArrived', function (panoIndex) {
+    if (!state.enabled) return;
+    videoMeshes.forEach(function (meshes, index) {
+      if (index === panoIndex) {
+        if (!videoMeshes[index]) {
+          var _meshes = videoMeshes[index] = createPanoVideoMeshes(index);
+
+          _meshes.forEach(function (mesh) {
+            return five.scene.add(mesh);
+          });
+        }
+      } else {
+        if (videoMeshes[index]) {
+          videoMeshes[index].forEach(function (mesh) {
+            mesh.geometry.dispose();
+            mesh.material.dispose();
+            five.scene.remove(mesh);
+          });
+          videoMeshes[index] = undefined;
+        }
+      }
+    });
+  });
+  five.on('modeChange', function (mode) {
+    if (!state.enabled) return;
+    if (mode === _five.Five.Mode.Panorama) return;
+    videoMeshes.forEach(function () {// if (meshes) {
+      //   meshes.forEach((mesh) => {
+      //     mesh.geometry.dispose()
+      //     mesh.material.dispose()
+      //     five.scene.remove(mesh)
+      //   })
+      //   videoMeshes[index] = undefined
+      //   if (state.videoTexture) state.videoTexture.image.pause()
+      // }
+    });
+  });
+  five.on('wantsTapGesture', function (raycaster) {
+    if (!state.enabled) return;
+    var meshArray = [];
+    videoMeshes.forEach(function (meshes) {
+      if (meshes) meshArray.push.apply(meshArray, _toConsumableArray(meshes));
+    });
+
+    if (raycaster.intersectObjects(meshArray).length) {
+      if (state.videoTexture) {
+        state.videoTexture.image.muted = !state.videoTexture.image.muted;
+        state.videoTexture.image.play();
+      }
+
+      return false;
+    }
+  });
+  five.on('dispose', function () {
+    videoMeshes.forEach(function (meshes, index) {
+      if (meshes) {
+        meshes.forEach(function (mesh) {
+          mesh.geometry.dispose();
+          mesh.material.dispose();
+          five.scene.remove(mesh);
+        });
+        videoMeshes[index] = undefined;
+        if (state.videoTexture) state.videoTexture.image.pause();
+      }
+    });
+  });
+  five.on('load', function (input) {
+    if (input.panoTVVideoData) {
+      load(input.panoTVVideoData);
+    }
+  });
+  return {
+    enable: enable,
+    disable: disable,
+    load: load
+  };
+};
+
+exports.PanoTVVideoPlugin = PanoTVVideoPlugin;
+var _default = PanoTVVideoPlugin;
+exports["default"] = _default;

package/plugins/TreasurePlugin/Controller.d.ts

@@ -0,0 +1,32 @@
+import { Five } from '@realsee/five';
+import { TreasureType } from './constants';
+/** 宝箱数据 */
+export interface TreasurePluginItemData {
+    /** 宝箱 ID */
+    id: string;
+    /** 宝箱位置：[x, y, z] */
+    position: number[];
+    /** 宝箱类型 */
+    type: TreasureType;
+}
+export interface TreasurePluginData {
+    treasures: TreasurePluginItemData[];
+}
+export declare type TreasurePluginParameterType = undefined;
+export declare type TreasurePluginEvents = {
+    /** 点击宝箱事件
+     * @param id: 宝箱 ID
+     */
+    tap: (id: string) => void;
+};
+export declare class TreasurePluginController {
+    private five;
+    private selfGroup;
+    private hooks;
+    private fbxLoader;
+    private treasures;
+    constructor(five: Five);
+    load(data: TreasurePluginData): Promise<boolean>;
+    removeTreasureByID(id: string): boolean;
+    private onTreasureClick;
+}

package/plugins/TreasurePlugin/Controller.js

@@ -0,0 +1,175 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TreasurePluginController = void 0;
+
+var _five = require("@realsee/five");
+
+var THREE = _interopRequireWildcard(require("three"));
+
+var _FBXLoader = require("three/examples/jsm/loaders/FBXLoader");
+
+var _constants = require("./constants");
+
+var _TreasureObject = require("./TreasureObject");
+
+var _loadFbxObj = require("../../shared-utils/three/loadFbxObj");
+
+var _loadTreasureTextures = require("./utils/loadTreasureTextures");
+
+var _loadTexture = require("../../shared-utils/three/loadTexture");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 _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 _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 _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 _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 _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+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, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// load 时才开始加载资源
+// 根据传入的数据判断需要加载哪些资源
+// 先写死宝箱类型，后续改成配置表，然后根据表里面的类型加载数据
+// FBX 文件里面的贴图默认用的是黄色贴图，所以对于默认的贴图逻辑有特殊处理
+var TreasurePluginController = /*#__PURE__*/function () {
+  function TreasurePluginController(five) {
+    var _this = this;
+
+    _classCallCheck(this, TreasurePluginController);
+
+    _defineProperty(this, "hooks", new _five.Subscribe());
+
+    _defineProperty(this, "fbxLoader", new _FBXLoader.FBXLoader());
+
+    _defineProperty(this, "treasures", []);
+
+    _defineProperty(this, "onTreasureClick", function (id) {
+      _this.hooks.emit('tap', id);
+    });
+
+    this.five = five; // ========== self group ==========
+
+    this.selfGroup = new THREE.Group();
+    this.selfGroup.name = 'treasure-plugin-group';
+    this.five.scene.add(this.selfGroup);
+  }
+
+  _createClass(TreasurePluginController, [{
+    key: "load",
+    value: function () {
+      var _load = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(data) {
+        var _this2 = this,
+            _this$selfGroup;
+
+        var baseFbxObjPromise, treasureTexturesPromise, faceTexturesPromise, _yield$Promise$all, _yield$Promise$all2, fbxGroup, treasureTextures, treasures;
+
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                baseFbxObjPromise = (0, _loadFbxObj.loadFbxObj)(this.fbxLoader, _constants.TREASURE_FBX_URL);
+                treasureTexturesPromise = (0, _loadTreasureTextures.loadTreasureTextures)(data, baseFbxObjPromise);
+                faceTexturesPromise = Promise.all(_constants.TREASURE_FACE_ANIMATION_URLS.map(_loadTexture.loadTexture));
+                _context.next = 5;
+                return Promise.all([baseFbxObjPromise, treasureTexturesPromise]);
+
+              case 5:
+                _yield$Promise$all = _context.sent;
+                _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+                fbxGroup = _yield$Promise$all2[0];
+                treasureTextures = _yield$Promise$all2[1];
+                treasures = data.treasures.map(function (_ref) {
+                  var _treasureTextures$fin;
+
+                  var id = _ref.id,
+                      type = _ref.type,
+                      positionArray = _ref.position;
+                  var texture = (_treasureTextures$fin = treasureTextures.find(function (_ref2) {
+                    var treasureMapItem = _ref2.treasureMapItem;
+                    return treasureMapItem.type === type;
+                  })) === null || _treasureTextures$fin === void 0 ? void 0 : _treasureTextures$fin.texture;
+                  if (!texture) throw new Error('数据初始化失败，未能找到预期的 Texture');
+                  var position = new THREE.Vector3().fromArray(positionArray).applyAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI);
+                  var treasure = new _TreasureObject.TreasureObject({
+                    id: id,
+                    fbxGroup: fbxGroup,
+                    position: position,
+                    five: _this2.five,
+                    faceTexturesPromise: faceTexturesPromise,
+                    baseTexture: texture,
+                    clickCallback: _this2.onTreasureClick
+                  });
+                  treasure.scale.fromArray([0.008, 0.008, 0.008]);
+                  return treasure;
+                });
+
+                (_this$selfGroup = this.selfGroup).add.apply(_this$selfGroup, _toConsumableArray(treasures));
+
+                this.treasures = treasures;
+                return _context.abrupt("return", true);
+
+              case 13:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function load(_x) {
+        return _load.apply(this, arguments);
+      }
+
+      return load;
+    }()
+  }, {
+    key: "removeTreasureByID",
+    value: function removeTreasureByID(id) {
+      var treasureIndex = this.treasures.findIndex(function (treasure) {
+        return treasure.treasureID === id;
+      });
+      if (typeof treasureIndex !== 'number') return false;
+      var treasure = this.treasures[treasureIndex];
+      treasure.dispose();
+      this.selfGroup.remove(treasure);
+      this.treasures.slice(treasureIndex, 1);
+      return true;
+    }
+  }]);
+
+  return TreasurePluginController;
+}();
+
+exports.TreasurePluginController = TreasurePluginController;

package/plugins/TreasurePlugin/TreasureFaceAnime.d.ts

@@ -0,0 +1,23 @@
+import { Five } from '@realsee/five';
+import { Group, Texture } from 'three';
+export interface TreasureFaceAnimeParam {
+    five: Five;
+    treasureGroup: Group;
+    faceTexturesPromise: Promise<Texture[]>;
+}
+export declare class TreasureFaceAnime {
+    paused: boolean;
+    private five;
+    private treasureGroup;
+    private faceAnimeStep;
+    private faceAnimeTimer?;
+    private faceTexturesPromise;
+    private initialFaceTexture;
+    private faceMesh;
+    constructor(param: TreasureFaceAnimeParam);
+    play: () => Promise<boolean>;
+    pause(): boolean;
+    dispose(): void;
+    setToInitialState(): void;
+    private clearTimer;
+}