hexa-viewer-communicator
Version:
A simple API for <hexa-viewer>
1,343 lines (1,337 loc) • 51.5 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "IConfigurationTransitionEffect", {
enumerable: true,
get: function get() {
return _configurator2.IConfigurationTransitionEffect;
}
});
exports.ViewerCommunicator = void 0;
require("regenerator-runtime/runtime.js");
var _configurator = require("./configurator");
var _eventObservable = require("./event-observable");
var _eventObservable2 = require("./interfaces/event-observable.interface");
var _viewerCommunicator = require("./interfaces/viewer-communicator.interface");
var _imageToVideo = require("./image-to-video");
var _configurator2 = require("./interfaces/configurator.interface");
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 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, _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); } // Do not delete this as it allows importing the package with other projects
var ViewerCommunicator = /*#__PURE__*/function () {
// private _onGetMeshesData: Array<Function>;
// private _onCollisions = [] as Array<Function>;
function ViewerCommunicator(options) {
_classCallCheck(this, ViewerCommunicator);
_defineProperty(this, "configurator", void 0);
_defineProperty(this, "_hexaViewer", void 0);
_defineProperty(this, "_frameID", void 0);
_defineProperty(this, "_isViewerLoaded", void 0);
_defineProperty(this, "_isModelLoaded", void 0);
_defineProperty(this, "_isAnimateEnterEnd", void 0);
_defineProperty(this, "_isViewerListening", void 0);
_defineProperty(this, "_onMessageBind", void 0);
_defineProperty(this, "_meshesData", void 0);
_defineProperty(this, "_mesheAnimations", void 0);
_defineProperty(this, "_mesheMorph", void 0);
_defineProperty(this, "_xrSupport", void 0);
_defineProperty(this, "_eventObservable", void 0);
_defineProperty(this, "_hasDestroyed", void 0);
_defineProperty(this, "_onLoadingProgress", void 0);
this._hasDestroyed = false;
options = options || {};
this._hexaViewer = options.hexaViewer;
this._isViewerLoaded = false;
this._isModelLoaded = false;
this._isAnimateEnterEnd = false;
this._onLoadingProgress = [];
this.initFrameID();
this.attachEvents();
this.initEventObservable();
this.configurator = new _configurator.Configurator(this);
// Update the current viewer state.
// In case it's too soon this won't even get to the viewer because he's not listening.
// In case the viewer is already listening and a model has already been loaded the
// await this.onModelLoaded() will return instead of never returning and preventing
// all communicator functionality.
this._updateViewerFullyLoaded();
}
_createClass(ViewerCommunicator, [{
key: "hexaViewer",
get: function get() {
return this._hexaViewer;
},
set: function set(hv) {
this.attachInstance(hv);
}
}, {
key: "eventObservable",
get: function get() {
return this._eventObservable;
}
}, {
key: "isModelLoaded",
get: function get() {
return this._isViewerLoaded;
},
set: function set(value) {
if (value) this._onViewerFullyLoaded();else this._isViewerLoaded = value;
}
}, {
key: "hasDestroyed",
get: function get() {
return this._hasDestroyed;
}
}, {
key: "isViewerListening",
get: function get() {
return this._isViewerListening;
},
set: function set(value) {
this._isViewerListening = value;
if (this._isViewerListening) this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_VIEWER_LISTENING, false);
}
}, {
key: "initEventObservable",
value: function initEventObservable() {
this._eventObservable = new _eventObservable.EventObservable();
}
}, {
key: "attachInstance",
value: function attachInstance(hexaViewer) {
this._hexaViewer = hexaViewer;
this.initFrameID();
}
}, {
key: "initFrameID",
value: function initFrameID(elem) {
elem = elem || this._hexaViewer;
if (elem) {
this._frameID = elem.getAttribute("frame-id");
if (!this._frameID) {
this._frameID = this.generateUUID();
elem.setAttribute("frame-id", this._frameID);
}
}
}
}, {
key: "attachEvents",
value: function attachEvents() {
this._onMessageBind = this.onMessage.bind(this);
self.addEventListener("message", this._onMessageBind, false);
}
}, {
key: "onMessage",
value: function onMessage(event) {
var obj = this.safeParse(event.data);
if (obj) {
if (this._frameID && obj.id && this._frameID !== obj.id) return;
// if (obj.to === IPostMessageOrigin.TOP) {
switch (obj.action) {
case "viewerListening":
{
this.isViewerListening = true;
break;
}
case "viewerFullyLoaded":
{
this._onViewerFullyLoaded();
break;
}
case "onModelLoaded":
{
this._onModelLoaded();
break;
}
case "onAnimateEnterEnd":
{
this._onAnimateEnterEnd();
break;
}
case "setMeshesData":
{
this._onMeshesData(obj.data);
break;
}
case "setMeshAnimations":
{
this._onMeshAnimations(obj.data);
break;
}
case "setMeshMorph":
{
this._onMeshMorph(obj.data);
break;
}
case "setCollisions":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_COLLISIONS, false, [obj.data]);
break;
}
case "setSceneSummary":
{
var _obj$data;
if ((_obj$data = obj.data) !== null && _obj$data !== void 0 && _obj$data.autoAdjustScene) this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_ADJUDT_SCENE, true, [obj.data]);
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_SET_SCENE_SUMMARY, true, [obj.data]);
break;
}
case "setAttachJsonScene":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_APPLY_PRESET, true);
break;
}
case "create_images_by_tour":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_CREATE_IMAGES_BY_TOUR, true, [obj.data]);
break;
}
case "onLightsSummary":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_LIGHTS_SUMMARY, true, [obj.data]);
break;
}
case "onConfiguratorSelectDone":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_CONFIGURATOR_SELECT_DONE, true, [obj.data]);
break;
}
case "onModelInteraction":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_MODEL_INTERACTION, false, [obj.data.type]);
break;
}
case "setViewerFullyLoaded":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_SET_VIEWER_FULLY_LOADED, true, [obj.data]);
break;
}
case "setCurrentScreenshot":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_SCREENSHOT, true, [obj.data]);
break;
}
case "onScreenshotsSequence":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_SCREENSHOTS_SEQUENCE, true, [obj.data.images]);
break;
}
case "setModel":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_EXPORT, true, [obj.data]);
break;
}
case "setBoundingBox":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_BOUNDING_BOX, true, [obj.data]);
break;
}
case "setMaterials":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_GET_MATERIALS, true, [obj.data]);
break;
}
case "setDiamondEffectOptions":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_GET_DIAMONDS_OPTIONS, true, [obj.data]);
break;
}
case "setLoadingPercentage":
{
this._onLoadingProgress.forEach(function (f) {
return f(obj.data);
});
break;
}
case "onMeshAnimationFinish":
{
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_MESH_ANIMATION_FINISHE, false, [obj.data]);
break;
}
}
// }
}
}
}, {
key: "_checkModelLoaded",
value: function _checkModelLoaded() {
if (this._isViewerLoaded && (this._isModelLoaded || this._isAnimateEnterEnd)) this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_MODEL_LOADED, true);
}
}, {
key: "_onAnimateEnterEnd",
value: function _onAnimateEnterEnd() {
this._isAnimateEnterEnd = true;
this._checkModelLoaded();
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_ANIMATE_ENTER_END, true);
}
}, {
key: "_onModelLoaded",
value: function _onModelLoaded() {
this._isModelLoaded = true;
this._checkModelLoaded();
}
}, {
key: "_onViewerFullyLoaded",
value: function _onViewerFullyLoaded() {
this._isModelLoaded = true;
this._isViewerLoaded = true;
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_VIEWER_LOADED, true);
this._checkModelLoaded();
}
}, {
key: "_onMeshesData",
value: function _onMeshesData(obj) {
this._meshesData = obj;
this.isModelLoaded = true;
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_GET_MESHES_DATA, true, [this._meshesData]);
// if (this._meshesData) {
// setTimeout(() =>{
// if (this._meshesData) {
// Object.values(this._meshesData).forEach(md => {
// if (md.rotation) {
// md.rotationDegree = {} as ThreeVector3int;
// md.rotationDegree.x = parseFloat(md.rotation.x.toString()) / (Math.PI / 180);
// md.rotationDegree.y = parseFloat(md.rotation.y.toString()) / (Math.PI / 180);
// md.rotationDegree.z = parseFloat(md.rotation.z.toString()) / (Math.PI / 180);
// }
// });
// }
// });
// }
}
}, {
key: "_onMeshAnimations",
value: function _onMeshAnimations(obj) {
this._mesheAnimations = obj;
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_GET_MESHE_ANIMATIONS, true, [this._mesheAnimations]);
}
}, {
key: "_onMeshMorph",
value: function _onMeshMorph(obj) {
this._mesheMorph = obj;
this._eventObservable.invoke(_eventObservable2.EventObservableTypes.ON_GET_MESHE_MORPH, true, [this._mesheMorph]);
}
}, {
key: "_updateViewerFullyLoaded",
value: function _updateViewerFullyLoaded() {
var _this = this;
return new Promise(function (resolve, reject) {
_this._eventObservable.add(_eventObservable2.EventObservableTypes.ON_SET_VIEWER_FULLY_LOADED, function (state) {
_this._isViewerLoaded = state;
if (_this._isViewerLoaded) {
_this.onModelLoaded();
_this._isViewerListening = true;
_this._onViewerFullyLoaded();
}
resolve();
});
var msg = {
action: "broadcastViewerFullyLoaded",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
};
_this.sendToViewer(msg);
});
}
}, {
key: "onModelLoaded",
value: function onModelLoaded() {
var _this2 = this;
return new Promise(function (resolve, reject) {
if (_this2._isViewerLoaded) resolve();else _this2._eventObservable.add(_eventObservable2.EventObservableTypes.ON_VIEWER_LOADED, resolve);
});
}
// on model ready is a later event then onModelLoaded
// it will fire after the enter animation is done (in case there is one)
// in case there isn't it will fire next to the onModelLoaded
}, {
key: "onModelReady",
value: function onModelReady() {
var _this3 = this;
return new Promise(function (resolve, reject) {
if (_this3._isModelLoaded) resolve();else _this3._eventObservable.add(_eventObservable2.EventObservableTypes.ON_MODEL_LOADED, resolve);
});
}
}, {
key: "onViewerListening",
value: function onViewerListening() {
var _this4 = this;
return new Promise(function (resolve, reject) {
if (_this4._isViewerListening) resolve();else _this4._eventObservable.add(_eventObservable2.EventObservableTypes.ON_VIEWER_LISTENING, resolve);
});
}
}, {
key: "onAnimateEnterEnd",
value: function onAnimateEnterEnd() {
var _this5 = this;
return new Promise(function (resolve, reject) {
if (_this5._isAnimateEnterEnd) resolve();else _this5._eventObservable.add(_eventObservable2.EventObservableTypes.ON_ANIMATE_ENTER_END, resolve);
});
}
}, {
key: "getMeshesData",
value: function getMeshesData() {
var _this6 = this;
return new Promise(function (resolve, reject) {
_this6._eventObservable.add(_eventObservable2.EventObservableTypes.ON_GET_MESHES_DATA, resolve);
var msg = {
action: "getMeshesData",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
};
_this6.sendToViewer(msg);
});
}
}, {
key: "getMeshAnimations",
value: function getMeshAnimations() {
var _this7 = this;
return new Promise(function (resolve, reject) {
_this7._eventObservable.add(_eventObservable2.EventObservableTypes.ON_GET_MESHE_ANIMATIONS, resolve);
var msg = {
action: "broadcastMeshAnimations",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
};
_this7.sendToViewer(msg);
});
}
}, {
key: "getMeshMorph",
value: function getMeshMorph() {
var _this8 = this;
return new Promise(function (resolve, reject) {
_this8._eventObservable.add(_eventObservable2.EventObservableTypes.ON_GET_MESHE_MORPH, resolve);
var msg = {
action: "broadcastMeshMorph",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
};
_this8.sendToViewer(msg);
});
}
}, {
key: "getMaterials",
value: function getMaterials() {
var _this9 = this;
return new Promise(function (resolve, reject) {
_this9._eventObservable.add(_eventObservable2.EventObservableTypes.ON_GET_MATERIALS, resolve);
var msg = {
action: "broadcastMaterials",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
};
_this9.sendToViewer(msg);
});
}
}, {
key: "updateMeshAnimations",
value: function updateMeshAnimations(meshAnimations) {
this.sendToViewer({
action: "updateMeshAnimations",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
meshAnimations: meshAnimations
}
});
}
}, {
key: "updateMeshMorph",
value: function updateMeshMorph(meshMorph) {
this.sendToViewer({
action: "updateMeshMorph",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
meshMorph: meshMorph
}
});
}
}, {
key: "executeAvatarPose",
value: function executeAvatarPose(pose, options) {
this.sendToViewer({
action: "executeAvatarPose",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
pose: pose,
options: options
}
});
}
}, {
key: "safeParse",
value: function safeParse(p) {
if (typeof p === "string") {
try {
return JSON.parse(p);
} catch (e) {}
}
return p;
}
}, {
key: "generateUUID",
value: function generateUUID() {
var d = new Date().getTime();
if (window.performance && typeof window.performance.now === "function") {
d += performance.now();
}
var uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
var r = (d + Math.random() * 16) % 16 | 0;
d = Math.floor(d / 16);
return (c === "x" ? r : r & 0x3 | 0x8).toString(16);
});
return uuid;
}
}, {
key: "materializeMesh",
value: function materializeMesh(meshName, config) {
var msg = {
action: "materializeMesh",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
name: meshName,
config: config
}
};
this.sendToViewer(msg);
}
}, {
key: "sendToViewer",
value: function sendToViewer(msg) {
// msg.from = IPostMessageOrigin.TOP;
if (this._frameID) msg.id = this._frameID;
self.postMessage(msg, location.origin);
}
// Creates a <hexa-viewer> instance from a viewer URL (typically the resource_default)
}, {
key: "createInstanceFromUrl",
value: function () {
var _createInstanceFromUrl = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(viewerURL) {
var params,
options,
hv,
p,
allP,
i,
_args = arguments;
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
params = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
options = _args.length > 2 ? _args[2] : undefined;
options = options || {};
hv = document.createElement("hexa-viewer");
p = this.getUrlParams(viewerURL);
allP = Object.assign(p, params);
if (typeof allP.server === "undefined") allP.server = "1";
if (typeof allP["frame-id"] === "undefined") allP["frame-id"] = this.generateUUID();
if (!options.enableWebXR) {
_context.next = 13;
break;
}
_context.next = 11;
return this.isWebXrSupported();
case 11:
if (!_context.sent) {
_context.next = 13;
break;
}
allP["offscreen"] = "false";
case 13:
if (options.themeColor) allP["theme-color"] = options.themeColor;
for (i in allP) {
i && hv.setAttribute(i, allP[i] === null ? "" : allP[i]);
}
this.initFrameID(hv);
return _context.abrupt("return", hv);
case 17:
case "end":
return _context.stop();
}
}
}, _callee, this);
}));
function createInstanceFromUrl(_x) {
return _createInstanceFromUrl.apply(this, arguments);
}
return createInstanceFromUrl;
}()
}, {
key: "getUrlParams",
value: function getUrlParams(url) {
var queryString = {},
query = "";
if (url.indexOf("?") > -1) query = url.substring(url.indexOf("?") + 1);
if (!query) return queryString;
query = query.split("+").join(" ");
var vars = query.split("&");
for (var i = 0; i < vars.length; i++) {
var pair = vars[i].split("=");
if (typeof queryString[pair[0]] === "undefined") {
queryString[pair[0]] = pair[1] ? decodeURIComponent(pair[1]) : null;
} else if (typeof queryString[pair[0]] === "string") {
var arr = [queryString[pair[0]], decodeURIComponent(pair[1])];
queryString[pair[0]] = arr;
} else {
queryString[pair[0]].push(decodeURIComponent(pair[1]));
}
}
return queryString;
}
}, {
key: "togglePicInPic",
value: function togglePicInPic(state) {
var msg = {
action: "togglePicInPic",
to: _viewerCommunicator.IPostMessageOrigin.MAIN,
value: state
};
this.sendToViewer(msg);
}
}, {
key: "toggleWireframe",
value: function toggleWireframe(state) {
var msg = {
action: "toggleWireframe",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: state
};
this.sendToViewer(msg);
}
}, {
key: "toggleUvMode",
value: function toggleUvMode(state) {
var msg = {
action: "toggleUvMode",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: state
};
this.sendToViewer(msg);
}
}, {
key: "toggleMatcapMode",
value: function toggleMatcapMode(state, options) {
var msg = {
action: "toggleMatcapMode",
data: options,
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: state
};
this.sendToViewer(msg);
}
}, {
key: "toggleHideBottom",
value: function toggleHideBottom(state) {
var msg = {
action: "toggleHideBottom",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: state
};
this.sendToViewer(msg);
}
}, {
key: "isWebXrSupported",
value: function isWebXrSupported() {
var _this10 = this;
return new Promise(function (resolve, reject) {
if (typeof _this10._xrSupport === "boolean") {
resolve(_this10._xrSupport);
return;
}
var navigatorAny = navigator;
if (!navigatorAny.xr || !navigatorAny.xr.isSessionSupported) {
_this10._xrSupport = false;
resolve(_this10._xrSupport);
return;
}
try {
navigatorAny.xr.isSessionSupported("immersive-ar").then(function (res) {
_this10._xrSupport = res;
resolve(_this10._xrSupport);
}, function (e) {
_this10._xrSupport = false;
resolve(_this10._xrSupport);
});
} catch (e) {
_this10._xrSupport = false;
resolve(_this10._xrSupport);
}
});
}
}, {
key: "toggleWebXR",
value: function toggleWebXR(state) {
var invokeWhenReady = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
var msg = {
action: "toggleXr",
obj: {
state: state,
value: invokeWhenReady,
showIcon: true
}
};
this.sendToViewer(msg);
}
}, {
key: "toggleAR",
value: function toggleAR(state) {
var invokeWhenReady = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
var msg = {
action: "toggleAR",
obj: {
state: state,
value: invokeWhenReady
}
};
this.sendToViewer(msg);
}
}, {
key: "waitForCollisions",
value: function waitForCollisions() {
var _this11 = this;
return new Promise(function (resolve, reject) {
_this11._eventObservable.add(_eventObservable2.EventObservableTypes.ON_COLLISIONS, resolve);
});
}
}, {
key: "toggleCollision",
value: function toggleCollision(collisionMode, color) {
this.sendToViewer({
action: "toggleCollision",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
value: collisionMode,
color: color
}
});
}
}, {
key: "deleteCollision",
value: function deleteCollision(position, count) {
this.sendToViewer({
action: "spliceCollision",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
value: position,
count: count
}
});
}
}, {
key: "removeAllCollisions",
value: function removeAllCollisions() {
this.sendToViewer({
action: "removeAllCollisions",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
});
}
}, {
key: "adjustScene",
value: function adjustScene() {
var _this12 = this;
return new Promise( /*#__PURE__*/function () {
var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(resolve, reject) {
return regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
_this12._eventObservable.add(_eventObservable2.EventObservableTypes.ON_ADJUDT_SCENE, resolve);
_context2.next = 3;
return _this12.onModelLoaded();
case 3:
_this12.sendToViewer({
action: "adjustScene",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
});
case 4:
case "end":
return _context2.stop();
}
}
}, _callee2);
}));
return function (_x2, _x3) {
return _ref.apply(this, arguments);
};
}());
}
// Not going to work without reloading instance or supporting each parameter on the viewer level
// private applyPresetSrc(params: any): void {
// for (let i in params) {
// this.hexaViewer.setAttribute(i, params[i]);
// }
// }
}, {
key: "applyPreset",
value: function applyPreset(json) {
var _this13 = this;
return new Promise( /*#__PURE__*/function () {
var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(resolve, reject) {
return regeneratorRuntime.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
_this13._eventObservable.add(_eventObservable2.EventObservableTypes.ON_APPLY_PRESET, resolve);
// Make sure model has loaded
_context3.next = 3;
return _this13.onModelLoaded();
case 3:
_this13.sendToViewer({
action: "attachJsonScene",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
data: json
});
// // Make sure all viewer parameters has taken effect
// await this.broadcastSceneSummary();
// if (preset?.preset_json) {
// if (preset.preset_json.shadowPlane)
// this.applyShadowPlane(preset.preset_json.shadowPlane);
// if (preset.preset_json.hdri) {
// if (!preset.preset_json.hdri.type)
// preset.preset_json.hdri.intensity = 0;
// this.applyHDRI(preset.preset_json.hdri);
// }
// if (preset.preset_json.lights)
// await this.setLightsByJson(preset.preset_json.lights);
// if (preset.preset_json.params)
// this.assetAdjustmentsService.applyParams();
// }
case 4:
case "end":
return _context3.stop();
}
}
}, _callee3);
}));
return function (_x4, _x5) {
return _ref2.apply(this, arguments);
};
}());
}
}, {
key: "applyHDRI",
value: function applyHDRI(hdri) {
this.sendToViewer({
action: "setHDR",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: hdri.type,
options: hdri
});
}
}, {
key: "applyShadowPlane",
value: function applyShadowPlane(shadowPlane) {
this.sendToViewer({
action: "togglePlane",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: shadowPlane.opacity,
options: {
active: shadowPlane.active,
color: shadowPlane.color,
opacity: shadowPlane.opacity,
physical: shadowPlane.physical,
physicalOptions: shadowPlane.physicalOptions,
reflector: shadowPlane.reflector,
side: shadowPlane.side
}
});
}
}, {
key: "broadcastSceneSummary",
value: function broadcastSceneSummary(params) {
var _this14 = this;
return new Promise(function (resolve, reject) {
_this14._eventObservable.add(_eventObservable2.EventObservableTypes.ON_SET_SCENE_SUMMARY, resolve);
_this14.sendToViewer({
action: "broadcastSceneSummary",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: params
});
});
}
}, {
key: "setLightsByJson",
value: function setLightsByJson(lights) {
var _this15 = this;
return new Promise(function (resolve, reject) {
_this15._eventObservable.add(_eventObservable2.EventObservableTypes.ON_LIGHTS_SUMMARY, resolve);
_this15.sendToViewer({
action: "setLightsByJson",
value: lights,
to: _viewerCommunicator.IPostMessageOrigin.WORKER
});
});
}
}, {
key: "onCreateImagesByTour",
value: function onCreateImagesByTour() {
var _this16 = this;
return new Promise( /*#__PURE__*/function () {
var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(resolve, reject) {
return regeneratorRuntime.wrap(function _callee4$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
_this16._eventObservable.add(_eventObservable2.EventObservableTypes.ON_CREATE_IMAGES_BY_TOUR, resolve);
case 1:
case "end":
return _context4.stop();
}
}
}, _callee4);
}));
return function (_x6, _x7) {
return _ref3.apply(this, arguments);
};
}());
}
}, {
key: "setMeshProps",
value: function setMeshProps(optins) {
var obj = {
name: optins.mesh.name,
props: {}
};
// if (optins.key === 'rotation') {
// // radians to degrees
// optins.mesh.rotation.x = optins.mesh.rotationDegree.x * (Math.PI / 180);
// optins.mesh.rotation.y = optins.mesh.rotationDegree.y * (Math.PI / 180);
// optins.mesh.rotation.z = optins.mesh.rotationDegree.z * (Math.PI / 180);
// optins.value = optins.mesh.rotation;
// }
obj["props"][optins.key] = optins.value;
if (!this._meshesData[obj.name]) this._meshesData[obj.name] = {};
this._meshesData[obj.name][optins.key] = optins.value;
this.sendToViewer({
action: "setMeshProps",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: obj
});
}
}, {
key: "appendDynamicElement",
value: function appendDynamicElement(obj, events) {
var selectorToAppend = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ".body";
this.sendToViewer({
action: "appendElement",
to: _viewerCommunicator.IPostMessageOrigin.MAIN,
obj: {
obj: obj,
events: events,
selectorToAppend: selectorToAppend
}
});
}
}, {
key: "controlsTutorial",
value: function controlsTutorial(types) {
this.sendToViewer({
action: "startZoomTutorial",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: types
});
}
}, {
key: "toggleAutoRotate",
value: function toggleAutoRotate(state) {
this.sendToViewer({
action: "toggleAutoRotate",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
data: state
});
}
}, {
key: "onModelInteraction",
value: function onModelInteraction(cb) {
var _this17 = this;
return new Promise(function (resolve, reject) {
_this17._eventObservable.add(_eventObservable2.EventObservableTypes.ON_MODEL_INTERACTION, function (type) {
if (cb) cb(type);
resolve(type);
});
});
}
}, {
key: "goToInitialCamPos",
value: function goToInitialCamPos() {
this.sendToViewer({
action: "goToInitialCamPos",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
});
}
}, {
key: "getCurrentScreenshot",
value: function getCurrentScreenshot() {
var _this18 = this;
return new Promise( /*#__PURE__*/function () {
var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(resolve, reject) {
return regeneratorRuntime.wrap(function _callee5$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
_this18._eventObservable.add(_eventObservable2.EventObservableTypes.ON_SCREENSHOT, resolve);
// await this.onModelReady();
_context5.next = 3;
return _this18.onAnimateEnterEnd();
case 3:
_this18.sendToViewer({
action: "getCurrentScreenshot",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
});
case 4:
case "end":
return _context5.stop();
}
}
}, _callee5);
}));
return function (_x8, _x9) {
return _ref4.apply(this, arguments);
};
}());
}
}, {
key: "expotModel",
value: function expotModel(options) {
var _this19 = this;
return new Promise( /*#__PURE__*/function () {
var _ref5 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6(resolve, reject) {
var action, value;
return regeneratorRuntime.wrap(function _callee6$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
if (!options.downloadFile) _this19._eventObservable.add(_eventObservable2.EventObservableTypes.ON_EXPORT, resolve);
_context6.next = 3;
return _this19.onModelReady();
case 3:
action = "", value = null;
_context6.t0 = options.type;
_context6.next = _context6.t0 === _viewerCommunicator.ExportFileType.GLB ? 7 : _context6.t0 === _viewerCommunicator.ExportFileType.glTF ? 7 : _context6.t0 === _viewerCommunicator.ExportFileType.USDZ ? 10 : _context6.t0 === _viewerCommunicator.ExportFileType.OBJ ? 12 : 14;
break;
case 7:
action = "broadcastGLTF";
value = {
binary: options.type === _viewerCommunicator.ExportFileType.GLB,
trs: false,
onlyVisible: true,
truncateDrawRange: false,
embedImages: true,
// animations: []
forceIndices: true,
forcePowerOfTwoTextures: true,
imagesFileType: null,
normalImagesFileType: null,
mroImagesFileType: null,
imagesCompressionFactor: null,
downloadFile: options.downloadFile,
maxTexturesSize: null,
maxDiffuseTexturesSize: null,
maxNormalTexturesSize: null,
maxMroTexturesSize: null,
optipng: options.compressPNG,
simplify: false,
deleteUV2: false
};
return _context6.abrupt("break", 16);
case 10:
action = "broadcastUSDZ";
return _context6.abrupt("break", 16);
case 12:
action = "broadcastOBJ";
return _context6.abrupt("break", 16);
case 14:
action = "broadcastGLTF";
return _context6.abrupt("break", 16);
case 16:
_this19.sendToViewer({
action: action,
value: value,
to: _viewerCommunicator.IPostMessageOrigin.WORKER
});
if (options.downloadFile) resolve(null);
case 18:
case "end":
return _context6.stop();
}
}
}, _callee6);
}));
return function (_x10, _x11) {
return _ref5.apply(this, arguments);
};
}());
}
}, {
key: "getScreenshotsSequence",
value: function getScreenshotsSequence(options) {
var _this20 = this;
return new Promise( /*#__PURE__*/function () {
var _ref6 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee8(resolve, reject) {
var finalOptions;
return regeneratorRuntime.wrap(function _callee8$(_context8) {
while (1) {
switch (_context8.prev = _context8.next) {
case 0:
_this20._eventObservable.add(_eventObservable2.EventObservableTypes.ON_SCREENSHOTS_SEQUENCE, /*#__PURE__*/function () {
var _ref7 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee7(images) {
var i2v;
return regeneratorRuntime.wrap(function _callee7$(_context7) {
while (1) {
switch (_context7.prev = _context7.next) {
case 0:
if (!(options.format === _viewerCommunicator.MediaFormat.VIDEO)) {
_context7.next = 10;
break;
}
i2v = new _imageToVideo.ImageToVideo(images);
if (options.codec) i2v.codecs = options.codec;
_context7.t0 = resolve;
_context7.next = 6;
return i2v.getVideo();
case 6:
_context7.t1 = _context7.sent;
(0, _context7.t0)(_context7.t1);
_context7.next = 11;
break;
case 10:
resolve(images);
case 11:
case "end":
return _context7.stop();
}
}
}, _callee7);
}));
return function (_x14) {
return _ref7.apply(this, arguments);
};
}());
_context8.next = 3;
return _this20.onModelReady();
case 3:
_context8.next = 5;
return _this20.onAnimateEnterEnd();
case 5:
finalOptions = {};
if (options) {
finalOptions.ggNumOfFrames = options.numOfFrames;
// finalOptions.ggInterval = options.interval;
// finalOptions.ggSampleInterval = options.sampleInterval;
// finalOptions.ggRotateSpeen = options.rotateSpeen;
}
finalOptions.msgObj = {
data: {},
action: "onScreenshotsSequence",
to: _viewerCommunicator.IPostMessageOrigin.TOP,
from: _viewerCommunicator.IPostMessageOrigin.WORKER
};
_this20.sendToViewer({
action: "broadcastGifSequence",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
data: {
options: finalOptions
}
});
case 9:
case "end":
return _context8.stop();
}
}
}, _callee8);
}));
return function (_x12, _x13) {
return _ref6.apply(this, arguments);
};
}());
}
}, {
key: "applyTexture",
value: function applyTexture(options) {
this.sendToViewer({
action: "mapTextureToMaterial",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
texture: options.src,
material: options.materialName,
options: {
map: options.mapType,
intensity: options.intensity,
textureSrc: options.src,
srcChange: !!options.src,
color: options.color,
videoSrc: options.mimeType === _viewerCommunicator.TextureMimeType.VIDEO ? options.src : null
}
}
});
}
}, {
key: "setMaterialProps",
value: function setMaterialProps(options) {
this.sendToViewer({
action: "setMaterialProps",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
name: options.materialName,
props: options.props
}
});
}
}, {
key: "swapMaterialType",
value: function swapMaterialType(options) {
this.sendToViewer({
action: "swapMaterialType",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
name: options.materialName,
newType: options.type
}
});
}
}, {
key: "displayFiles",
value: function displayFiles(files) {
this.sendToViewer({
action: "displayFiles",
to: _viewerCommunicator.IPostMessageOrigin.MAIN,
value: {
files: files
}
});
}
}, {
key: "getBoundingBox",
value: function getBoundingBox() {
var _this21 = this;
return new Promise( /*#__PURE__*/function () {
var _ref8 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee9(resolve, reject) {
return regeneratorRuntime.wrap(function _callee9$(_context9) {
while (1) {
switch (_context9.prev = _context9.next) {
case 0:
_context9.next = 2;
return _this21.onModelReady();
case 2:
_this21._eventObservable.add(_eventObservable2.EventObservableTypes.ON_BOUNDING_BOX, resolve);
_this21.sendToViewer({
action: "broadcastBoundingBox",
to: _viewerCommunicator.IPostMessageOrigin.WORKER
});
case 4:
case "end":
return _context9.stop();
}
}
}, _callee9);
}));
return function (_x15, _x16) {
return _ref8.apply(this, arguments);
};
}());
}
}, {
key: "toggleNoDistanceLimit",
value: function () {
var _toggleNoDistanceLimit = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee10(state) {
return regeneratorRuntime.wrap(function _callee10$(_context10) {
while (1) {
switch (_context10.prev = _context10.next) {
case 0:
_context10.next = 2;
return this.onModelReady();
case 2:
this.sendToViewer({
action: "toggleNoDistanceLimit",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: state
});
case 3:
case "end":
return _context10.stop();
}
}
}, _callee10, this);
}));
function toggleNoDistanceLimit(_x17) {
return _toggleNoDistanceLimit.apply(this, arguments);
}
return toggleNoDistanceLimit;
}()
}, {
key: "toggleCloseup",
value: function () {
var _toggleCloseup = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee11(state) {
return regeneratorRuntime.wrap(function _callee11$(_context11) {
while (1) {
switch (_context11.prev = _context11.next) {
case 0:
_context11.next = 2;
return this.onModelReady();
case 2:
this.sendToViewer({
action: "toggleCloseup",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: state
});
case 3:
case "end":
return _context11.stop();
}
}
}, _callee11, this);
}));
function toggleCloseup(_x18) {
return _toggleCloseup.apply(this, arguments);
}
return toggleCloseup;
}()
}, {
key: "setCameraPosition",
value: function () {
var _setCameraPosition = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee12(pos) {
return regeneratorRuntime.wrap(function _callee12$(_context12) {
while (1) {
switch (_context12.prev = _context12.next) {
case 0:
_context12.next = 2;
return this.onModelReady();
case 2:
this.sendToViewer({
action: "setCameraPosition",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: pos
});
case 3:
case "end":
return _context12.stop();
}
}
}, _callee12, this);
}));
function setCameraPosition(_x19) {
return _setCameraPosition.apply(this, arguments);
}
return setCameraPosition;
}()
}, {
key: "setDiamonds",
value: function () {
var _setDiamonds = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee13(state, meshesNames, options) {
return regeneratorRuntime.wrap(function _callee13$(_context13) {
while (1) {
switch (_context13.prev = _context13.next) {
case 0:
_context13.next = 2;
return this.onModelReady();
case 2:
this.sendToViewer({
action: "toggleDiamond",
to: _viewerCommunicator.IPostMessageOrigin.WORKER,
value: {
state: state,
meshes: meshesNames,
options: options
}