@egjs/view3d/dist/view3d.js

/*
Copyright (c) 2020-present NAVER Corp.
name: @egjs/view3d
license: MIT
author: NAVER Corp.
repository: https://github.com/naver/egjs-view3d
version: 1.1.0
*/
(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('three'), require('three/examples/jsm/loaders/DRACOLoader'), require('three/examples/jsm/loaders/GLTFLoader'), require('three/examples/jsm/loaders/RGBELoader')) :
    typeof define === 'function' && define.amd ? define(['three', 'three/examples/jsm/loaders/DRACOLoader', 'three/examples/jsm/loaders/GLTFLoader', 'three/examples/jsm/loaders/RGBELoader'], factory) :
    (global = global || self, global.View3D = factory(global.THREE, global.DRACOLoader, global.GLTFLoader$1, global.RGBELoader));
}(this, (function (THREE, DRACOLoader, GLTFLoader$1, RGBELoader) { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */

    /* global Reflect, Promise */
    var extendStatics = function (d, b) {
      extendStatics = Object.setPrototypeOf || {
        __proto__: []
      } instanceof Array && function (d, b) {
        d.__proto__ = b;
      } || function (d, b) {
        for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
      };

      return extendStatics(d, b);
    };

    function __extends(d, b) {
      extendStatics(d, b);

      function __() {
        this.constructor = d;
      }

      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }
    var __assign = function () {
      __assign = Object.assign || function __assign(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
          s = arguments[i];

          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
        }

        return t;
      };

      return __assign.apply(this, arguments);
    };
    function __awaiter(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function (resolve) {
          resolve(value);
        });
      }

      return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }

        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }

        function step(result) {
          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
        }

        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    }
    function __generator(thisArg, body) {
      var _ = {
        label: 0,
        sent: function () {
          if (t[0] & 1) throw t[1];
          return t[1];
        },
        trys: [],
        ops: []
      },
          f,
          y,
          t,
          g;
      return g = {
        next: verb(0),
        "throw": verb(1),
        "return": verb(2)
      }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
        return this;
      }), g;

      function verb(n) {
        return function (v) {
          return step([n, v]);
        };
      }

      function step(op) {
        if (f) throw new TypeError("Generator is already executing.");

        while (_) try {
          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
          if (y = 0, t) op = [op[0] & 2, t.value];

          switch (op[0]) {
            case 0:
            case 1:
              t = op;
              break;

            case 4:
              _.label++;
              return {
                value: op[1],
                done: false
              };

            case 5:
              _.label++;
              y = op[1];
              op = [0];
              continue;

            case 7:
              op = _.ops.pop();

              _.trys.pop();

              continue;

            default:
              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                _ = 0;
                continue;
              }

              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
                _.label = op[1];
                break;
              }

              if (op[0] === 6 && _.label < t[1]) {
                _.label = t[1];
                t = op;
                break;
              }

              if (t && _.label < t[2]) {
                _.label = t[2];

                _.ops.push(op);

                break;
              }

              if (t[2]) _.ops.pop();

              _.trys.pop();

              continue;
          }

          op = body.call(thisArg, _);
        } catch (e) {
          op = [6, e];
          y = 0;
        } finally {
          f = t = 0;
        }

        if (op[0] & 5) throw op[1];
        return {
          value: op[0] ? op[1] : void 0,
          done: true
        };
      }
    }
    function __values(o) {
      var s = typeof Symbol === "function" && Symbol.iterator,
          m = s && o[s],
          i = 0;
      if (m) return m.call(o);
      if (o && typeof o.length === "number") return {
        next: function () {
          if (o && i >= o.length) o = void 0;
          return {
            value: o && o[i++],
            done: !o
          };
        }
      };
      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
    }
    function __read(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o),
          r,
          ar = [],
          e;

      try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      } catch (error) {
        e = {
          error: error
        };
      } finally {
        try {
          if (r && !r.done && (m = i["return"])) m.call(i);
        } finally {
          if (e) throw e.error;
        }
      }

      return ar;
    }
    function __spread() {
      for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

      return ar;
    }

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var EventEmitter =
    /*#__PURE__*/
    function () {
      function EventEmitter() {
        this._listenerMap = {};
      }

      var __proto = EventEmitter.prototype;

      __proto.on = function (eventName, callback) {
        var listenerMap = this._listenerMap;
        var listeners = listenerMap[eventName];

        if (listeners && listeners.indexOf(callback) < 0) {
          listeners.push(callback);
        } else {
          listenerMap[eventName] = [callback];
        }

        return this;
      };

      __proto.once = function (eventName, callback) {

        var listenerMap = this._listenerMap;
        var listeners = listenerMap[eventName];

        if (listeners && listeners.indexOf(callback) < 0) {
          listeners.push(callback);
        } else {
          listenerMap[eventName] = [callback];
        }

        return this;
      };

      __proto.off = function (eventName, callback) {
        var listenerMap = this._listenerMap;

        if (!eventName) {
          this._listenerMap = {};
          return this;
        }

        if (!callback) {
          delete listenerMap[eventName];
          return this;
        }

        var listeners = listenerMap[eventName];

        if (listeners) {
          var callbackIdx = listeners.indexOf(callback);

          if (callbackIdx >= 0) {
            listeners.splice(callbackIdx, 1);
          }
        }

        return this;
      };

      __proto.emit = function (eventName) {
        var event = [];

        for (var _i = 1; _i < arguments.length; _i++) {
          event[_i - 1] = arguments[_i];
        }

        var listeners = this._listenerMap[eventName];

        if (listeners) {
          listeners.forEach(function (callback) {
            callback.apply(void 0, __spread(event));
          });
        }

        return this;
      };

      return EventEmitter;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Renderer that renders View3D's Scene
     * @category Core
     */

    var Renderer =
    /*#__PURE__*/
    function () {
      /**
       * Create new Renderer instance
       * @param canvas \<canvas\> element to render 3d model
       */
      function Renderer(canvas) {
        this._canvas = canvas;
        this._renderer = new THREE.WebGLRenderer({
          canvas: this._canvas,
          alpha: true,
          antialias: true,
          preserveDrawingBuffer: true
        });
        this._renderer.xr.enabled = true;
        this._renderer.outputEncoding = THREE.sRGBEncoding;
        this._clock = new THREE.Clock(false);
        this.enableShadow();
      }

      var __proto = Renderer.prototype;
      Object.defineProperty(__proto, "canvas", {
        /**
         * {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement HTMLCanvasElement} given when creating View3D instance
         * @type HTMLCanvasElement
         * @readonly
         */
        get: function () {
          return this._canvas;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "context", {
        /**
         * Current {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext WebGLRenderingContext}
         * @type WebGLRenderingContext
         * @readonly
         */
        get: function () {
          return this._renderer.context;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "size", {
        /**
         * The width and height of the renderer's output canvas
         * @see https://threejs.org/docs/#api/en/math/Vector2
         * @type THREE.Vector2
         */
        get: function () {
          return this._renderer.getSize(new THREE.Vector2());
        },
        set: function (val) {
          this._renderer.setSize(val.x, val.y, false);
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "threeRenderer", {
        /**
         * Three.js {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer WebGLRenderer} instance
         * @type THREE.WebGLRenderer
         * @readonly
         */
        get: function () {
          return this._renderer;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Resize the renderer based on current canvas width / height
       * @returns {void} Nothing
       */

      __proto.resize = function () {
        var renderer = this._renderer;
        var canvas = this._canvas;
        if (renderer.xr.isPresenting) return;
        renderer.setPixelRatio(window.devicePixelRatio);
        renderer.setSize(canvas.offsetWidth, canvas.offsetHeight, false);
      };
      /**
       * Render a scene using a camera.
       * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.render
       * @param scene {@link Scene} to render
       * @param camera {@link Camera} to render
       */


      __proto.render = function (scene, camera) {
        this._renderer.render(scene.root, camera.threeCamera);
      };

      __proto.setAnimationLoop = function (callback) {
        var _this = this;

        this._clock.start();

        this._renderer.setAnimationLoop(function (timestamp, frame) {
          var delta = _this._clock.getDelta();

          callback(delta, frame);
        });
      };

      __proto.stopAnimationLoop = function () {
        this._clock.stop(); // See https://threejs.org/docs/#api/en/renderers/WebGLRenderer.setAnimationLoop


        this._renderer.setAnimationLoop(null);
      };
      /**
       * Enable shadow map
       */


      __proto.enableShadow = function () {
        var threeRenderer = this._renderer;
        threeRenderer.shadowMap.enabled = true;
        threeRenderer.shadowMap.type = THREE.PCFSoftShadowMap;
      };
      /**
       * Disable shadow map
       */


      __proto.disableShadow = function () {
        var threeRenderer = this._renderer;
        threeRenderer.shadowMap.enabled = false;
      };

      return Renderer;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    // Constants that used internally
    // Texture map names that used in THREE#MeshStandardMaterial
    var STANDARD_MAPS = ["alphaMap", "aoMap", "bumpMap", "displacementMap", "emissiveMap", "envMap", "lightMap", "map", "metalnessMap", "normalMap", "roughnessMap"];

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var View3DError =
    /*#__PURE__*/
    function (_super) {
      __extends(View3DError, _super);

      function View3DError(message, code) {
        var _this = _super.call(this, message) || this;

        _this.message = message;
        _this.code = code;
        Object.setPrototypeOf(_this, View3DError.prototype);
        _this.name = "View3DError";
        return _this;
      }

      return View3DError;
    }(Error);

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    /**
     * Error codes of {@link View3DError}
     * @name ERROR_CODES
     * @memberof Constants
     * @type object
     * @property {number} WRONG_TYPE 0
     * @property {number} ELEMENT_NOT_FOUND 1
     * @property {number} CANVAS_NOT_FOUND 2
     * @property {number} WEBGL_NOT_SUPPORTED 3
     * @property {number} ADD_CONTROL_FIRST 4
     * @property {number} PROVIDE_WIDTH_OR_HEIGHT 5
     */
    var CODES = {
      WRONG_TYPE: 0,
      ELEMENT_NOT_FOUND: 1,
      ELEMENT_NOT_CANVAS: 2,
      WEBGL_NOT_SUPPORTED: 3,
      ADD_CONTROL_FIRST: 4,
      PROVIDE_WIDTH_OR_HEIGHT: 5
    };
    var MESSAGES = {
      WRONG_TYPE: function (val, types) {
        return typeof val + " is not a " + types.map(function (type) {
          return "\"" + type + "\"";
        }).join(" or ") + ".";
      },
      ELEMENT_NOT_FOUND: function (query) {
        return "Element with selector \"" + query + "\" not found.";
      },
      ELEMENT_NOT_CANVAS: function (el) {
        return "Given element <" + el.tagName + "> is not a canvas.";
      },
      WEBGL_NOT_SUPPORTED: "WebGL is not supported on this browser.",
      ADD_CONTROL_FIRST: "Control is enabled before setting a target element.",
      PROVIDE_WIDTH_OR_HEIGHT: "Either width or height should be given."
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    function getElement(el, parent) {
      var targetEl = null;

      if (typeof el === "string") {
        var parentEl = parent ? parent : document;
        var queryResult = parentEl.querySelector(el);

        if (!queryResult) {
          throw new View3DError(MESSAGES.ELEMENT_NOT_FOUND(el), CODES.ELEMENT_NOT_FOUND);
        }

        targetEl = queryResult;
      } else if (el && el.nodeType === Node.ELEMENT_NODE) {
        targetEl = el;
      }

      return targetEl;
    }
    function getCanvas(el) {
      var targetEl = getElement(el);

      if (!targetEl) {
        throw new View3DError(MESSAGES.WRONG_TYPE(el, ["HTMLElement", "string"]), CODES.WRONG_TYPE);
      }

      if (!/^canvas$/i.test(targetEl.tagName)) {
        throw new View3DError(MESSAGES.ELEMENT_NOT_CANVAS(targetEl), CODES.ELEMENT_NOT_CANVAS);
      }

      return targetEl;
    }
    function range(end) {
      if (!end || end <= 0) {
        return [];
      }

      return Array.apply(0, Array(end)).map(function (undef, idx) {
        return idx;
      });
    }
    function toRadian(x) {
      return x * Math.PI / 180;
    }
    function clamp(x, min, max) {
      return Math.max(Math.min(x, max), min);
    }
    function findIndex(target, list) {
      var e_1, _a;

      var index = -1;

      try {
        for (var _b = __values(range(list.length)), _c = _b.next(); !_c.done; _c = _b.next()) {
          var itemIndex = _c.value;

          if (list[itemIndex] === target) {
            index = itemIndex;
            break;
          }
        }
      } catch (e_1_1) {
        e_1 = {
          error: e_1_1
        };
      } finally {
        try {
          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
        } finally {
          if (e_1) throw e_1.error;
        }
      }

      return index;
    } // Linear interpolation between a and b

    function mix(a, b, t) {
      return a * (1 - t) + b * t;
    }
    function circulate(val, min, max) {
      var size = Math.abs(max - min);

      if (val < min) {
        var offset = (min - val) % size;
        val = max - offset;
      } else if (val > max) {
        var offset = (val - max) % size;
        val = min + offset;
      }

      return val;
    }
    function merge(target) {
      var srcs = [];

      for (var _i = 1; _i < arguments.length; _i++) {
        srcs[_i - 1] = arguments[_i];
      }

      srcs.forEach(function (source) {
        Object.keys(source).forEach(function (key) {
          var value = source[key];

          if (Array.isArray(target[key]) && Array.isArray(value)) {
            target[key] = __spread(target[key], value);
          } else {
            target[key] = value;
          }
        });
      });
      return target;
    }
    function getBoxPoints(box) {
      return [box.min.clone(), new THREE.Vector3(box.min.x, box.min.y, box.max.z), new THREE.Vector3(box.min.x, box.max.y, box.min.z), new THREE.Vector3(box.min.x, box.max.y, box.max.z), new THREE.Vector3(box.max.x, box.min.y, box.min.z), new THREE.Vector3(box.max.x, box.min.y, box.max.z), new THREE.Vector3(box.max.x, box.max.y, box.min.z), box.max.clone()];
    }
    function toPowerOfTwo(val) {
      var result = 1;

      while (result < val) {
        result *= 2;
      }

      return result;
    }
    function getPrimaryAxisIndex(basis, viewDir) {
      var primaryIdx = 0;
      var maxDot = 0;
      basis.forEach(function (axes, axesIdx) {
        var dotProduct = Math.abs(viewDir.dot(axes));

        if (dotProduct > maxDot) {
          primaryIdx = axesIdx;
          maxDot = dotProduct;
        }
      });
      return primaryIdx;
    } // In radian

    function getRotationAngle(center, v1, v2) {
      var centerToV1 = new THREE.Vector2().subVectors(v1, center).normalize();
      var centerToV2 = new THREE.Vector2().subVectors(v2, center).normalize(); // Get the rotation angle with the model's NDC coordinates as the center.

      var deg = centerToV2.angle() - centerToV1.angle();
      var compDeg = -Math.sign(deg) * (2 * Math.PI - Math.abs(deg)); // Take the smaller deg

      var rotationAngle = Math.abs(deg) < Math.abs(compDeg) ? deg : compDeg;
      return rotationAngle;
    }

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Scene that View3D will render.
     * All model datas including Mesh, Lights, etc. will be included on this
     * @category Core
     */

    var Scene =
    /*#__PURE__*/
    function () {
      /**
       * Create new Scene instance
       */
      function Scene() {
        this._root = new THREE.Scene();
        this._userObjects = new THREE.Group();
        this._envObjects = new THREE.Group();
        this._envs = [];
        var root = this._root;
        var userObjects = this._userObjects;
        var envObjects = this._envObjects;
        userObjects.name = "userObjects";
        envObjects.name = "envObjects";
        root.add(userObjects);
        root.add(envObjects);
      }

      var __proto = Scene.prototype;
      Object.defineProperty(__proto, "root", {
        /**
         * Root {@link https://threejs.org/docs/#api/en/scenes/Scene THREE.Scene} object
         */
        get: function () {
          return this._root;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "environments", {
        /**
         * {@link Environment}s inside scene
         */
        get: function () {
          return this._envs;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "visible", {
        /**
         * Return the visibility of the root scene
         */
        get: function () {
          return this._root.visible;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Update scene to fit the given model
       * @param model model to fit
       * @param override options for specific environments
       */

      __proto.update = function (model, override) {
        this._envs.forEach(function (env) {
          return env.fit(model, override);
        });
      };
      /**
       * Reset scene to initial state
       * @returns {void} Nothing
       */


      __proto.reset = function () {
        this.resetModel();
        this.resetEnv();
      };
      /**
       * Fully remove all objects that added by calling {@link Scene#add add()}
       * @returns {void} Nothing
       */


      __proto.resetModel = function () {
        this._removeChildsOf(this._userObjects);
      };
      /**
       * Remove all objects that added by calling {@link Scene#addEnv addEnv()}
       * This will also reset scene background & envmap
       * @returns {void} Nothing
       */


      __proto.resetEnv = function () {
        this._removeChildsOf(this._envObjects);

        this._envs = [];
        this._root.background = null;
        this._root.environment = null;
      };
      /**
       * Add new Three.js {@link https://threejs.org/docs/#api/en/core/Object3D Object3D} into the scene
       * @param object {@link https://threejs.org/docs/#api/en/core/Object3D THREE.Object3D}s to add
       * @returns {void} Nothing
       */


      __proto.add = function () {
        var _a;

        var object = [];

        for (var _i = 0; _i < arguments.length; _i++) {
          object[_i] = arguments[_i];
        }

        (_a = this._userObjects).add.apply(_a, __spread(object));
      };
      /**
       * Add new {@link Environment} or Three.js {@link https://threejs.org/docs/#api/en/core/Object3D Object3D}s to the scene, which won't be removed after displaying another 3D model
       * @param envs {@link Environment} | {@link https://threejs.org/docs/#api/en/core/Object3D THREE.Object3D}s to add
       * @returns {void} Nothing
       */


      __proto.addEnv = function () {
        var _this = this;

        var envs = [];

        for (var _i = 0; _i < arguments.length; _i++) {
          envs[_i] = arguments[_i];
        }

        envs.forEach(function (env) {
          var _a;

          if (env.isObject3D) {
            _this._envObjects.add(env);
          } else {
            _this._envs.push(env);

            (_a = _this._envObjects).add.apply(_a, __spread(env.objects));
          }
        });
      };
      /**
       * Remove Three.js {@link https://threejs.org/docs/#api/en/core/Object3D Object3D} into the scene
       * @param object {@link https://threejs.org/docs/#api/en/core/Object3D THREE.Object3D}s to add
       * @returns {void} Nothing
       */


      __proto.remove = function () {
        var _a;

        var object = [];

        for (var _i = 0; _i < arguments.length; _i++) {
          object[_i] = arguments[_i];
        }

        (_a = this._userObjects).remove.apply(_a, __spread(object));
      };
      /**
       * Remove {@link Environment} or Three.js {@link https://threejs.org/docs/#api/en/core/Object3D Object3D}s to the scene, which won't be removed after displaying another 3D model
       * @param envs {@link Environment} | {@link https://threejs.org/docs/#api/en/core/Object3D THREE.Object3D}s to add
       * @returns {void} Nothing
       */


      __proto.removeEnv = function () {
        var _this = this;

        var envs = [];

        for (var _i = 0; _i < arguments.length; _i++) {
          envs[_i] = arguments[_i];
        }

        envs.forEach(function (env) {
          var _a;

          if (env.isObject3D) {
            _this._envObjects.remove(env);
          } else {
            var envIndex = findIndex(env, _this._envs);

            if (envIndex > -1) {
              _this._envs.splice(envIndex, 1);
            }

            (_a = _this._envObjects).remove.apply(_a, __spread(env.objects));
          }
        });
      };
      /**
       * Set background of the scene.
       * @see {@link https://threejs.org/docs/#api/en/scenes/Scene.background THREE.Scene.background}
       * @param background A texture to set as background
       * @returns {void} Nothing
       */


      __proto.setBackground = function (background) {
        // Three.js's type definition does not include WebGLCubeRenderTarget, but it works and defined on their document
        // See https://threejs.org/docs/#api/en/scenes/Scene.background
        this._root.background = background;
      };
      /**
       * Set scene's environment map that affects all physical materials in the scene
       * @see {@link https://threejs.org/docs/#api/en/scenes/Scene.environment THREE.Scene.environment}
       * @param envmap A texture to set as environment map
       * @returns {void} Nothing
       */


      __proto.setEnvMap = function (envmap) {
        // Next line written to silence Three.js's warning
        var environment = envmap.texture ? envmap.texture : envmap;
        this._root.environment = environment;
      };
      /**
       * Make this scene visible
       * @returns {void} Nothing
       */


      __proto.show = function () {
        this._root.visible = true;
      };
      /**
       * Make this scene invisible
       * @returns {void} Nothing
       */


      __proto.hide = function () {
        this._root.visible = false;
      };

      __proto._removeChildsOf = function (obj) {
        obj.traverse(function (child) {
          if (child.isMesh) {
            var mesh = child; // Release geometry & material memory

            mesh.geometry.dispose();
            var materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
            materials.forEach(function (mat) {
              STANDARD_MAPS.forEach(function (map) {
                if (mat[map]) {
                  mat[map].dispose();
                }
              });
            });
          }
        });

        while (obj.children.length > 0) {
          obj.remove(obj.children[0]);
        }
      };

      return Scene;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Controller that controls camera of the View3D
     * @category Core
     */

    var Controller =
    /*#__PURE__*/
    function () {
      /**
       * Create new Controller instance
       */
      function Controller(canvas, camera) {
        this._controls = [];
        this._canvas = canvas;
        this._camera = camera;
      }

      var __proto = Controller.prototype;
      Object.defineProperty(__proto, "controls", {
        /**
         * {@link CameraControl CameraControl} instances that is added on this controller.
         */
        get: function () {
          return this._controls;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Remove all attached controls, and removes all event listeners attached by that controls.
       * @returns {void} Nothing
       */

      __proto.clear = function () {
        this._controls.forEach(function (control) {
          return control.destroy();
        });

        this._controls = [];
      };
      /**
       * Add a new control
       * @param control {@link CameraControl CameraControl} instance to add
       * @see Adding Controls
       * @returns {void} Nothing
       */


      __proto.add = function (control) {
        var canvas = this._canvas;

        if (!control.element) {
          // Set canvas as default element
          control.setElement(canvas);
        }

        control.sync(this._camera);
        control.enable();

        this._controls.push(control);
      };
      /**
       * Remove control and disable it
       * @param control {@link CameraControl CameraControl} instance to remove
       * @returns removed control or null if it doesn't exists
       */


      __proto.remove = function (control) {
        var controls = this._controls;
        var controlIndex = findIndex(control, controls);
        if (controlIndex < 0) return null;
        var removedControl = controls.splice(controlIndex, 1)[0];
        removedControl.disable();
        return removedControl;
      };
      /**
       * Enable all controls attached
       * @returns {void} Nothing
       */


      __proto.enableAll = function () {
        this._controls.forEach(function (control) {
          return control.enable();
        });

        this.syncToCamera();
      };
      /**
       * Disable all controls attached
       * @returns {void} Nothing
       */


      __proto.disableAll = function () {
        this._controls.forEach(function (control) {
          return control.disable();
        });
      };
      /**
       * Update all controls attached to given screen size.
       * @param size Size of the screen. Noramlly size of the canvas is used.
       * @returns {void} Nothing
       */


      __proto.resize = function (size) {
        this._controls.forEach(function (control) {
          return control.resize(size);
        });
      };
      /**
       * Synchronize all controls attached to current camera position.
       * @returns {void} Nothing
       */


      __proto.syncToCamera = function () {
        var _this = this;

        this._controls.forEach(function (control) {
          return control.sync(_this._camera);
        });
      };
      /**
       * Update all controls attached to this controller & update camera position based on it.
       * @param delta number of seconds to update controls
       * @returns {void} Nothing
       */


      __proto.update = function (delta) {
        var deltaMiliSec = delta * 1000;
        var camera = this._camera;

        this._controls.forEach(function (control) {
          control.update(camera, deltaMiliSec);
        });

        camera.updatePosition();
      };

      return Controller;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Data class of camera's pose
     */

    var Pose =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of pose
       * @param yaw yaw
       * @param pitch pitch
       * @param distance distance
       * @param pivot pivot
       * @see https://threejs.org/docs/#api/en/math/Vector3
       * @example
       * import { THREE, Pose } from "@egjs/view3d";
       *
       * const pose = new Pose(180, 45, 150, new THREE.Vector3(5, -1, 3));
       */
      function Pose(yaw, pitch, distance, pivot) {
        if (pivot === void 0) {
          pivot = new THREE.Vector3(0, 0, 0);
        }

        this.yaw = yaw;
        this.pitch = pitch;
        this.distance = distance;
        this.pivot = pivot;
      }
      /**
       * Clone this pose
       * @returns Cloned pose
       */


      var __proto = Pose.prototype;

      __proto.clone = function () {
        return new Pose(this.yaw, this.pitch, this.distance, this.pivot.clone());
      };

      return Pose;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    /**
     * Collection of easing functions
     * @namespace EASING
     * @example
     * import View3D, { RotateControl, EASING } from "@egjs/view3d";
     *
     * new RotateControl({
     *  easing: EASING.EASE_OUT_CUBIC,
     * });
     */

    /**
     * @memberof EASING
     * @name SINE_WAVE
     */
    var SINE_WAVE = function (x) {
      return Math.sin(x * Math.PI * 2);
    };
    /**
     * @memberof EASING
     * @name EASE_OUT_CUBIC
     */

    var EASE_OUT_CUBIC = function (x) {
      return 1 - Math.pow(1 - x, 3);
    };
    /**
     * @memberof EASING
     * @name EASE_OUT_BOUNCE
     */

    var EASE_OUT_BOUNCE = function (x) {
      var n1 = 7.5625;
      var d1 = 2.75;

      if (x < 1 / d1) {
        return n1 * x * x;
      } else if (x < 2 / d1) {
        return n1 * (x -= 1.5 / d1) * x + 0.75;
      } else if (x < 2.5 / d1) {
        return n1 * (x -= 2.25 / d1) * x + 0.9375;
      } else {
        return n1 * (x -= 2.625 / d1) * x + 0.984375;
      }
    };

    var EASING = {
        __proto__: null,
        SINE_WAVE: SINE_WAVE,
        EASE_OUT_CUBIC: EASE_OUT_CUBIC,
        EASE_OUT_BOUNCE: EASE_OUT_BOUNCE
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    var MODEL_SIZE = 80; // Animation related

    var EASING$1 = EASE_OUT_CUBIC;
    var ANIMATION_DURATION = 500;
    var ANIMATION_LOOP = false;
    var ANIMATION_RANGE = {
      min: 0,
      max: 1
    }; // Camera related

    var CAMERA_POSE = new Pose(0, 0, 100, new THREE.Vector3(0, 0, 0));
    var INFINITE_RANGE = {
      min: -Infinity,
      max: Infinity
    };
    var PITCH_RANGE = {
      min: -89.9,
      max: 89.9
    };
    var DISTANCE_RANGE = {
      min: 0,
      max: 500
    };
    var MINIMUM_DISTANCE = 1;
    var MAXIMUM_DISTANCE = 500;
    var NULL_ELEMENT = null;
    var DRACO_DECODER_URL = "https://www.gstatic.com/draco/v1/decoders/";

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var Motion =
    /*#__PURE__*/
    function () {
      function Motion(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.duration,
            duration = _c === void 0 ? ANIMATION_DURATION : _c,
            _d = _b.loop,
            loop = _d === void 0 ? ANIMATION_LOOP : _d,
            _e = _b.range,
            range = _e === void 0 ? ANIMATION_RANGE : _e,
            _f = _b.easing,
            easing = _f === void 0 ? EASING$1 : _f;

        this._duration = duration;
        this._loop = loop;
        this._range = range;
        this._easing = easing;
        this._activated = false;
        this.reset(0);
      }

      var __proto = Motion.prototype;
      Object.defineProperty(__proto, "val", {
        get: function () {
          return this._val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "start", {
        get: function () {
          return this._start;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "end", {
        get: function () {
          return this._end;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "progress", {
        get: function () {
          return this._progress;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "duration", {
        get: function () {
          return this._duration;
        },
        set: function (val) {
          this._duration = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "loop", {
        get: function () {
          return this._loop;
        },
        set: function (val) {
          this._loop = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "range", {
        get: function () {
          return this._range;
        },
        set: function (val) {
          this._range = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "easing", {
        get: function () {
          return this._easing;
        },
        set: function (val) {
          this._easing = val;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Update motion and progress it by given deltaTime
       * @param deltaTime number of milisec to update motion
       * @returns Difference(delta) of the value from the last update.
       */

      __proto.update = function (deltaTime) {
        if (!this._activated) return 0;
        var start = this._start;
        var end = this._end;
        var duration = this._duration;
        var prev = this._val;
        var loop = this._loop;
        var nextProgress = this._progress + deltaTime / duration;
        this._progress = loop ? circulate(nextProgress, 0, 1) : clamp(nextProgress, 0, 1);

        var easedProgress = this._easing(this._progress);

        this._val = mix(start, end, easedProgress);

        if (!loop && this._progress >= 1) {
          this._activated = false;
        }

        return this._val - prev;
      };

      __proto.reset = function (defaultVal) {
        var range = this._range;
        var val = clamp(defaultVal, range.min, range.max);
        this._start = val;
        this._end = val;
        this._val = val;
        this._progress = 0;
        this._activated = false;
      };

      __proto.setEndDelta = function (delta) {
        var range = this._range;
        this._start = this._val;
        this._end = clamp(this._end + delta, range.min, range.max);
        this._progress = 0;
        this._activated = true;
      };

      return Motion;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Control that animates model without user input
     * @category Controls
     */

    var AnimationControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of AnimationControl
       * @param from Start pose
       * @param to End pose
       * @param {object} options Options
       * @param {number} [options.duration=500] Animation duration
       * @param {function} [options.easing=(x: number) => 1 - Math.pow(1 - x, 3)] Animation easing function
       */
      function AnimationControl(from, to, _a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.duration,
            duration = _c === void 0 ? ANIMATION_DURATION : _c,
            _d = _b.easing,
            easing = _d === void 0 ? EASING$1 : _d;

        this._enabled = false;
        this._finishCallbacks = [];
        from = from.clone();
        to = to.clone();
        from.yaw = circulate(from.yaw, 0, 360);
        to.yaw = circulate(to.yaw, 0, 360); // Take the smaller degree

        if (Math.abs(to.yaw - from.yaw) > 180) {
          to.yaw = to.yaw < from.yaw ? to.yaw + 360 : to.yaw - 360;
        }

        this._motion = new Motion({
          duration: duration,
          range: ANIMATION_RANGE,
          easing: easing
        });
        this._from = from;
        this._to = to;
      }

      var __proto = AnimationControl.prototype;
      Object.defineProperty(__proto, "element", {
        get: function () {
          return null;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "duration", {
        /**
         * Duration of the animation
         */
        get: function () {
          return this._motion.duration;
        },
        set: function (val) {
          this._motion.duration = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "easing", {
        /**
         * Easing function of the animation
         */
        get: function () {
          return this._motion.easing;
        },
        set: function (val) {
          this._motion.easing = val;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Destroy the instance and remove all event listeners attached
       * This also will reset CSS cursor to intial
       * @returns {void} Nothing
       */

      __proto.destroy = function () {
        this.disable();
      };
      /**
       * Update control by given deltaTime
       * @param camera Camera to update position
       * @param deltaTime Number of milisec to update
       * @returns {void} Nothing
       */


      __proto.update = function (camera, deltaTime) {
        if (!this._enabled) return;
        var from = this._from;
        var to = this._to;
        var motion = this._motion;
        motion.update(deltaTime); // Progress that easing is applied

        var progress = motion.val;
        camera.yaw = mix(from.yaw, to.yaw, progress);
        camera.pitch = mix(from.pitch, to.pitch, progress);
        camera.distance = mix(from.distance, to.distance, progress);
        camera.pivot = from.pivot.clone().lerp(to.pivot, progress);

        if (motion.progress >= 1) {
          this.disable();

          this._finishCallbacks.forEach(function (callback) {
            return callback();
          });
        }
      };
      /**
       * Enable this input and add event listeners
       * @returns {void} Nothing
       */


      __proto.enable = function () {
        if (this._enabled) return;
        this._enabled = true;

        this._motion.reset(0);

        this._motion.setEndDelta(1);
      };
      /**
       * Disable this input and remove all event handlers
       * @returns {void} Nothing
       */


      __proto.disable = function () {
        if (!this._enabled) return;
        this._enabled = false;
      };
      /**
       * Add callback which is called when animation is finished
       * @param callback Callback that will be called when animation finishes
       * @returns {void} Nothing
       */


      __proto.onFinished = function (callback) {
        this._finishCallbacks.push(callback);
      };
      /**
       * Remove all onFinished callbacks
       * @returns {void} Nothing
       */


      __proto.clearFinished = function () {
        this._finishCallbacks = [];
      };

      __proto.resize = function (size) {// DO NOTHING
      };

      __proto.setElement = function (element) {// DO NOTHING
      };

      __proto.sync = function (camera) {// Do nothing
      };

      return AnimationControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Camera that renders the scene of View3D
     * @category Core
     */

    var Camera =
    /*#__PURE__*/
    function () {
      /**
       * Create new Camera instance
       * @param canvas \<canvas\> element to render 3d model
       */
      function Camera(canvas) {
        this._minDistance = MINIMUM_DISTANCE;
        this._maxDistance = MAXIMUM_DISTANCE;
        this._defaultPose = CAMERA_POSE;
        this._currentPose = this._defaultPose.clone();
        this._threeCamera = new THREE.PerspectiveCamera();
        this._controller = new Controller(canvas, this);
      }

      var __proto = Camera.prototype;
      Object.defineProperty(__proto, "threeCamera", {
        /**
         * Three.js {@link https://threejs.org/docs/#api/en/cameras/PerspectiveCamera PerspectiveCamera} instance
         * @readonly
         * @type THREE.PerspectiveCamera
         */
        get: function () {
          return this._threeCamera;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "controller", {
        /**
         * Controller of the camera
         * @readonly
         * @type Controller
         */
        get: function () {
          return this._controller;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "defaultPose", {
        /**
         * Camera's default pose(yaw, pitch, distance, pivot)
         * This will be new currentPose when {@link Camera#reset reset()} is called
         * @readonly
         * @type Pose
         */
        get: function () {
          return this._defaultPose;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "currentPose", {
        /**
         * Camera's current pose value
         * @readonly
         * @type Pose
         */
        get: function () {
          return this._currentPose.clone();
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "yaw", {
        /**
         * Camera's current yaw
         * {@link Camera#updatePosition} should be called after changing this value, and normally it is called every frame.
         * @type number
         */
        get: function () {
          return this._currentPose.yaw;
        },
        set: function (val) {
          this._currentPose.yaw = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "pitch", {
        /**
         * Camera's current pitch
         * {@link Camera#updatePosition} should be called after changing this value, and normally it is called every frame.
         * @type number
         */
        get: function () {
          return this._currentPose.pitch;
        },
        set: function (val) {
          this._currentPose.pitch = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "distance", {
        /**
         * Camera's current distance
         * {@link Camera#updatePosition} should be called after changing this value, and normally it is called every frame.
         * @type number
         */
        get: function () {
          return this._currentPose.distance;
        },
        set: function (val) {
          this._currentPose.distance = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "pivot", {
        /**
         * Current pivot point of camera rotation
         * @readonly
         * @type THREE.Vector3
         * @see {@link https://threejs.org/docs/#api/en/math/Vector3 THREE#Vector3}
         */
        get: function () {
          return this._currentPose.pivot;
        },
        set: function (val) {
          this._currentPose.pivot = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "minDistance", {
        /**
         * Minimum distance from lookAtPosition
         * @type number
         * @example
         * import View3D from "@egjs/view3d";
         *
         * const view3d = new View3D("#view3d-canvas");
         * view3d.camera.minDistance = 100;
         */
        get: function () {
          return this._minDistance;
        },
        set: function (val) {
          this._minDistance = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "maxDistance", {
        /**
         * Maximum distance from lookAtPosition
         * @type number
         * @example
         * import View3D from "@egjs/view3d";
         *
         * const view3d = new View3D("#view3d-canvas");
         * view3d.camera.maxDistance = 400;
         */
        get: function () {
          return this._maxDistance;
        },
        set: function (val) {
          this._maxDistance = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "fov", {
        /**
         * Camera's focus of view value
         * @type number
         * @see {@link https://threejs.org/docs/#api/en/cameras/PerspectiveCamera.fov THREE#PerspectiveCamera}
         */
        get: function () {
          return this._threeCamera.fov;
        },
        set: function (val) {
          this._threeCamera.fov = val;

          this._threeCamera.updateProjectionMatrix();
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "renderWidth", {
        /**
         * Camera's frustum width on current distance value
         * @type number
         */
        get: function () {
          return this.renderHeight * this._threeCamera.aspect;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "renderHeight", {
        /**
         * Camera's frustum height on current distance value
         * @type number
         */
        get: function () {
          return 2 * this.distance * Math.tan(toRadian(this.fov / 2));
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "pose", {
        set: function (val) {
          this._currentPose = val;

          this._controller.syncToCamera();
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Reset camera to default pose
       * @param duration Duration of the reset animation
       * @param easing Easing function for the reset animation
       * @returns Promise that resolves when the animation finishes
       */

      __proto.reset = function (duration, easing) {
        if (duration === void 0) {
          duration = 0;
        }

        if (easing === void 0) {
          easing = EASING$1;
        }

        var controller = this._controller;
        var currentPose = this._currentPose;
        var defaultPose = this._defaultPose;

        if (duration <= 0) {
          // Reset camera immediately
          this._currentPose = defaultPose.clone();
          controller.syncToCamera();
          return Promise.resolve();
        } else {
          // Add reset animation control to controller
          var resetControl_1 = new AnimationControl(currentPose, defaultPose);
          resetControl_1.duration = duration;
          resetControl_1.easing = easing;
          return new Promise(function (resolve) {
            resetControl_1.onFinished(function () {
              controller.remove(resetControl_1);
              controller.syncToCamera();
              resolve();
            });
            controller.add(resetControl_1);
          });
        }
      };
      /**
       * Update camera's aspect to given size
       * @param size {@link THREE.Vector2} instance that has width(x), height(y)
       * @returns {void} Nothing
       */


      __proto.resize = function (size) {
        var cam = this._threeCamera;
        var aspect = size.x / size.y;
        cam.aspect = aspect;
        cam.updateProjectionMatrix();

        this._controller.resize(size);
      };
      /**
       * Set default position of camera relative to the 3d model
       * New default pose will be used when {@link Camera#reset reset()} is called
       * @param newDefaultPose new default pose to apply
       * @returns {void} Nothing
       */


      __proto.setDefaultPose = function (newDefaultPose) {
        var defaultPose = this._defaultPose;
        var yaw = newDefaultPose.yaw,
            pitch = newDefaultPose.pitch,
            distance = newDefaultPose.distance,
            pivot = newDefaultPose.pivot;

        if (yaw != null) {
          defaultPose.yaw = yaw;
        }

        if (pitch != null) {
          defaultPose.pitch = pitch;
        }

        if (distance != null) {
          defaultPose.distance = distance;
        }

        if (pivot != null) {
          defaultPose.pivot = pivot;
        }
      };
      /**
       * Update camera position base on the {@link Camera#currentPose currentPose} value
       * @returns {void} Nothing
       */


      __proto.updatePosition = function () {
        this._clampCurrentPose();

        var threeCamera = this._threeCamera;
        var pose = this._currentPose;
        var yaw = toRadian(pose.yaw);
        var pitch = toRadian(pose.pitch); // Should use minimum distance to prevent distance becomes 0, which makes whole x,y,z to 0 regardless of pose

        var distance = Math.max(pose.distance + this._minDistance, MINIMUM_DISTANCE);
        var newCamPos = new THREE.Vector3(0, 0, 0);
        newCamPos.y = distance * Math.sin(pitch);
        newCamPos.z = distance * Math.cos(pitch);
        newCamPos.x = newCamPos.z * Math.sin(-yaw);
        newCamPos.z = newCamPos.z * Math.cos(-yaw);
        newCamPos.add(pose.pivot);
        threeCamera.position.copy(newCamPos);
        threeCamera.lookAt(pose.pivot);
        threeCamera.updateProjectionMatrix();
      };

      __proto._clampCurrentPose = function () {
        var currentPose = this._currentPose;
        currentPose.yaw = circulate(currentPose.yaw, 0, 360);
        currentPose.pitch = clamp(currentPose.pitch, PITCH_RANGE.min, PITCH_RANGE.max);
        currentPose.distance = clamp(currentPose.distance, this._minDistance, this._maxDistance);
      };

      return Camera;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Component that manages animations of the 3D Model
     * @category Core
     */

    var ModelAnimator =
    /*#__PURE__*/
    function () {
      /**
       * Create new ModelAnimator instance
       * @param scene {@link https://threejs.org/docs/index.html#api/en/scenes/Scene THREE.Scene} instance that is root of all 3d objects
       */
      function ModelAnimator(scene) {
        this._mixer = new THREE.AnimationMixer(scene);
        this._clips = [];
        this._actions = [];
      }

      var __proto = ModelAnimator.prototype;
      Object.defineProperty(__proto, "clips", {
        /**
         * Three.js {@link https://threejs.org/docs/#api/en/animation/AnimationClip AnimationClip}s that stored
         * @type THREE.AnimationClip
         * @readonly
         */
        get: function () {
          return this._clips;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "mixer", {
        /**
         * {@link https://threejs.org/docs/index.html#api/en/animation/AnimationMixer THREE.AnimationMixer} instance
         * @type THREE.AnimationMixer
         * @readonly
         */
        get: function () {
          return this._mixer;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Store the given clips
       * @param clips Three.js {@link https://threejs.org/docs/#api/en/animation/AnimationClip AnimationClip}s of the model
       * @returns {void} Nothing
       * @example
       * // After loading model
       * view3d.animator.setClips(model.animations);
       */

      __proto.setClips = function (clips) {
        var mixer = this._mixer;
        this._clips = clips;
        this._actions = clips.map(function (clip) {
          return mixer.clipAction(clip);
        });
      };
      /**
       * Play one of the model's animation
       * @param index Index of the animation to play
       * @returns {void} Nothing
       */


      __proto.play = function (index) {
        var action = this._actions[index];

        if (action) {
          action.play();
        }
      };
      /**
       * Pause one of the model's animation
       * If you want to stop animation completely, you should call {@link ModelAnimator#stop stop} instead
       * You should call {@link ModelAnimator#resume resume} to resume animation
       * @param index Index of the animation to pause
       * @returns {void} Nothing
       */


      __proto.pause = function (index) {
        var action = this._actions[index];

        if (action) {
          action.timeScale = 0;
        }
      };
      /**
       * Resume one of the model's animation
       * This will play animation from the point when the animation is paused
       * @param index Index of the animation to resume
       * @returns {void} Nothing
       */


      __proto.resume = function (index) {
        var action = this._actions[index];

        if (action) {
          action.timeScale = 1;
        }
      };
      /**
       * Fully stops one of the model's animation
       * @param index Index of the animation to stop
       * @returns {void} Nothing
       */


      __proto.stop = function (index) {
        var action = this._actions[index];

        if (action) {
          action.stop();
        }
      };
      /**
       * Update animations
       * @param delta number of seconds to play animations attached
       * @returns {void} Nothing
       */


      __proto.update = function (delta) {
        this._mixer.update(delta);
      };
      /**
       * Reset the instance and remove all cached animation clips attached to it
       * @returns {void} Nothing
       */


      __proto.reset = function () {
        var mixer = this._mixer;
        mixer.uncacheRoot(mixer.getRoot());
        this._clips = [];
        this._actions = [];
      };

      return ModelAnimator;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * XRManager that manages XRSessions
     * @category Core
     */

    var XRManager =
    /*#__PURE__*/
    function () {
      /**
       * Create a new instance of the XRManager
       * @param view3d Instance of the View3D
       */
      function XRManager(view3d) {
        this._view3d = view3d;
        this._sessions = [];
        this._currentSession = null;
      }

      var __proto = XRManager.prototype;
      Object.defineProperty(__proto, "sessions", {
        /**
         * Array of {@link XRSession}s added
         */
        get: function () {
          return this._sessions;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "currentSession", {
        /**
         * Current entry session. Note that only WebXR type session can be returned.
         */
        get: function () {
          return this._currentSession;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Return a Promise containing whether any of the added session is available
       */

      __proto.isAvailable = function () {
        return __awaiter(this, void 0, void 0, function () {
          var results;
          return __generator(this, function (_a) {
            switch (_a.label) {
              case 0:
                return [4
                /*yield*/
                , Promise.all(this._sessions.map(function (session) {
                  return session.isAvailable();
                }))];

              case 1:
                results = _a.sent();
                return [2
                /*return*/
                , results.some(function (result) {
                  return result === true;
                })];
            }
          });
        });
      };
      /**
       * Add new {@link XRSession}.
       * The XRSession's order added is the same as the order of entry.
       * @param xrSession XRSession to add
       */


      __proto.addSession = function () {
        var _a;

        var xrSession = [];

        for (var _i = 0; _i < arguments.length; _i++) {
          xrSession[_i] = arguments[_i];
        }

        (_a = this._sessions).push.apply(_a, __spread(xrSession));
      };
      /**
       * Enter XR Session.
       */


      __proto.enter = function () {
        return __awaiter(this, void 0, void 0, function () {
          return __generator(this, function (_a) {
            return [2
            /*return*/
            , this._enterSession(0, [])];
          });
        });
      };
      /**
       * Exit current XR Session.
       */


      __proto.exit = function () {
        if (this._currentSession) {
          this._currentSession.exit(this._view3d);

          this._currentSession = null;
        }
      };

      __proto._enterSession = function (sessionIdx, errors) {
        return __awaiter(this, void 0, void 0, function () {
          var view3d, sessions, xrSession, isSessionAvailable;

          var _this = this;

          return __generator(this, function (_a) {
            switch (_a.label) {
              case 0:
                view3d = this._view3d;
                sessions = this._sessions;

                if (sessionIdx >= sessions.length) {
                  if (errors.length < 1) {
                    errors.push(new Error("No sessions available"));
                  }

                  return [2
                  /*return*/
                  , Promise.reject(errors)];
                }

                xrSession = sessions[sessionIdx];
                return [4
                /*yield*/
                , xrSession.isAvailable()];

              case 1:
                isSessionAvailable = _a.sent();

                if (!isSessionAvailable) {
                  return [2
                  /*return*/
                  , this._enterSession(sessionIdx + 1, errors)];
                }

                return [4
                /*yield*/
                , xrSession.enter(view3d).then(function () {
                  if (xrSession.isWebXRSession) {
                    // Non-webxr sessions are ignored
                    _this._currentSession = xrSession;
                    xrSession.session.addEventListener("end", function () {
                      _this._currentSession = null;
                    });
                  }

                  return errors;
                }).catch(function (e) {
                  errors.push(e);
                  return _this._enterSession(sessionIdx + 1, errors);
                })];

              case 2:
                return [2
                /*return*/
                , _a.sent()];
            }
          });
        });
      };

      return XRManager;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    var EVENTS = {
      MOUSE_DOWN: "mousedown",
      MOUSE_MOVE: "mousemove",
      MOUSE_UP: "mouseup",
      TOUCH_START: "touchstart",
      TOUCH_MOVE: "touchmove",
      TOUCH_END: "touchend",
      WHEEL: "wheel",
      RESIZE: "resize",
      CONTEXT_MENU: "contextmenu",
      MOUSE_ENTER: "mouseenter",
      MOUSE_LEAVE: "mouseleave"
    }; // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.button

    var MOUSE_BUTTON;

    (function (MOUSE_BUTTON) {
      MOUSE_BUTTON[MOUSE_BUTTON["LEFT"] = 0] = "LEFT";
      MOUSE_BUTTON[MOUSE_BUTTON["MIDDLE"] = 1] = "MIDDLE";
      MOUSE_BUTTON[MOUSE_BUTTON["RIGHT"] = 2] = "RIGHT";
    })(MOUSE_BUTTON || (MOUSE_BUTTON = {}));

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Yet another 3d model viewer
     * @category Core
     * @mermaid
     * classDiagram
     *   class View3D
     *     View3D *-- Camera
     *     View3D *-- Renderer
     *     View3D *-- Scene
     *     View3D *-- ModelAnimator
     *     Camera *-- Controller
     * @event resize
     * @event beforeRender
     * @event afterRender
     */

    var View3D =
    /*#__PURE__*/
    function (_super) {
      __extends(View3D, _super);
      /**
       * Creates new View3D instance
       * @example
       * import View3D, { ERROR_CODES } from "@egjs/view3d";
       *
       * try {
       *   const view3d = new View3D("#wrapper")
       * } catch (e) {
       *   if (e.code === ERROR_CODES.ELEMENT_NOT_FOUND) {
       *     console.error("Element not found")
       *   }
       * }
       * @throws {View3DError} `CODES.WRONG_TYPE`<br/>When the parameter is not either string or the canvas element.
       * @throws {View3DError} `CODES.ELEMENT_NOT_FOUND`<br/>When the element with given query does not exist.
       * @throws {View3DError} `CODES.ELEMENT_NOT_CANVAS`<br/>When the element given is not a \<canvas\> element.
       * @throws {View3DError} `CODES.WEBGL_NOT_SUPPORTED`<br/>When browser does not support WebGL.
       * @see Model
       * @see Camera
       * @see Renderer
       * @see Scene
       * @see Controller
       * @see XRManager
       */


      function View3D(el) {
        var _this = _super.call(this) || this;
        /**
         * Resize View3D instance to fit current canvas size
         * @method
         * @returns {void} Nothing
         */


        _this.resize = function () {
          _this._renderer.resize();

          var newSize = _this._renderer.size;

          _this._camera.resize(newSize);

          _this.emit("resize", __assign(__assign({}, newSize), {
            target: _this
          }));
        };
        /**
         * View3D's basic render loop function
         * @param delta Number of seconds passed since last frame
         */


        _this.renderLoop = function (delta) {
          var renderer = _this._renderer;
          var scene = _this._scene;
          var camera = _this._camera;
          var controller = _this.controller;
          var animator = _this._animator;
          animator.update(delta);
          controller.update(delta);

          _this.emit("beforeRender", _this);

          renderer.render(scene, camera);

          _this.emit("afterRender", _this);
        };

        var canvas = getCanvas(el);
        _this._renderer = new Renderer(canvas);
        _this._camera = new Camera(canvas);
        _this._scene = new Scene();
        _this._animator = new ModelAnimator(_this._scene.root);
        _this._xr = new XRManager(_this);
        _this._model = null;

        _this.resize();

        window.addEventListener(EVENTS.RESIZE, _this.resize);
        return _this;
      }

      var __proto = View3D.prototype;
      Object.defineProperty(__proto, "renderer", {
        /**
         * {@link Renderer} instance of the View3D
         * @type {Renderer}
         */
        get: function () {
          return this._renderer;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scene", {
        /**
         * {@link Scene} instance of the View3D
         * @type {Scene}
         */
        get: function () {
          return this._scene;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "camera", {
        /**
         * {@link Camera} instance of the View3D
         * @type {Camera}
         */
        get: function () {
          return this._camera;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "controller", {
        /**
         * {@link Controller} instance of the Camera
         * @type {Controller}
         */
        get: function () {
          return this._camera.controller;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "animator", {
        /**
         * {@link ModelAnimator} instance of the View3D
         * @type {ModelAnimator}
         */
        get: function () {
          return this._animator;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "xr", {
        /**
         * {@link XRManager} instance of the View3D
         * @type {XRManager}
         */
        get: function () {
          return this._xr;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "model", {
        /**
         * {@link Model} that View3D is currently showing
         * @type {Model|null}
         */
        get: function () {
          return this._model;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Destroy View3D instance and remove all events attached to it
       * @returns {void} Nothing
       */

      __proto.destroy = function () {
        this._scene.reset();

        this.controller.clear();
        this._model = null;
        window.removeEventListener(EVENTS.RESIZE, this.resize);
      };
      /**
       * Display the given model.
       * This method will remove the current displaying model, and reset the camera & control to default position.
       * View3D can only show one model at a time
       * @param model {@link Model} instance to show
       * @param {object} [options={}] Display options
       * @param {number} [options.applySize=true] Whether to change model size to given "size" option.
       * @param {number} [options.size=80] Size of the model to show as.
       * @param {boolean} [options.resetView=true] Whether to reset the view to the camera's default pose.
       * @returns {void} Nothing
       */


      __proto.display = function (model, _a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.applySize,
            applySize = _c === void 0 ? true : _c,
            _d = _b.size,
            size = _d === void 0 ? MODEL_SIZE : _d,
            _e = _b.resetView,
            resetView = _e === void 0 ? true : _e;

        var renderer = this._renderer;
        var scene = this._scene;
        var camera = this._camera;
        var animator = this._animator;

        if (applySize) {
          model.size = size;
        } // model.moveToOrigin();


        scene.resetModel();

        if (resetView) {
          camera.reset();
        }

        animator.reset();
        this._model = model;
        scene.add(model.scene);
        animator.setClips(model.animations);
        scene.update(model);
        renderer.stopAnimationLoop();
        renderer.setAnimationLoop(this.renderLoop);
      };
      /**
       * Current version of the View3D
       */


      View3D.VERSION = "1.1.0";
      return View3D;
    }(EventEmitter);

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Data class for loaded 3d model
     * @category Core
     */

    var Model =
    /*#__PURE__*/
    function () {
      /**
       * Create new Model instance
       */
      function Model(_a) {
        var scenes = _a.scenes,
            _b = _a.animations,
            animations = _b === void 0 ? [] : _b,
            _c = _a.fixSkinnedBbox,
            fixSkinnedBbox = _c === void 0 ? false : _c,
            _d = _a.castShadow,
            castShadow = _d === void 0 ? true : _d,
            _e = _a.receiveShadow,
            receiveShadow = _e === void 0 ? false : _e; // This guarantees model's root has identity matrix at creation

        this._scene = new THREE.Group();
        var pivot = new THREE.Object3D();
        pivot.name = "Pivot";
        pivot.add.apply(pivot, __spread(scenes));

        this._scene.add(pivot);

        this._animations = animations;
        this._fixSkinnedBbox = fixSkinnedBbox;
        this._cachedLights = null;
        this._cachedMeshes = null;

        this._setInitialBbox();

        var bboxCenter = this._initialBbox.getCenter(new THREE.Vector3());

        pivot.position.copy(bboxCenter.negate());

        this._moveInitialBboxToCenter();

        this._originalSize = this.size;
        this.castShadow = castShadow;
        this.receiveShadow = receiveShadow;
      }

      var __proto = Model.prototype;
      Object.defineProperty(__proto, "scene", {
        /**
         * Scene of the model, see {@link https://threejs.org/docs/#api/en/objects/Group THREE.Group}
         * @readonly
         */
        get: function () {
          return this._scene;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "animations", {
        /**
         * {@link https://threejs.org/docs/#api/en/animation/AnimationClip THREE.AnimationClip}s inside model
         */
        get: function () {
          return this._animations;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "lights", {
        /***
         * {@link https://threejs.org/docs/#api/en/lights/Light THREE.Light}s inside model if there's any.
         * @readonly
         */
        get: function () {
          return this._cachedLights ? this._cachedLights : this._getAllLights();
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "meshes", {
        /**
         * {@link https://threejs.org/docs/#api/en/objects/Mesh THREE.Mesh}es inside model if there's any.
         * @readonly
         */
        get: function () {
          return this._cachedMeshes ? this._cachedMeshes : this._getAllMeshes();
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "bbox", {
        /**
         * Get a copy of model's current bounding box
         * @type THREE#Box3
         * @see https://threejs.org/docs/#api/en/math/Box3
         */
        get: function () {
          return this._getTransformedBbox();
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "initialBbox", {
        /**
         * Get a copy of model's initial bounding box without transform
         */
        get: function () {
          return this._initialBbox.clone();
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "size", {
        /**
         * Model's bounding box size
         * Changing this will scale the model.
         * @type number
         * @example
         * import { GLTFLoader } from "@egjs/view3d";
         * new GLTFLoader().load(URL_TO_GLTF)
         *  .then(model => {
         *    model.size = 100;
         *  })
         */
        get: function () {
          return this._getTransformedBbox().getSize(new THREE.Vector3()).length();
        },
        set: function (val) {
          var scene = this._scene;
          var initialBbox = this._initialBbox; // Modify scale

          var bboxSize = initialBbox.getSize(new THREE.Vector3());
          var scale = val / bboxSize.length();
          scene.scale.setScalar(scale);
          scene.updateMatrix();
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "fixSkinnedBbox", {
        /**
         * Whether to apply inference from skeleton when calculating bounding box
         * This can fix some models with skinned mesh when it has wrong bounding box
         * @type boolean
         */
        get: function () {
          return this._fixSkinnedBbox;
        },
        set: function (val) {
          this._fixSkinnedBbox = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "originalSize", {
        /**
         * Return the model's original bbox size before applying any transform
         * @type number
         */
        get: function () {
          return this._originalSize;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "castShadow", {
        /**
         * Whether the model's meshes gets rendered into shadow map
         * @type boolean
         * @example
         * model.castShadow = true;
         */
        set: function (val) {
          var meshes = this.meshes;
          meshes.forEach(function (mesh) {
            return mesh.castShadow = val;
          });
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "receiveShadow", {
        /**
         * Whether the model's mesh materials receive shadows
         * @type boolean
         * @example
         * model.receiveShadow = true;
         */
        set: function (val) {
          var meshes = this.meshes;
          meshes.forEach(function (mesh) {
            return mesh.receiveShadow = val;
          });
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Translate the model to center the model's bounding box to world origin (0, 0, 0).
       */

      __proto.moveToOrigin = function () {
        // Translate scene position to origin
        var scene = this._scene;

        var initialBbox = this._initialBbox.clone();

        initialBbox.min.multiply(scene.scale);
        initialBbox.max.multiply(scene.scale);
        var bboxCenter = initialBbox.getCenter(new THREE.Vector3());
        scene.position.copy(bboxCenter.negate());
        scene.updateMatrix();
      };

      __proto._setInitialBbox = function () {
        this._scene.updateMatrixWorld();

        if (this._fixSkinnedBbox && this._hasSkinnedMesh()) {
          this._initialBbox = this._getSkeletonBbox();
        } else {
          this._initialBbox = new THREE.Box3().setFromObject(this._scene);
        }
      };

      __proto._getSkeletonBbox = function () {
        var bbox = new THREE.Box3();
        this.meshes.forEach(function (mesh) {
          if (!mesh.isSkinnedMesh) {
            bbox.expandByObject(mesh);
            return;
          }

          var geometry = mesh.geometry;
          var positions = geometry.attributes.position;
          var skinIndicies = geometry.attributes.skinIndex;
          var skinWeights = geometry.attributes.skinWeight;
          var skeleton = mesh.skeleton;
          skeleton.update();
          var boneMatricies = skeleton.boneMatrices;
          var finalMatrix = new THREE.Matrix4();

          var _loop_1 = function (posIdx) {
            finalMatrix.identity();
            var skinned = new THREE.Vector4();
            skinned.set(0, 0, 0, 0);
            var skinVertex = new THREE.Vector4();
            skinVertex.set(positions.getX(posIdx), positions.getY(posIdx), positions.getZ(posIdx), 1).applyMatrix4(mesh.bindMatrix);
            var weights = [skinWeights.getX(posIdx), skinWeights.getY(posIdx), skinWeights.getZ(posIdx), skinWeights.getW(posIdx)];
            var indicies = [skinIndicies.getX(posIdx), skinIndicies.getY(posIdx), skinIndicies.getZ(posIdx), skinIndicies.getW(posIdx)];
            weights.forEach(function (weight, index) {
              var boneMatrix = new THREE.Matrix4().fromArray(boneMatricies, indicies[index] * 16);
              skinned.add(skinVertex.clone().applyMatrix4(boneMatrix).multiplyScalar(weight));
            });
            var transformed = new THREE.Vector3().fromArray(skinned.applyMatrix4(mesh.bindMatrixInverse).toArray());
            transformed.applyMatrix4(mesh.matrixWorld);
            bbox.expandByPoint(transformed);
          };

          for (var posIdx = 0; posIdx < positions.count; posIdx++) {
            _loop_1(posIdx);
          }
        });
        return bbox;
      };

      __proto._moveInitialBboxToCenter = function () {
        var bboxCenter = this._initialBbox.getCenter(new THREE.Vector3());

        this._initialBbox.translate(bboxCenter.negate());
      };

      __proto._getAllLights = function () {
        var lights = [];

        this._scene.traverse(function (obj) {
          if (obj.isLight) {
            lights.push(obj);
          }
        });

        this._cachedLights = lights;
        return lights;
      };
      /**
       * Get all {@link https://threejs.org/docs/#api/en/objects/Mesh THREE.Mesh}es inside model if there's any.
       * @private
       * @returns Meshes found at model's scene
       */


      __proto._getAllMeshes = function () {
        var meshes = [];

        this._scene.traverse(function (obj) {
          if (obj.isMesh) {
            meshes.push(obj);
          }
        });

        this._cachedMeshes = meshes;
        return meshes;
      };

      __proto._hasSkinnedMesh = function () {
        return this.meshes.some(function (mesh) {
          return mesh.isSkinnedMesh;
        });
      };

      __proto._getTransformedBbox = function () {
        return this._initialBbox.clone().applyMatrix4(this._scene.matrix);
      };

      return Model;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var Core = {
        __proto__: null,
        ModelAnimator: ModelAnimator,
        Model: Model,
        Renderer: Renderer,
        Scene: Scene,
        XRManager: XRManager,
        Camera: Camera,
        Controller: Controller,
        Pose: Pose
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Control that animates model without user input
     * @category Controls
     */

    var AutoControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new RotateControl instance
       * @param {object} options Options
       * @param {HTMLElement | string | null} [options.element=null] Attaching element / selector of the element
       * @param {number} [options.delay=2000] Reactivation delay after mouse input in milisecond
       * @param {number} [options.delayOnMouseLeave=0] Reactivation delay after mouse leave
       * @param {number} [options.speed=1] Y-axis(yaw) rotation speed
       * @param {boolean} [options.pauseOnHover=false] Whether to pause rotation on mouse hover
       * @param {boolean} [options.canInterrupt=true] Whether user can interrupt the rotation with click/wheel input
       * @param {boolean} [options.disableOnInterrupt=false] Whether to disable control on user interrupt
       * @tutorial Adding Controls
       */
      function AutoControl(_a) {
        var _this = this;

        var _b = _a === void 0 ? {} : _a,
            _c = _b.element,
            element = _c === void 0 ? NULL_ELEMENT : _c,
            _d = _b.delay,
            delay = _d === void 0 ? 2000 : _d,
            _e = _b.delayOnMouseLeave,
            delayOnMouseLeave = _e === void 0 ? 0 : _e,
            _f = _b.speed,
            speed = _f === void 0 ? 1 : _f,
            _g = _b.pauseOnHover,
            pauseOnHover = _g === void 0 ? false : _g,
            _h = _b.canInterrupt,
            canInterrupt = _h === void 0 ? true : _h,
            _j = _b.disableOnInterrupt,
            disableOnInterrupt = _j === void 0 ? false : _j; // Internal values


        this._targetEl = null;
        this._enabled = false;
        this._interrupted = false;
        this._interruptionTimer = -1;
        this._hovering = false;

        this._onMouseDown = function (evt) {
          if (!_this._canInterrupt) return;
          if (evt.button !== MOUSE_BUTTON.LEFT && evt.button !== MOUSE_BUTTON.RIGHT) return;
          _this._interrupted = true;

          _this._clearTimeout();

          window.addEventListener(EVENTS.MOUSE_UP, _this._onMouseUp, false);
        };

        this._onMouseUp = function () {
          window.removeEventListener(EVENTS.MOUSE_UP, _this._onMouseUp, false);

          _this._setUninterruptedAfterDelay(_this._delay);
        };

        this._onTouchStart = function () {
          if (!_this._canInterrupt) return;
          _this._interrupted = true;

          _this._clearTimeout();
        };

        this._onTouchEnd = function () {
          _this._setUninterruptedAfterDelay(_this._delay);
        };

        this._onMouseEnter = function () {
          if (!_this._pauseOnHover) return;
          _this._interrupted = true;
          _this._hovering = true;
        };

        this._onMouseLeave = function () {
          if (!_this._pauseOnHover) return;
          _this._hovering = false;

          _this._setUninterruptedAfterDelay(_this._delayOnMouseLeave);
        };

        this._onWheel = function () {
          if (!_this._canInterrupt) return;
          _this._interrupted = true;

          _this._setUninterruptedAfterDelay(_this._delay);
        };

        var targetEl = getElement(element);

        if (targetEl) {
          this.setElement(targetEl);
        }

        this._delay = delay;
        this._delayOnMouseLeave = delayOnMouseLeave;
        this._speed = speed;
        this._pauseOnHover = pauseOnHover;
        this._canInterrupt = canInterrupt;
        this._disableOnInterrupt = disableOnInterrupt;
      }

      var __proto = AutoControl.prototype;
      Object.defineProperty(__proto, "element", {
        /**
         * Control's current target element to attach event listeners
         * @readonly
         */
        get: function () {
          return this._targetEl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "delay", {
        /**
         * Reactivation delay after mouse input in milisecond
         */
        get: function () {
          return this._delay;
        },
        set: function (val) {
          this._delay = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "delayOnMouseLeave", {
        /**
         * Reactivation delay after mouse leave
         * This option only works when {@link AutoControl#pauseOnHover pauseOnHover} is activated
         */
        get: function () {
          return this._delayOnMouseLeave;
        },
        set: function (val) {
          this._delayOnMouseLeave = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "speed", {
        /**
         * Y-axis(yaw) rotation speed
         * @default 1
         */
        get: function () {
          return this._speed;
        },
        set: function (val) {
          this._speed = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "pauseOnHover", {
        /**
         * Whether to pause rotation on mouse hover
         * @default false
         */
        get: function () {
          return this._pauseOnHover;
        },
        set: function (val) {
          this._pauseOnHover = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "canInterrupt", {
        /**
         * Whether user can interrupt the rotation with click/wheel input
         * @default true
         */
        get: function () {
          return this._canInterrupt;
        },
        set: function (val) {
          this._canInterrupt = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "disableOnInterrupt", {
        /**
         * Whether to disable control on user interrupt
         * @default false
         */
        get: function () {
          return this._disableOnInterrupt;
        },
        set: function (val) {
          this._disableOnInterrupt = val;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Destroy the instance and remove all event listeners attached
       * This also will reset CSS cursor to intial
       * @returns {void} Nothing
       */

      __proto.destroy = function () {
        this.disable();
      };
      /**
       * Update control by given deltaTime
       * @param camera Camera to update position
       * @param deltaTime Number of milisec to update
       * @returns {void} Nothing
       */


      __proto.update = function (camera, deltaTime) {
        if (!this._enabled) return;

        if (this._interrupted) {
          if (this._disableOnInterrupt) {
            this.disable();
          }

          return;
        }

        camera.yaw += this._speed * deltaTime / 100;
      }; // This is not documetned on purpose as it doesn't do nothing


      __proto.resize = function (size) {// DO NOTHING
      };
      /**
       * Enable this input and add event listeners
       * @returns {void} Nothing
       */


      __proto.enable = function () {
        if (this._enabled) return;

        if (!this._targetEl) {
          throw new View3DError(MESSAGES.ADD_CONTROL_FIRST, CODES.ADD_CONTROL_FIRST);
        }

        var targetEl = this._targetEl;
        targetEl.addEventListener(EVENTS.MOUSE_DOWN, this._onMouseDown, false);
        targetEl.addEventListener(EVENTS.TOUCH_START, this._onTouchStart, false);
        targetEl.addEventListener(EVENTS.TOUCH_END, this._onTouchEnd, false);
        targetEl.addEventListener(EVENTS.MOUSE_ENTER, this._onMouseEnter, false);
        targetEl.addEventListener(EVENTS.MOUSE_LEAVE, this._onMouseLeave, false);
        targetEl.addEventListener(EVENTS.WHEEL, this._onWheel, false);
        this._enabled = true;
      };
      /**
       * Disable this input and remove all event handlers
       * @returns {void} Nothing
       */


      __proto.disable = function () {
        if (!this._enabled || !this._targetEl) return;
        var targetEl = this._targetEl;
        targetEl.removeEventListener(EVENTS.MOUSE_DOWN, this._onMouseDown, false);
        window.removeEventListener(EVENTS.MOUSE_UP, this._onMouseUp, false);
        targetEl.removeEventListener(EVENTS.TOUCH_START, this._onTouchStart, false);
        targetEl.removeEventListener(EVENTS.TOUCH_END, this._onTouchEnd, false);
        targetEl.removeEventListener(EVENTS.MOUSE_ENTER, this._onMouseEnter, false);
        targetEl.removeEventListener(EVENTS.MOUSE_LEAVE, this._onMouseLeave, false);
        targetEl.removeEventListener(EVENTS.WHEEL, this._onWheel, false);
        this._enabled = false;
        this._interrupted = false;
        this._hovering = false;

        this._clearTimeout();
      }; // This does nothing


      __proto.sync = function (camera) {// Do nothing
      };
      /**
       * Set target element to attach event listener
       * @param element target element
       * @returns {void} Nothing
       */


      __proto.setElement = function (element) {
        this._targetEl = element;
      };

      __proto._setUninterruptedAfterDelay = function (delay) {
        var _this = this;

        if (this._hovering) return;

        this._clearTimeout();

        if (delay > 0) {
          this._interruptionTimer = window.setTimeout(function () {
            _this._interrupted = false;
            _this._interruptionTimer = -1;
          }, delay);
        } else {
          this._interrupted = false;
          this._interruptionTimer = -1;
        }
      };

      __proto._clearTimeout = function () {
        if (this._interruptionTimer >= 0) {
          window.clearTimeout(this._interruptionTimer);
          this._interruptionTimer = -1;
        }
      };

      return AutoControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    var CURSOR = {
      GRAB: "grab",
      GRABBING: "grabbing"
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Model's rotation control that supports both mouse & touch
     * @category Controls
     */

    var RotateControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new RotateControl instance
       * @param {object} options Options
       * @param {HTMLElement | null} [options.element] Target element.
       * @param {number} [options.duration=500] Motion's duration.
       * @param {function} [options.easing=(x: number) => 1 - Math.pow(1 - x, 3)] Motion's easing function.
       * @param {THREE.Vector2} [options.scale=new THREE.Vector2(1, 1)] Scale factor for panning, x is for horizontal and y is for vertical panning.
       * @param {boolean} [options.useGrabCursor=true] Whether to apply CSS style `cursor: grab` on the target element or not.
       * @param {boolean} [options.scaleToElement=true] Whether to scale control to fit element size.
       * @tutorial Adding Controls
       */
      function RotateControl(_a) {
        var _this = this;

        var _b = _a === void 0 ? {} : _a,
            _c = _b.element,
            element = _c === void 0 ? NULL_ELEMENT : _c,
            _d = _b.duration,
            duration = _d === void 0 ? ANIMATION_DURATION : _d,
            _e = _b.easing,
            easing = _e === void 0 ? EASING$1 : _e,
            _f = _b.scale,
            scale = _f === void 0 ? new THREE.Vector2(1, 1) : _f,
            _g = _b.useGrabCursor,
            useGrabCursor = _g === void 0 ? true : _g,
            _h = _b.scaleToElement,
            scaleToElement = _h === void 0 ? true : _h; // Internal values


        this._targetEl = null;
        this._screenScale = new THREE.Vector2(0, 0);
        this._prevPos = new THREE.Vector2(0, 0);
        this._enabled = false;

        this._onMouseDown = function (evt) {
          if (evt.button !== MOUSE_BUTTON.LEFT) return;
          var targetEl = _this._targetEl;
          evt.preventDefault();
          targetEl.focus ? targetEl.focus() : window.focus();

          _this._prevPos.set(evt.clientX, evt.clientY);

          window.addEventListener(EVENTS.MOUSE_MOVE, _this._onMouseMove, false);
          window.addEventListener(EVENTS.MOUSE_UP, _this._onMouseUp, false);

          _this._setCursor(CURSOR.GRABBING);
        };

        this._onMouseMove = function (evt) {
          evt.preventDefault();
          var prevPos = _this._prevPos;
          var rotateDelta = new THREE.Vector2(evt.clientX, evt.clientY).sub(prevPos).multiply(_this._userScale);

          if (_this._scaleToElement) {
            rotateDelta.multiply(_this._screenScale);
          }

          _this._xMotion.setEndDelta(rotateDelta.x);

          _this._yMotion.setEndDelta(rotateDelta.y);

          prevPos.set(evt.clientX, evt.clientY);
        };

        this._onMouseUp = function () {
          _this._prevPos.set(0, 0);

          window.removeEventListener(EVENTS.MOUSE_MOVE, _this._onMouseMove, false);
          window.removeEventListener(EVENTS.MOUSE_UP, _this._onMouseUp, false);

          _this._setCursor(CURSOR.GRAB);
        };

        this._onTouchStart = function (evt) {
          evt.preventDefault();
          var touch = evt.touches[0];

          _this._prevPos.set(touch.clientX, touch.clientY);
        };

        this._onTouchMove = function (evt) {
          // Only the one finger motion should be considered
          if (evt.touches.length > 1) return;

          if (evt.cancelable !== false) {
            evt.preventDefault();
          }

          evt.stopPropagation();
          var touch = evt.touches[0];
          var prevPos = _this._prevPos;
          var rotateDelta = new THREE.Vector2(touch.clientX, touch.clientY).sub(prevPos).multiply(_this._userScale);

          if (_this._scaleToElement) {
            rotateDelta.multiply(_this._screenScale);
          }

          _this._xMotion.setEndDelta(rotateDelta.x);

          _this._yMotion.setEndDelta(rotateDelta.y);

          prevPos.set(touch.clientX, touch.clientY);
        };

        this._onTouchEnd = function (evt) {
          var touch = evt.touches[0];

          if (touch) {
            _this._prevPos.set(touch.clientX, touch.clientY);
          } else {
            _this._prevPos.set(0, 0);
          }
        };

        var targetEl = getElement(element);

        if (targetEl) {
          this.setElement(targetEl);
        }

        this._userScale = scale;
        this._useGrabCursor = useGrabCursor;
        this._scaleToElement = scaleToElement;
        this._xMotion = new Motion({
          duration: duration,
          range: INFINITE_RANGE,
          easing: easing
        });
        this._yMotion = new Motion({
          duration: duration,
          range: PITCH_RANGE,
          easing: easing
        });
      }

      var __proto = RotateControl.prototype;
      Object.defineProperty(__proto, "element", {
        /**
         * Control's current target element to attach event listeners
         * @readonly
         */
        get: function () {
          return this._targetEl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scale", {
        /**
         * Scale factor for panning, x is for horizontal and y is for vertical panning.
         * @type THREE.Vector2
         * @see https://threejs.org/docs/#api/en/math/Vector2
         * @example
         * const rotateControl = new View3D.RotateControl();
         * rotateControl.scale.setX(2);
         */
        get: function () {
          return this._userScale;
        },
        set: function (val) {
          this._userScale.copy(val);
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "useGrabCursor", {
        /**
         * Whether to apply CSS style `cursor: grab` on the target element or not
         * @default true
         * @example
         * const rotateControl = new View3D.RotateControl();
         * rotateControl.useGrabCursor = true;
         */
        get: function () {
          return this._useGrabCursor;
        },
        set: function (val) {
          if (!val) {
            this._setCursor("");

            this._useGrabCursor = false;
          } else {
            this._useGrabCursor = true;

            this._setCursor(CURSOR.GRAB);
          }
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scaleToElement", {
        /**
         * Whether to scale control to fit element size.
         * When this is true and {@link RotateControl#scale scale.x} is 1, panning through element's width will make 3d model's yaw rotate 360°.
         * When this is true and {@link RotateControl#scale scale.y} is 1, panning through element's height will make 3d model's pitch rotate 180°.
         * @default true
         * @example
         * import View3D, { RotateControl } from "@egjs/view3d";
         * const view3d = new View3D("#view3d-canvas");
         * const rotateControl = new RotateControl();
         * rotateControl.scaleToElement = true;
         * view3d.controller.add(rotateControl);
         * view3d.resize();
         */
        get: function () {
          return this._scaleToElement;
        },
        set: function (val) {
          this._scaleToElement = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Destroy the instance and remove all event listeners attached
       * This also will reset CSS cursor to intial
       * @returns {void} Nothing
       */

      __proto.destroy = function () {
        this.disable();
      };
      /**
       * Update control by given deltaTime
       * @param camera Camera to update position
       * @param deltaTime Number of milisec to update
       * @returns {void} Nothing
       */


      __proto.update = function (camera, deltaTime) {
        var xMotion = this._xMotion;
        var yMotion = this._yMotion;
        var delta = new THREE.Vector2(xMotion.update(deltaTime), yMotion.update(deltaTime));
        camera.yaw += delta.x;
        camera.pitch += delta.y;
      };
      /**
       * Resize control to match target size
       * This method is only meaningful when {@link RotateControl#scaleToElement scaleToElement} is enabled
       * @param size {@link https://threejs.org/docs/#api/en/math/Vector2 THREE.Vector2} instance of width(x), height(y)
       */


      __proto.resize = function (size) {
        this._screenScale.set(360 / size.x, 180 / size.y);
      };
      /**
       * Enable this input and add event listeners
       * @returns {void} Nothing
       */


      __proto.enable = function () {
        if (this._enabled) return;

        if (!this._targetEl) {
          throw new View3DError(MESSAGES.ADD_CONTROL_FIRST, CODES.ADD_CONTROL_FIRST);
        }

        var targetEl = this._targetEl;
        targetEl.addEventListener(EVENTS.MOUSE_DOWN, this._onMouseDown, false);
        targetEl.addEventListener(EVENTS.TOUCH_START, this._onTouchStart, false);
        targetEl.addEventListener(EVENTS.TOUCH_MOVE, this._onTouchMove, false);
        targetEl.addEventListener(EVENTS.TOUCH_END, this._onTouchEnd, false);
        this._enabled = true;

        this._setCursor(CURSOR.GRAB);
      };
      /**
       * Disable this input and remove all event handlers
       * @returns {void} Nothing
       */


      __proto.disable = function () {
        if (!this._enabled || !this._targetEl) return;
        var targetEl = this._targetEl;
        targetEl.removeEventListener(EVENTS.MOUSE_DOWN, this._onMouseDown, false);
        window.removeEventListener(EVENTS.MOUSE_MOVE, this._onMouseMove, false);
        window.removeEventListener(EVENTS.MOUSE_UP, this._onMouseUp, false);
        targetEl.removeEventListener(EVENTS.TOUCH_START, this._onTouchStart, false);
        targetEl.removeEventListener(EVENTS.TOUCH_MOVE, this._onTouchMove, false);
        targetEl.removeEventListener(EVENTS.TOUCH_END, this._onTouchEnd, false);

        this._setCursor("");

        this._enabled = false;
      };
      /**
       * Synchronize this control's state to given camera position
       * @param camera Camera to match state
       * @returns {void} Nothing
       */


      __proto.sync = function (camera) {
        this._xMotion.reset(camera.yaw);

        this._yMotion.reset(camera.pitch);
      };
      /**
       * Set target element to attach event listener
       * @param element target element
       * @returns {void} Nothing
       */


      __proto.setElement = function (element) {
        this._targetEl = element;
        this.resize(new THREE.Vector2(element.offsetWidth, element.offsetHeight));
      };

      __proto._setCursor = function (val) {
        var targetEl = this._targetEl;
        if (!this._useGrabCursor || !targetEl || !this._enabled) return;
        targetEl.style.cursor = val;
      };

      return RotateControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Model's translation control that supports both mouse & touch
     * @category Controls
     */

    var TranslateControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new TranslateControl instance
       * @param {object} options Options
       * @param {HTMLElement | null} [options.element] Target element.
       * @param {function} [options.easing=(x: number) => 1 - Math.pow(1 - x, 3)] Motion's easing function.
       * @param {THREE.Vector2} [options.scale=new THREE.Vector2(1, 1)] Scale factor for translation.
       * @param {boolean} [options.useGrabCursor=true] Whether to apply CSS style `cursor: grab` on the target element or not.
       * @param {boolean} [options.scaleToElement=true] Whether to scale control to fit element size.
       * @tutorial Adding Controls
       */
      function TranslateControl(_a) {
        var _this = this;

        var _b = _a === void 0 ? {} : _a,
            _c = _b.element,
            element = _c === void 0 ? NULL_ELEMENT : _c,
            _d = _b.easing,
            easing = _d === void 0 ? EASING$1 : _d,
            _e = _b.scale,
            scale = _e === void 0 ? new THREE.Vector2(1, 1) : _e,
            _f = _b.useGrabCursor,
            useGrabCursor = _f === void 0 ? true : _f,
            _g = _b.scaleToElement,
            scaleToElement = _g === void 0 ? true : _g; // Internal values


        this._targetEl = null;
        this._enabled = false; // Sometimes, touchstart for second finger doesn't triggered.
        // This flag checks whether that happened

        this._touchInitialized = false;
        this._prevPos = new THREE.Vector2(0, 0);
        this._screenSize = new THREE.Vector2(0, 0);

        this._onMouseDown = function (evt) {
          if (evt.button !== MOUSE_BUTTON.RIGHT) return;
          var targetEl = _this._targetEl;
          evt.preventDefault();
          targetEl.focus ? targetEl.focus() : window.focus();

          _this._prevPos.set(evt.clientX, evt.clientY);

          window.addEventListener(EVENTS.MOUSE_MOVE, _this._onMouseMove, false);
          window.addEventListener(EVENTS.MOUSE_UP, _this._onMouseUp, false);

          _this._setCursor(CURSOR.GRABBING);
        };

        this._onMouseMove = function (evt) {
          evt.preventDefault();
          var prevPos = _this._prevPos;
          var delta = new THREE.Vector2(evt.clientX, evt.clientY).sub(prevPos).multiply(_this._userScale); // X value is negated to match cursor direction

          _this._xMotion.setEndDelta(-delta.x);

          _this._yMotion.setEndDelta(delta.y);

          prevPos.set(evt.clientX, evt.clientY);
        };

        this._onMouseUp = function () {
          _this._prevPos.set(0, 0);

          window.removeEventListener(EVENTS.MOUSE_MOVE, _this._onMouseMove, false);
          window.removeEventListener(EVENTS.MOUSE_UP, _this._onMouseUp, false);

          _this._setCursor(CURSOR.GRAB);
        };

        this._onTouchStart = function (evt) {
          // Only the two finger motion should be considered
          if (evt.touches.length !== 2) return;
          evt.preventDefault();

          _this._prevPos.copy(_this._getTouchesMiddle(evt.touches));

          _this._touchInitialized = true;
        };

        this._onTouchMove = function (evt) {
          // Only the two finger motion should be considered
          if (evt.touches.length !== 2) return;

          if (evt.cancelable !== false) {
            evt.preventDefault();
          }

          evt.stopPropagation();
          var prevPos = _this._prevPos;

          var middlePoint = _this._getTouchesMiddle(evt.touches);

          if (!_this._touchInitialized) {
            prevPos.copy(middlePoint);
            _this._touchInitialized = true;
            return;
          }

          var delta = new THREE.Vector2().subVectors(middlePoint, prevPos).multiply(_this._userScale); // X value is negated to match cursor direction

          _this._xMotion.setEndDelta(-delta.x);

          _this._yMotion.setEndDelta(delta.y);

          prevPos.copy(middlePoint);
        };

        this._onTouchEnd = function (evt) {
          // Only the two finger motion should be considered
          if (evt.touches.length !== 2) {
            _this._touchInitialized = false;
            return;
          } // Three fingers to two fingers


          _this._prevPos.copy(_this._getTouchesMiddle(evt.touches));

          _this._touchInitialized = true;
        };

        this._onContextMenu = function (evt) {
          evt.preventDefault();
        };

        var targetEl = getElement(element);

        if (targetEl) {
          this.setElement(targetEl);
        }

        this._xMotion = new Motion({
          duration: 0,
          range: INFINITE_RANGE,
          easing: easing
        });
        this._yMotion = new Motion({
          duration: 0,
          range: INFINITE_RANGE,
          easing: easing
        });
        this._userScale = scale;
        this._useGrabCursor = useGrabCursor;
        this._scaleToElement = scaleToElement;
      }

      var __proto = TranslateControl.prototype;
      Object.defineProperty(__proto, "element", {
        /**
         * Control's current target element to attach event listeners
         * @readonly
         */
        get: function () {
          return this._targetEl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scale", {
        /**
         * Scale factor for translation
         * @type THREE.Vector2
         * @see https://threejs.org/docs/#api/en/math/Vector2
         * @example
         * import { TranslateControl } from "@egjs/view3d";
         * const translateControl = new TranslateControl();
         * translateControl.scale.set(2, 2);
         */
        get: function () {
          return this._userScale;
        },
        set: function (val) {
          this._userScale.copy(val);
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "useGrabCursor", {
        /**
         * Whether to apply CSS style `cursor: grab` on the target element or not
         * @default true
         * @example
         * import { TranslateControl } from "@egjs/view3d";
         * const translateControl = new TranslateControl();
         * translateControl.useGrabCursor = true;
         */
        get: function () {
          return this._useGrabCursor;
        },
        set: function (val) {
          if (!val) {
            this._setCursor("");

            this._useGrabCursor = false;
          } else {
            this._useGrabCursor = true;

            this._setCursor(CURSOR.GRAB);
          }
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scaleToElement", {
        /**
         * Scale control to fit element size.
         * When this is true, camera's pivot change will correspond same amount you've dragged.
         * @default true
         * @example
         * import View3D, { TranslateControl } from "@egjs/view3d";
         * const view3d = new View3D("#view3d-canvas");
         * const translateControl = new TranslateControl();
         * translateControl.scaleToElement = true;
         * view3d.controller.add(translateControl);
         * view3d.resize();
         */
        get: function () {
          return this._scaleToElement;
        },
        set: function (val) {
          this._scaleToElement = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Destroy the instance and remove all event listeners attached
       * This also will reset CSS cursor to intial
       * @returns {void} Nothing
       */

      __proto.destroy = function () {
        this.disable();
      };
      /**
       * Update control by given deltaTime
       * @param deltaTime Number of milisec to update
       * @returns {void} Nothing
       */


      __proto.update = function (camera, deltaTime) {
        var screenSize = this._screenSize;
        var delta = new THREE.Vector2(this._xMotion.update(deltaTime), this._yMotion.update(deltaTime));
        var viewXDir = new THREE.Vector3(1, 0, 0).applyQuaternion(camera.threeCamera.quaternion);
        var viewYDir = new THREE.Vector3(0, 1, 0).applyQuaternion(camera.threeCamera.quaternion);

        if (this._scaleToElement) {
          var screenScale = new THREE.Vector2(camera.renderWidth, camera.renderHeight).divide(screenSize);
          delta.multiply(screenScale);
        }

        camera.pivot.add(viewXDir.multiplyScalar(delta.x));
        camera.pivot.add(viewYDir.multiplyScalar(delta.y));
      };
      /**
       * Resize control to match target size
       * This method is only meaningful when {@link RotateControl#scaleToElementSize scaleToElementSize} is enabled
       * @param size {@link https://threejs.org/docs/#api/en/math/Vector2 THREE.Vector2} instance of width(x), height(y)
       */


      __proto.resize = function (size) {
        var screenSize = this._screenSize;
        screenSize.copy(size);
      };
      /**
       * Enable this input and add event listeners
       * @returns {void} Nothing
       */


      __proto.enable = function () {
        if (this._enabled) return;

        if (!this._targetEl) {
          throw new View3DError(MESSAGES.ADD_CONTROL_FIRST, CODES.ADD_CONTROL_FIRST);
        }

        var targetEl = this._targetEl;
        targetEl.addEventListener(EVENTS.MOUSE_DOWN, this._onMouseDown, false);
        targetEl.addEventListener(EVENTS.TOUCH_START, this._onTouchStart, false);
        targetEl.addEventListener(EVENTS.TOUCH_MOVE, this._onTouchMove, false);
        targetEl.addEventListener(EVENTS.TOUCH_END, this._onTouchEnd, false);
        targetEl.addEventListener(EVENTS.CONTEXT_MENU, this._onContextMenu, false);
        this._enabled = true;

        this._setCursor(CURSOR.GRAB);
      };
      /**
       * Disable this input and remove all event handlers
       * @returns {void} Nothing
       */


      __proto.disable = function () {
        if (!this._enabled || !this._targetEl) return;
        var targetEl = this._targetEl;
        targetEl.removeEventListener(EVENTS.MOUSE_DOWN, this._onMouseDown, false);
        window.removeEventListener(EVENTS.MOUSE_MOVE, this._onMouseMove, false);
        window.removeEventListener(EVENTS.MOUSE_UP, this._onMouseUp, false);
        targetEl.removeEventListener(EVENTS.TOUCH_START, this._onTouchStart, false);
        targetEl.removeEventListener(EVENTS.TOUCH_MOVE, this._onTouchMove, false);
        targetEl.removeEventListener(EVENTS.TOUCH_END, this._onTouchEnd, false);
        targetEl.removeEventListener(EVENTS.CONTEXT_MENU, this._onContextMenu, false);

        this._setCursor("");

        this._enabled = false;
      };
      /**
       * Synchronize this control's state to given camera position
       * @param camera Camera to match state
       * @returns {void} Nothing
       */


      __proto.sync = function (camera) {
        this._xMotion.reset(0);

        this._yMotion.reset(0);
      };
      /**
       * Set target element to attach event listener
       * @param element target element
       * @returns {void} Nothing
       */


      __proto.setElement = function (element) {
        this._targetEl = element;
        this.resize(new THREE.Vector2(element.offsetWidth, element.offsetHeight));
      };

      __proto._setCursor = function (val) {
        var targetEl = this._targetEl;
        if (!this._useGrabCursor || !targetEl || !this._enabled) return;
        targetEl.style.cursor = val;
      };

      __proto._getTouchesMiddle = function (touches) {
        return new THREE.Vector2(touches[0].clientX + touches[1].clientX, touches[0].clientY + touches[1].clientY).multiplyScalar(0.5);
      };

      return TranslateControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Distance controller handling both mouse wheel and pinch zoom
     * @category Controls
     */

    var DistanceControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new DistanceControl instance
       * @tutorial Adding Controls
       * @param {object} options Options
       * @param {HTMLElement | string | null} [options.element=null] Attaching element / selector of the element.
       * @param {number} [options.duration=500] Motion's duration.
       * @param {object} [options.range={min: 0, max: 500}] Motion's range.
       * @param {function} [options.easing=(x: number) => 1 - Math.pow(1 - x, 3)] Motion's easing function.
       */
      function DistanceControl(_a) {
        var _this = this;

        var _b = _a === void 0 ? {} : _a,
            _c = _b.element,
            element = _c === void 0 ? NULL_ELEMENT : _c,
            _d = _b.duration,
            duration = _d === void 0 ? ANIMATION_DURATION : _d,
            _e = _b.range,
            range = _e === void 0 ? DISTANCE_RANGE : _e,
            _f = _b.easing,
            easing = _f === void 0 ? EASING$1 : _f; // Options


        this._scale = 1; // Internal values

        this._targetEl = null;
        this._scaleModifier = 0.25;
        this._prevTouchDistance = -1;
        this._enabled = false;

        this._onWheel = function (evt) {
          if (evt.deltaY === 0) return;
          evt.preventDefault();
          evt.stopPropagation();
          var animation = _this._motion;
          var delta = _this._scale * _this._scaleModifier * evt.deltaY;
          animation.setEndDelta(delta);
        };

        this._onTouchMove = function (evt) {
          var touches = evt.touches;
          if (touches.length !== 2) return;

          if (evt.cancelable !== false) {
            evt.preventDefault();
          }

          evt.stopPropagation();
          var animation = _this._motion;
          var prevTouchDistance = _this._prevTouchDistance;
          var touchPoint1 = new THREE.Vector2(touches[0].pageX, touches[0].pageY);
          var touchPoint2 = new THREE.Vector2(touches[1].pageX, touches[1].pageY);
          var touchDiff = touchPoint1.sub(touchPoint2);

          var touchDistance = touchDiff.length() * _this._scale * _this._scaleModifier;

          var delta = -(touchDistance - prevTouchDistance);
          _this._prevTouchDistance = touchDistance;
          if (prevTouchDistance < 0) return;
          animation.setEndDelta(delta);
        };

        this._onTouchEnd = function () {
          _this._prevTouchDistance = -1;
        };

        var targetEl = getElement(element);

        if (targetEl) {
          this.setElement(targetEl);
        }

        this._motion = new Motion({
          duration: duration,
          range: range,
          easing: easing
        });
      }

      var __proto = DistanceControl.prototype;
      Object.defineProperty(__proto, "element", {
        /**
         * Control's current target element to attach event listeners
         * @readonly
         */
        get: function () {
          return this._targetEl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scale", {
        /**
         * Scale factor of the distance
         * @type number
         * @example
         * import { DistanceControl } from "@egjs/view3d";
         * const distanceControl = new DistanceControl();
         * distanceControl.scale = 2;
         */
        get: function () {
          return this._scale;
        },
        set: function (val) {
          this._scale = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Destroy the instance and remove all event listeners attached
       * @returns {void} Nothing
       */

      __proto.destroy = function () {
        this.disable();
      };
      /**
       * Update control by given deltaTime
       * @param camera Camera to update position
       * @param deltaTime Number of milisec to update
       * @returns {void} Nothing
       */


      __proto.update = function (camera, deltaTime) {
        var motion = this._motion;
        camera.distance += motion.update(deltaTime);
      }; // This is not documetned on purpose as it doesn't do nothing


      __proto.resize = function (size) {// DO NOTHING
      };
      /**
       * Enable this input and add event listeners
       * @returns {void} Nothing
       */


      __proto.enable = function () {
        if (this._enabled) return;

        if (!this._targetEl) {
          throw new View3DError(MESSAGES.ADD_CONTROL_FIRST, CODES.ADD_CONTROL_FIRST);
        }

        var targetEl = this._targetEl;
        targetEl.addEventListener(EVENTS.WHEEL, this._onWheel, false);
        targetEl.addEventListener(EVENTS.TOUCH_MOVE, this._onTouchMove, false);
        targetEl.addEventListener(EVENTS.TOUCH_END, this._onTouchEnd, false);
        this._enabled = true;
      };
      /**
       * Disable this input and remove all event handlers
       * @returns {void} Nothing
       */


      __proto.disable = function () {
        if (!this._enabled || !this._targetEl) return;
        var targetEl = this._targetEl;
        targetEl.removeEventListener(EVENTS.WHEEL, this._onWheel, false);
        targetEl.removeEventListener(EVENTS.TOUCH_MOVE, this._onTouchMove, false);
        targetEl.removeEventListener(EVENTS.TOUCH_END, this._onTouchEnd, false);
        this._enabled = false;
      };
      /**
       * Synchronize this control's state to given camera position
       * @param camera Camera to match state
       * @returns {void} Nothing
       */


      __proto.sync = function (camera) {
        this._motion.range.min = camera.minDistance;
        this._motion.range.max = camera.maxDistance;

        this._motion.reset(camera.distance);
      };
      /**
       * Set target element to attach event listener
       * @param element target element
       * @returns {void} Nothing
       */


      __proto.setElement = function (element) {
        this._targetEl = element;
      };

      return DistanceControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Aggregation of {@link RotateControl}, {@link TranslateControl}, and {@link DistanceControl}.
     * @category Controls
     */

    var OrbitControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new OrbitControl instance
       * @param {object} options Options
       * @param {HTMLElement | string | null} [options.element=null] Attaching element / selector of the element
       * @param {object} [options.rotate={}] Constructor options of {@link RotateControl}
       * @param {object} [options.translate={}] Constructor options of {@link TranslateControl}
       * @param {object} [options.distance={}] Constructor options of {@link DistanceControl}
       * @tutorial Adding Controls
       */
      function OrbitControl(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.element,
            element = _c === void 0 ? NULL_ELEMENT : _c,
            _d = _b.rotate,
            rotate = _d === void 0 ? {} : _d,
            _e = _b.translate,
            translate = _e === void 0 ? {} : _e,
            _f = _b.distance,
            distance = _f === void 0 ? {} : _f;

        this._enabled = false;
        this._targetEl = getElement(element);
        this._rotateControl = new RotateControl(__assign(__assign({}, rotate), {
          element: rotate.element || this._targetEl
        }));
        this._translateControl = new TranslateControl(__assign(__assign({}, translate), {
          element: translate.element || this._targetEl
        }));
        this._distanceControl = new DistanceControl(__assign(__assign({}, distance), {
          element: distance.element || this._targetEl
        }));
      }

      var __proto = OrbitControl.prototype;
      Object.defineProperty(__proto, "element", {
        /**
         * Control's current target element to attach event listeners
         * @readonly
         */
        get: function () {
          return this._targetEl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "rotate", {
        /**
         * {@link RotateControl} of this control
         */
        get: function () {
          return this._rotateControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "translate", {
        /**
         * {@link TranslateControl} of this control
         */
        get: function () {
          return this._translateControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "distance", {
        /**
         * {@link DistanceControl} of this control
         */
        get: function () {
          return this._distanceControl;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Destroy the instance and remove all event listeners attached
       * This also will reset CSS cursor to intial
       * @returns {void} Nothing
       */

      __proto.destroy = function () {
        this._rotateControl.destroy();

        this._translateControl.destroy();

        this._distanceControl.destroy();
      };
      /**
       * Update control by given deltaTime
       * @param camera Camera to update position
       * @param deltaTime Number of milisec to update
       * @returns {void} Nothing
       */


      __proto.update = function (camera, deltaTime) {
        this._rotateControl.update(camera, deltaTime);

        this._translateControl.update(camera, deltaTime);

        this._distanceControl.update(camera, deltaTime);
      };
      /**
       * Resize control to match target size
       * @param size {@link https://threejs.org/docs/#api/en/math/Vector2 THREE.Vector2} instance of width(x), height(y)
       */


      __proto.resize = function (size) {
        this._rotateControl.resize(size);

        this._translateControl.resize(size);

        this._distanceControl.resize(size);
      };
      /**
       * Enable this control and add event listeners
       * @returns {void} Nothingß
       */


      __proto.enable = function () {
        if (this._enabled) return;

        if (!this._targetEl) {
          throw new View3DError(MESSAGES.ADD_CONTROL_FIRST, CODES.ADD_CONTROL_FIRST);
        }

        this._rotateControl.enable();

        this._translateControl.enable();

        this._distanceControl.enable();

        this._enabled = true;
      };
      /**
       * Disable this control and remove all event handlers
       * @returns {void} Nothing
       */


      __proto.disable = function () {
        if (!this._enabled || !this._targetEl) return;

        this._rotateControl.disable();

        this._translateControl.disable();

        this._distanceControl.disable();

        this._enabled = false;
      };
      /**
       * Synchronize this control's state to given camera position
       * @param camera Camera to match state
       * @returns {void} Nothing
       */


      __proto.sync = function (camera) {
        this._rotateControl.sync(camera);

        this._translateControl.sync(camera);

        this._distanceControl.sync(camera);
      };
      /**
       * Set target element to attach event listener
       * @param element target element
       * @returns {void} Nothing
       */


      __proto.setElement = function (element) {
        this._targetEl = element;

        this._rotateControl.setElement(element);

        this._translateControl.setElement(element);

        this._distanceControl.setElement(element);
      };

      return OrbitControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var Controls = {
        __proto__: null,
        AnimationControl: AnimationControl,
        AutoControl: AutoControl,
        Motion: Motion,
        OrbitControl: OrbitControl,
        RotateControl: RotateControl,
        TranslateControl: TranslateControl,
        DistanceControl: DistanceControl
    };

    /**
     * DracoLoader
     * @category Loaders
     */

    var DracoLoader =
    /*#__PURE__*/
    function () {
      function DracoLoader() {}
      /**
       * Load new DRC model from the given url
       * @param url URL to fetch .drc file
       * @param options Options for a loaded model
       * @returns Promise that resolves {@link Model}
       */


      var __proto = DracoLoader.prototype;

      __proto.load = function (url, options) {
        var _this = this;

        if (options === void 0) {
          options = {};
        }

        var loader = new DRACOLoader.DRACOLoader();
        loader.setCrossOrigin("anonymous");
        loader.setDecoderPath(DRACO_DECODER_URL);
        loader.manager = new THREE.LoadingManager();
        return new Promise(function (resolve, reject) {
          loader.load(url, function (geometry) {
            var model = _this._parseToModel(geometry, options);

            loader.dispose();
            resolve(model);
          }, undefined, function (err) {
            loader.dispose();
            reject(err);
          });
        });
      };

      __proto._parseToModel = function (geometry, _a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.fixSkinnedBbox,
            fixSkinnedBbox = _c === void 0 ? false : _c,
            _d = _b.color,
            color = _d === void 0 ? 0xffffff : _d,
            _e = _b.point,
            point = _e === void 0 ? false : _e,
            _f = _b.pointOptions,
            pointOptions = _f === void 0 ? {} : _f;

        geometry.computeVertexNormals();
        var material = point ? new THREE.PointsMaterial(__assign({
          color: color
        }, pointOptions)) : new THREE.MeshStandardMaterial({
          color: color
        });
        var mesh = point ? new THREE.Points(geometry, material) : new THREE.Mesh(geometry, material);
        var model = new Model({
          scenes: [mesh],
          fixSkinnedBbox: fixSkinnedBbox
        });
        return model;
      };

      return DracoLoader;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * THREE.DirectionalLight wrapper that will automatically update its shadow size to model
     * Shadow is enabled by default, use {@link AutoDirectionalLight#disableShadow disableShadow} to disable it
     * @category Environment
     */

    var AutoDirectionalLight =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of AutoDirectionalLight
       * @param [color="#ffffff"] Color of the light
       * @param [intensity=1] Intensity of the light
       * @param {object} [options={}] Additional options
       * @param {THREE.Vector3} [options.direction=new THREE.Vector3(-1, -1, -1)] Direction of the light
       */
      function AutoDirectionalLight(color, intensity, _a) {
        if (color === void 0) {
          color = "#ffffff";
        }

        if (intensity === void 0) {
          intensity = 1;
        }

        var _b = (_a === void 0 ? {} : _a).direction,
            direction = _b === void 0 ? new THREE.Vector3(-1, -1, -1) : _b;
        this._light = new THREE.DirectionalLight(color, intensity); // Set the default position ratio of the directional light

        var light = this._light;
        light.castShadow = true; // Is enabled by default

        light.shadow.mapSize.width = 2048;
        light.shadow.mapSize.height = 2048;
        light.matrixAutoUpdate = false;
        this._direction = direction.clone().normalize();
      }

      var __proto = AutoDirectionalLight.prototype;
      Object.defineProperty(__proto, "objects", {
        /**
         * Array of lights that used in this preset
         * @see https://threejs.org/docs/#api/en/lights/Light
         */
        get: function () {
          return [this._light, this._light.target];
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "light", {
        /**
         * The actual THREE.DirectionalLight
         * @type THREE#DirectionalLight
         * @see https://threejs.org/docs/#api/en/lights/DirectionalLight
         */
        get: function () {
          return this._light;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "position", {
        /**
         * Position of the light
         * @type THREE#Vector3
         * @see https://threejs.org/docs/#api/en/math/Vector3
         */
        get: function () {
          return this._light.position;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "direction", {
        get: function () {
          return this._direction;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Make light cast a shadow
       */

      __proto.enableShadow = function () {
        this._light.castShadow = true;
      };
      /**
       * Make light don't cast a shadow
       */


      __proto.disableShadow = function () {
        this._light.castShadow = false;
      };
      /**
       * Modify light's position & shadow camera size from model's bounding box
       * @param model Model to fit size
       * @param scale Scale factor for shadow camera size
       */


      __proto.fit = function (model, _a) {
        var _b = (_a === void 0 ? {} : _a).scale,
            scale = _b === void 0 ? 1.5 : _b;
        var bbox = model.bbox;
        var light = this._light;
        var direction = this._direction;
        var boxSize = bbox.getSize(new THREE.Vector3()).length();
        var boxCenter = bbox.getCenter(new THREE.Vector3()); // Position fitting

        var newPos = new THREE.Vector3().addVectors(boxCenter, direction.clone().negate().multiplyScalar(boxSize * 0.5));
        light.position.copy(newPos);
        light.target.position.copy(boxCenter);
        light.updateMatrix(); // Shadowcam fitting

        var shadowCam = light.shadow.camera;
        shadowCam.near = 0;
        shadowCam.far = 2 * boxSize;
        shadowCam.position.copy(newPos);
        shadowCam.lookAt(boxCenter);
        shadowCam.left = -1;
        shadowCam.right = 1;
        shadowCam.top = 1;
        shadowCam.bottom = -1;
        shadowCam.updateMatrixWorld();
        shadowCam.updateProjectionMatrix();
        var bboxPoints = getBoxPoints(bbox);
        var projectedPoints = bboxPoints.map(function (position) {
          return position.project(shadowCam);
        });
        var screenBbox = new THREE.Box3().setFromPoints(projectedPoints);
        shadowCam.left *= -scale * screenBbox.min.x;
        shadowCam.right *= scale * screenBbox.max.x;
        shadowCam.top *= scale * screenBbox.max.y;
        shadowCam.bottom *= -scale * screenBbox.min.y;
        shadowCam.updateProjectionMatrix();
      };

      return AutoDirectionalLight;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Helper class to easily add shadow plane under your 3D model
     * @category Environment
     * @example
     * import View3D, { ShadowPlane } from "@egjs/view3d";
     *
     * const view3d = new View3D("#view3d-canvas");
     * const shadowPlane = new ShadowPlane();
     * view3d.scene.addEnv(shadowPlane);
     */

    var ShadowPlane =
    /*#__PURE__*/
    function () {
      /**
       * Create new shadow plane
       * @param {object} options Options
       * @param {number} [options.size=10000] Size of the shadow plane
       * @param {number} [options.opacity=0.3] Opacity of the shadow
       */
      function ShadowPlane(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.size,
            size = _c === void 0 ? 10000 : _c,
            _d = _b.opacity,
            opacity = _d === void 0 ? 0.3 : _d;

        this.geometry = new THREE.PlaneGeometry(size, size, 100, 100);
        this.material = new THREE.ShadowMaterial({
          opacity: opacity
        });
        this.mesh = new THREE.Mesh(this.geometry, this.material);
        var mesh = this.mesh;
        mesh.rotateX(-Math.PI / 2);
        mesh.receiveShadow = true;
      }

      var __proto = ShadowPlane.prototype;
      Object.defineProperty(__proto, "objects", {
        get: function () {
          return [this.mesh];
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "opacity", {
        /**
         * Shadow opacity, value can be between 0(invisible) and 1(solid)
         * @type number
         */
        get: function () {
          return this.material.opacity;
        },
        set: function (val) {
          this.material.opacity = val;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Fit shadow plane's size & position to given model
       * @param model Model to fit
       */

      __proto.fit = function (model, _a) {
        var _b = _a === void 0 ? {} : _a,
            floorPosition = _b.floorPosition,
            _c = _b.floorRotation,
            floorRotation = _c === void 0 ? new THREE.Quaternion(0, 0, 0, 1) : _c;

        var modelPosition = model.scene.position;
        var localYAxis = new THREE.Vector3(0, 1, 0).applyQuaternion(floorRotation); // Apply position

        if (floorPosition) {
          // Apply a tiny offset to prevent z-fighting with original model
          this.mesh.position.copy(floorPosition.clone().add(localYAxis.clone().multiplyScalar(0.001)));
        } else {
          var modelBbox = model.bbox;
          var modelBboxYOffset = modelBbox.getCenter(new THREE.Vector3()).y - modelBbox.min.y;
          var modelFloor = new THREE.Vector3().addVectors(modelPosition, // Apply a tiny offset to prevent z-fighting with original model
          localYAxis.multiplyScalar(-modelBboxYOffset + 0.0001));
          this.mesh.position.copy(modelFloor);
        } // Apply rotation


        var rotX90 = new THREE.Quaternion().setFromEuler(new THREE.Euler(-Math.PI / 2, 0, 0));
        var shadowRotation = new THREE.Quaternion().multiplyQuaternions(floorRotation, rotX90);
        this.mesh.quaternion.copy(shadowRotation);
        this.mesh.updateMatrix();
      };

      return ShadowPlane;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var Environments = {
        __proto__: null,
        AutoDirectionalLight: AutoDirectionalLight,
        ShadowPlane: ShadowPlane
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * GLTFLoader
     * @category Loaders
     */

    var GLTFLoader =
    /*#__PURE__*/
    function () {
      /**
       * Create a new instance of GLTFLoader
       */
      function GLTFLoader() {
        this._loader = new GLTFLoader$1.GLTFLoader();
        this._dracoLoader = new DRACOLoader.DRACOLoader();
        var loader = this._loader;
        loader.setCrossOrigin("anonymous");
        var dracoLoader = this._dracoLoader;
        dracoLoader.setDecoderPath(DRACO_DECODER_URL);
        loader.setDRACOLoader(dracoLoader);
      }

      var __proto = GLTFLoader.prototype;
      Object.defineProperty(__proto, "loader", {
        get: function () {
          return this._loader;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "dracoLoader", {
        get: function () {
          return this._dracoLoader;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Load new GLTF model from the given url
       * @param url URL to fetch glTF/glb file
       * @param options Options for a loaded model
       * @returns Promise that resolves {@link Model}
       */

      __proto.load = function (url, options) {
        var _this = this;

        if (options === void 0) {
          options = {};
        }

        var loader = this._loader;
        loader.manager = new THREE.LoadingManager();
        return new Promise(function (resolve, reject) {
          loader.load(url, function (gltf) {
            var model = _this._parseToModel(gltf, options);

            resolve(model);
          }, undefined, function (err) {
            reject(err);
          });
        });
      };
      /**
       * Load preset generated from View3D editor.
       * @param viewer Instance of the {@link View3D}.
       * @param url Preset url
       * @param {object} options Options
       * @param {string} [options.path] Base path for additional files.
       * @param {function} [options.onLoad] Callback which called after each model LOD is loaded.
       * @returns {Model} Model instance with highest LOD
       */


      __proto.loadPreset = function (viewer, url, options) {
        var _this = this;

        if (options === void 0) {
          options = {};
        }

        var loader = this._loader;
        var fileLoader = new THREE.FileLoader();
        return fileLoader.loadAsync(url).then(function (jsonRaw) {
          return new Promise(function (resolve, reject) {
            var json = JSON.parse(jsonRaw);
            var baseURL = THREE.LoaderUtils.extractUrlBase(url); // Reset

            viewer.scene.reset();
            viewer.camera.reset();
            viewer.animator.reset();
            var modelOptions = json.model;
            var cameraOptions = json.camera;
            var environmentOptions = json.env;
            viewer.camera.setDefaultPose({
              yaw: cameraOptions.yaw,
              pitch: cameraOptions.pitch
            });
            viewer.camera.minDistance = cameraOptions.distanceRange[0];
            viewer.camera.maxDistance = cameraOptions.distanceRange[1];

            if (environmentOptions.background) {
              viewer.scene.setBackground(new THREE.Color(environmentOptions.background));
            }

            var shadowPlane = new ShadowPlane();
            shadowPlane.opacity = environmentOptions.shadow.opacity;
            viewer.scene.addEnv(shadowPlane);
            var ambientOptions = environmentOptions.ambient;
            var ambient = new THREE.AmbientLight(new THREE.Color(ambientOptions.color), ambientOptions.intensity);
            viewer.scene.addEnv(ambient);
            var lightOptions = [environmentOptions.light1, environmentOptions.light2, environmentOptions.light3];
            lightOptions.forEach(function (lightOption) {
              var lightDirection = new THREE.Vector3(lightOption.x, lightOption.y, lightOption.z).negate();
              var directional = new AutoDirectionalLight(new THREE.Color(lightOption.color), lightOption.intensity, {
                direction: lightDirection
              });
              directional.light.castShadow = lightOption.castShadow;
              directional.light.updateMatrixWorld();
              viewer.scene.addEnv(directional);
            });
            var isFirstLoad = true;
            var loadFlags = json.LOD.map(function () {
              return false;
            });
            json.LOD.forEach(function (fileName, lodIndex) {
              var glbURL = _this._resolveURL("" + baseURL + fileName, options.path || "");

              loader.load(glbURL, function (gltf) {
                loadFlags[lodIndex] = true;
                var higherLODLoaded = loadFlags.slice(lodIndex + 1).some(function (loaded) {
                  return loaded;
                });
                if (higherLODLoaded) return;

                var model = _this._parseToModel(gltf);

                viewer.display(model, {
                  size: modelOptions.size,
                  resetView: isFirstLoad
                });
                isFirstLoad = false;
                model.castShadow = modelOptions.castShadow;
                model.receiveShadow = modelOptions.receiveShadow;

                if (options.onLoad) {
                  options.onLoad(model, lodIndex);
                }

                if (lodIndex === json.LOD.length - 1) {
                  resolve(model);
                }
              }, undefined, function (err) {
                reject(err);
              });
            });
          });
        });
      };
      /**
       * Load new GLTF model from the given files
       * @param files Files that has glTF/glb and all its associated resources like textures and .bin data files
       * @param options Options for a loaded model
       * @returns Promise that resolves {@link Model}
       */


      __proto.loadFromFiles = function (files, options) {
        var _this = this;

        if (options === void 0) {
          options = {};
        }

        var objectURLs = [];

        var revokeURLs = function () {
          objectURLs.forEach(function (url) {
            URL.revokeObjectURL(url);
          });
        };

        return new Promise(function (resolve, reject) {
          if (files.length <= 0) {
            reject(new Error("No files found"));
            return;
          }

          var gltfFile = files.find(function (file) {
            return /\.(gltf|glb)$/i.test(file.name);
          });

          if (!gltfFile) {
            reject(new Error("No glTF file found"));
            return;
          }

          var filesMap = new Map();
          files.forEach(function (file) {
            filesMap.set(file.name, file);
          });
          var gltfURL = URL.createObjectURL(gltfFile);
          objectURLs.push(gltfURL);
          var manager = new THREE.LoadingManager();
          manager.setURLModifier(function (fileURL) {
            var fileNameResult = /[^\/|\\]+$/.exec(fileURL);
            var fileName = fileNameResult && fileNameResult[0] || "";

            if (filesMap.has(fileName)) {
              var blob = filesMap.get(fileName);
              var blobURL = URL.createObjectURL(blob);
              objectURLs.push(blobURL);
              return blobURL;
            }

            return fileURL;
          });
          var loader = _this._loader;
          loader.manager = manager;
          loader.load(gltfURL, function (gltf) {
            var model = _this._parseToModel(gltf, options);

            resolve(model);
            revokeURLs();
          }, undefined, function (err) {
            reject(err);
            revokeURLs();
          });
        });
      };
      /**
       * Parse from array buffer
       * @param data glTF asset to parse, as an ArrayBuffer or JSON string.
       * @param path The base path from which to find subsequent glTF resources such as textures and .bin data files.
       * @param options Options for a loaded model
       * @returns Promise that resolves {@link Model}
       */


      __proto.parse = function (data, path, options) {
        var _this = this;

        if (options === void 0) {
          options = {};
        }

        var loader = this._loader;
        loader.manager = new THREE.LoadingManager();
        return new Promise(function (resolve, reject) {
          loader.parse(data, path, function (gltf) {
            var model = _this._parseToModel(gltf, options);

            resolve(model);
          }, function (err) {
            reject(err);
          });
        });
      };

      __proto._parseToModel = function (gltf, _a) {
        var _b = (_a === void 0 ? {} : _a).fixSkinnedBbox,
            fixSkinnedBbox = _b === void 0 ? false : _b;
        var model = new Model({
          scenes: gltf.scenes,
          animations: gltf.animations,
          fixSkinnedBbox: fixSkinnedBbox
        });
        model.meshes.forEach(function (mesh) {
          var materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
          materials.forEach(function (mat) {
            if (mat.map) {
              mat.map.encoding = THREE.sRGBEncoding;
            }
          });
        });
        return model;
      }; // Grabbed from three.js/GLTFLoader
      // Original code: https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/GLTFLoader.js#L1221
      // License: MIT


      __proto._resolveURL = function (url, path) {
        // Invalid URL
        if (typeof url !== "string" || url === "") return ""; // Host Relative URL

        if (/^https?:\/\//i.test(path) && /^\//.test(url)) {
          path = path.replace(/(^https?:\/\/[^\/]+).*/i, "$1");
        } // Absolute URL http://,https://,//


        if (/^(https?:)?\/\//i.test(url)) return url; // Data URI

        if (/^data:.*,.*$/i.test(url)) return url; // Blob URL

        if (/^blob:.*$/i.test(url)) return url; // Relative URL

        return path + url;
      };

      return GLTFLoader;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Texture loader
     * @category Loaders
     */

    var TextureLoader =
    /*#__PURE__*/
    function () {
      /**
       * Create new TextureLoader instance
       * @param renderer {@link Renderer} instance of View3D
       */
      function TextureLoader(renderer) {
        this._renderer = renderer;
      }
      /**
       * Create new {@link https://threejs.org/docs/index.html#api/en/textures/Texture Texture} with given url
       * Texture's {@link https://threejs.org/docs/index.html#api/en/textures/Texture.flipY flipY} property is `true` by Three.js's policy, so be careful when using it as a map texture.
       * @param url url to fetch image
       */


      var __proto = TextureLoader.prototype;

      __proto.load = function (url) {
        return new Promise(function (resolve, reject) {
          var loader = new THREE.TextureLoader();
          loader.load(url, resolve, undefined, reject);
        });
      };
      /**
       * Create new {@link https://threejs.org/docs/#api/en/renderers/WebGLCubeRenderTarget WebGLCubeRenderTarget} with given equirectangular image url
       * Be sure that equirectangular image has height of power of 2, as it will be resized if it isn't
       * @param url url to fetch equirectangular image
       * @returns WebGLCubeRenderTarget created
       */


      __proto.loadEquirectagularTexture = function (url) {
        var _this = this;

        return new Promise(function (resolve, reject) {
          var loader = new THREE.TextureLoader();
          loader.load(url, function (skyboxTexture) {
            resolve(_this._equirectToCubemap(skyboxTexture));
          }, undefined, reject);
        });
      };
      /**
       * Create new {@link https://threejs.org/docs/#api/en/textures/CubeTexture CubeTexture} with given cubemap image urls
       * Image order should be: px, nx, py, ny, pz, nz
       * @param urls cubemap image urls
       * @returns CubeTexture created
       */


      __proto.loadCubeTexture = function (urls) {
        return new Promise(function (resolve, reject) {
          var loader = new THREE.CubeTextureLoader();
          loader.load(urls, resolve, undefined, reject);
        });
      };
      /**
       * Create new texture with given HDR(RGBE) image url
       * @param url image url
       * @param isEquirectangular Whether to read this image as a equirectangular texture
       */


      __proto.loadHDRTexture = function (url, isEquirectangular) {
        var _this = this;

        if (isEquirectangular === void 0) {
          isEquirectangular = true;
        }

        return new Promise(function (resolve, reject) {
          var loader = new RGBELoader.RGBELoader();
          loader.load(url, function (texture) {
            if (isEquirectangular) {
              resolve(_this._equirectToCubemap(texture));
            } else {
              resolve(texture);
            }
          }, undefined, reject);
        });
      };

      __proto._equirectToCubemap = function (texture) {
        return new THREE.WebGLCubeRenderTarget(texture.image.height).fromEquirectangularTexture(this._renderer.threeRenderer, texture);
      };

      return TextureLoader;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var Loaders = {
        __proto__: null,
        GLTFLoader: GLTFLoader,
        DracoLoader: DracoLoader,
        TextureLoader: TextureLoader
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    var QUICKLOOK_SUPPORTED = function () {
      var anchorEl = document.createElement("a");
      return anchorEl.relList && anchorEl.relList.supports && anchorEl.relList.supports("ar");
    }();
    var WEBXR_SUPPORTED = navigator.xr && navigator.xr.isSessionSupported;
    var HIT_TEST_SUPPORTED = window.XRSession && window.XRSession.prototype.requestHitTestSource;
    var DOM_OVERLAY_SUPPORTED = window.XRDOMOverlayState != null;
    var SESSION = {
      AR: "immersive-ar",
      VR: "immersive-ar"
    };
    var REFERENCE_SPACE = {
      LOCAL: "local",
      LOCAL_FLOOR: "local-floor",
      VIEWER: "viewer"
    };
    var EVENTS$1 = {
      SELECT_START: "selectstart",
      SELECT: "select",
      SELECT_END: "selectend"
    };
    var INPUT_PROFILE = {
      TOUCH: "generic-touchscreen"
    };
    var FEATURES = {
      HIT_TEST: {
        requiredFeatures: ["hit-test"]
      },
      DOM_OVERLAY: function (root) {
        return {
          optionalFeatures: ["dom-overlay"],
          domOverlay: {
            root: root
          }
        };
      }
    }; // For type definition

    var EMPTY_FEATURES = {};
    var SCENE_VIEWER = {
      INTENT_AR_CORE: function (params, fallback) {
        return "intent://arvr.google.com/scene-viewer/1.1?" + params + "#Intent;scheme=https;package=com.google.ar.core;action=android.intent.action.VIEW;" + (fallback ? "S.browser_fallback_url=" + fallback + ";" : "") + "end;";
      },
      INTENT_SEARCHBOX: function (params, fallback) {
        return "intent://arvr.google.com/scene-viewer/1.1?" + params + "#Intent;scheme=https;package=com.google.android.googlequicksearchbox;action=android.intent.action.VIEW;" + (fallback ? "S.browser_fallback_url=" + fallback + ";" : "") + "end;";
      },
      FALLBACK_DEFAULT: function (params) {
        return "https://arvr.google.com/scene-viewer?" + params;
      }
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Manager for WebXR dom-overlay feature
     * @category XR
     */

    var DOMOverlay =
    /*#__PURE__*/
    function () {
      /**
       * Create new DOMOverlay instance
       * @param {object} [options] Options
       * @param {HTMLElement} [options.root] Overlay root element
       * @param {HTMLElement | null} [options.loadingEl] Model loading indicator element which will be invisible after placing model on the floor.
       */
      function DOMOverlay(options) {
        this._root = options.root;
        this._loadingEl = options.loadingEl;
      }

      var __proto = DOMOverlay.prototype;
      Object.defineProperty(__proto, "root", {
        /**
         * Overlay root element
         */
        get: function () {
          return this._root;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "loadingElement", {
        /**
         * Loading indicator element, if there's any
         */
        get: function () {
          return this._loadingEl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "features", {
        /**
         * {@link https://developer.mozilla.org/en-US/docs/Web/API/XRSessionInit XRSessionInit} object for dom-overlay feature
         */
        get: function () {
          return FEATURES.DOM_OVERLAY(this._root);
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Return whether dom-overlay feature is available
       */

      __proto.isAvailable = function () {
        return DOM_OVERLAY_SUPPORTED;
      };
      /**
       * Show loading indicator, if there's any
       */


      __proto.showLoading = function () {
        if (!this._loadingEl) return;
        this._loadingEl.style.visibility = "visible";
      };
      /**
       * Hide loading indicator, if there's any
       */


      __proto.hideLoading = function () {
        if (!this._loadingEl) return;
        this._loadingEl.style.visibility = "hidden";
      };

      return DOMOverlay;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * WebXR based abstract AR session class
     * @category XR
     * @fires WebARSession#start
     * @fires WebARSession#end
     * @fires WebARSession#canPlace
     * @fires WebARSession#modelPlaced
     */

    var WebARSession =
    /*#__PURE__*/
    function (_super) {
      __extends(WebARSession, _super);
      /**
       * Emitted when session is started.
       * @event start
       * @category XR
       * @memberof WebARSession
       * @type void
       */

      /**
       * Emitted when session is ended.
       * @event end
       * @category XR
       * @memberof WebARSession
       * @type void
       */

      /**
       * Emitted when model can be placed on the space.
       * @event canPlace
       * @category XR
       * @memberof WebARSession
       * @type void
       */

      /**
       * Emitted when model is placed.
       * @event modelPlaced
       * @category XR
       * @memberof WebARSession
       * @type void
       */

      /**
       * Create new instance of WebARSession
       * @param {object} [options={}] Options
       * @param {object} [options.features={}] You can set additional features(see {@link https://developer.mozilla.org/en-US/docs/Web/API/XRSessionInit XRSessionInit}) with this option.
       * @param {number} [options.maxModelSize=Infinity] If model's size is too big to show on AR, you can restrict it's size with this option. Model with size bigger than this value will clamped to this value.
       * @param {HTMLElement|string|null} [options.overlayRoot=null] If this value is set, dom-overlay feature will be automatically added for this session. And this value will be used as dom-overlay's root element. You can set either HTMLElement or query selector for that element.
       * @param {HTMLElement|string|null} [options.loadingEl=null] This will be used for loading indicator element, which will automatically invisible after placing 3D model by setting `visibility: hidden`. This element must be placed under `overlayRoot`. You can set either HTMLElement or query selector for that element.
       * @param {boolean} [options.forceOverlay=false] Whether to apply `dom-overlay` feature as required. If set to false, `dom-overlay` will be optional feature.
       */


      function WebARSession(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.features,
            userFeatures = _c === void 0 ? EMPTY_FEATURES : _c,
            // https://developer.mozilla.org/en-US/docs/Web/API/XRSessionInit
        _d = _b.maxModelSize,
            // https://developer.mozilla.org/en-US/docs/Web/API/XRSessionInit
        maxModelSize = _d === void 0 ? Infinity : _d,
            _e = _b.overlayRoot,
            overlayRoot = _e === void 0 ? NULL_ELEMENT : _e,
            _f = _b.loadingEl,
            loadingEl = _f === void 0 ? NULL_ELEMENT : _f,
            _g = _b.forceOverlay,
            forceOverlay = _g === void 0 ? false : _g;

        var _this = _super.call(this) || this;
        /**
         * Whether it's webxr-based session or not
         * @type true
         */


        _this.isWebXRSession = true;
        _this._session = null;
        _this._domOverlay = null;
        var overlayEl = getElement(overlayRoot);
        var features = [];

        if (overlayEl) {
          _this._domOverlay = new DOMOverlay({
            root: overlayEl,
            loadingEl: getElement(loadingEl, overlayEl)
          });
          features.push(_this._domOverlay.features);
        }

        _this._features = merge.apply(void 0, __spread([{}], features, [userFeatures]));
        _this._maxModelSize = maxModelSize;
        _this._forceOverlay = forceOverlay;
        return _this;
      }

      var __proto = WebARSession.prototype;
      Object.defineProperty(__proto, "session", {
        /**
         * {@link https://developer.mozilla.org/en-US/docs/Web/API/XRSession XRSession} of this session
         * This value is only available after calling enter
         */
        get: function () {
          return this._session;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "features", {
        /**
         * {@link https://developer.mozilla.org/en-US/docs/Web/API/XRSessionInit XRSessionInit} object for this session.
         */
        get: function () {
          return this._features;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Return availability of this session
       * @returns {Promise} A Promise that resolves availability of this session(boolean).
       */

      __proto.isAvailable = function () {
        var domOverlay = this._domOverlay;
        if (!WEBXR_SUPPORTED || !HIT_TEST_SUPPORTED) return Promise.resolve(false);

        if (this._forceOverlay) {
          if (domOverlay && !domOverlay.isAvailable()) return Promise.resolve(false);
        }

        return navigator.xr.isSessionSupported(SESSION.AR);
      };
      /**
       * Enter session
       * @param view3d Instance of the View3D
       * @returns {Promise}
       */


      __proto.enter = function (view3d) {
        var _this = this; // Model not loaded yet


        if (!view3d.model) return Promise.reject("3D Model is not loaded");
        var model = view3d.model;
        return navigator.xr.requestSession(SESSION.AR, this._features).then(function (session) {
          var renderer = view3d.renderer;
          var threeRenderer = renderer.threeRenderer;
          var xrContext = {
            view3d: view3d,
            model: model,
            session: session
          }; // Cache original values

          var originalMatrix = model.scene.matrix.clone();
          var originalModelSize = model.size;
          var originalBackground = view3d.scene.root.background;
          var arModelSize = Math.min(model.originalSize, _this._maxModelSize);
          model.size = arModelSize;
          model.moveToOrigin();
          view3d.scene.setBackground(null); // Cache original model rotation

          threeRenderer.xr.setReferenceSpaceType(REFERENCE_SPACE.LOCAL);
          threeRenderer.xr.setSession(session);
          threeRenderer.setPixelRatio(1);

          _this.onStart(xrContext);

          session.addEventListener("end", function () {
            _this.onEnd(xrContext); // Restore original values


            model.scene.matrix.copy(originalMatrix);
            model.scene.matrix.decompose(model.scene.position, model.scene.quaternion, model.scene.scale);
            model.size = originalModelSize;
            model.moveToOrigin();
            view3d.scene.update(model);
            view3d.scene.setBackground(originalBackground); // Restore renderer values

            threeRenderer.xr.setSession(null);
            threeRenderer.setPixelRatio(window.devicePixelRatio); // Restore render loop

            renderer.stopAnimationLoop();
            renderer.setAnimationLoop(view3d.renderLoop);
          }, {
            once: true
          }); // Set XR session render loop

          renderer.stopAnimationLoop();
          renderer.setAnimationLoop(function (delta, frame) {
            var xrCam = threeRenderer.xr.getCamera(new THREE.PerspectiveCamera());
            var referenceSpace = threeRenderer.xr.getReferenceSpace();
            var glLayer = session.renderState.baseLayer;
            var size = {
              width: glLayer.framebufferWidth,
              height: glLayer.framebufferHeight
            };

            var renderContext = __assign(__assign({}, xrContext), {
              delta: delta,
              frame: frame,
              referenceSpace: referenceSpace,
              xrCam: xrCam,
              size: size
            });

            _this._beforeRender(renderContext);

            view3d.renderLoop(delta);
          });
        });
      };
      /**
       * Exit this session
       * @param view3d Instance of the View3D
       */


      __proto.exit = function (view3d) {
        var session = view3d.renderer.threeRenderer.xr.getSession();
        session.end();
      };

      __proto.onStart = function (ctx) {
        var _a;

        this._session = ctx.session;
        (_a = this._domOverlay) === null || _a === void 0 ? void 0 : _a.showLoading();
        this.emit("start");
      };

      __proto.onEnd = function (ctx) {
        var _a;

        this._session = null;
        (_a = this._domOverlay) === null || _a === void 0 ? void 0 : _a.hideLoading();
        this.emit("end");
      };

      return WebARSession;
    }(EventEmitter);

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Manager for WebXR hit-test feature
     * @category XR
     */

    var HitTest =
    /*#__PURE__*/
    function () {
      function HitTest() {
        this._source = null;
      }

      var __proto = HitTest.prototype;
      Object.defineProperty(__proto, "ready", {
        /**
         * Return whether hit-test is ready
         */
        get: function () {
          return this._source != null;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "features", {
        /**
         * {@link https://developer.mozilla.org/en-US/docs/Web/API/XRSessionInit XRSessionInit} object for hit-test feature
         */
        get: function () {
          return FEATURES.HIT_TEST;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Destroy instance
       */

      __proto.destroy = function () {
        if (this._source) {
          this._source.cancel();

          this._source = null;
        }
      };
      /**
       * Initialize hit-test feature
       * @param {XRSession} session XRSession instance
       */


      __proto.init = function (session) {
        var _this = this;

        session.requestReferenceSpace(REFERENCE_SPACE.VIEWER).then(function (referenceSpace) {
          session.requestHitTestSource({
            space: referenceSpace
          }).then(function (source) {
            _this._source = source;
          });
        });
      };
      /**
       * Return whether hit-test feature is available
       */


      __proto.isAvailable = function () {
        return HIT_TEST_SUPPORTED;
      };
      /**
       * Get hit-test results
       * @param {XRFrame} frame XRFrame instance
       */


      __proto.getResults = function (frame) {
        return frame.getHitTestResults(this._source);
      };

      return HitTest;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Fires for every animation frame when animation is active.
     * @type object
     * @property {object} event Event object.
     * @property {number} [event.progress] Current animation progress value.
     * Value is ranged from 0(start) to 1(end).
     * @property {number} [event.easedProgress] Eased progress value.
     * @event Animation#progress
     */

    /**
     * Fires for every animation loop except for the last loop
     * This will be triggered only when repeat > 0
     * @type object
     * @property {object} event Event object.
     * @property {number} [event.progress] Current animation progress value.
     * Value is ranged from 0(start) to 1(end).
     * @property {number} [event.easedProgress] Eased progress value.
     * @property {number} [event.loopIndex] Index of the current loop.
     * @event Animation#loop
     */

    /**
     * Fires when animation ends.
     * @type void
     * @event Animation#finish
     */

    /**
     * Self-running animation
     * @category Core
     */

    var Animation =
    /*#__PURE__*/
    function (_super) {
      __extends(Animation, _super);
      /**
       * Create new instance of the Animation
       * @param {object} [options={}] Options
       */


      function Animation(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.context,
            context = _c === void 0 ? window : _c,
            _d = _b.repeat,
            repeat = _d === void 0 ? 0 : _d,
            _e = _b.duration,
            duration = _e === void 0 ? ANIMATION_DURATION : _e,
            _f = _b.easing,
            easing = _f === void 0 ? EASE_OUT_CUBIC : _f;

        var _this = _super.call(this) || this;

        _this._loop = function () {
          var delta = _this._getDeltaTime();

          var duration = _this._duration;
          _this._time += delta;
          var loopIncrease = Math.floor(_this._time / duration);
          _this._time = circulate(_this._time, 0, duration);
          var progress = _this._time / duration;
          var progressEvent = {
            progress: progress,
            easedProgress: _this._easing(progress)
          };

          _this.emit("progress", progressEvent);

          for (var loopIdx = 0; loopIdx < loopIncrease; loopIdx++) {
            _this._loopCount++;

            if (_this._loopCount > _this._repeat) {
              _this.emit("finish");

              _this.stop();

              return;
            } else {
              _this.emit("loop", __assign(__assign({}, progressEvent), {
                loopIndex: _this._loopCount
              }));
            }
          }

          _this._rafId = _this._ctx.requestAnimationFrame(_this._loop);
        }; // Options


        _this._repeat = repeat;
        _this._duration = duration;
        _this._easing = easing; // Internal States

        _this._ctx = context;
        _this._rafId = -1;
        _this._time = 0;
        _this._clock = 0;
        _this._loopCount = 0;
        return _this;
      }

      var __proto = Animation.prototype;

      __proto.start = function () {
        if (this._rafId >= 0) return; // This guarantees "progress" event with progress = 0 on first start

        this._updateClock();

        this._loop();
      };

      __proto.stop = function () {
        if (this._rafId < 0) return;
        this._time = 0;
        this._loopCount = 0;

        this._stopLoop();
      };

      __proto.pause = function () {
        if (this._rafId < 0) return;

        this._stopLoop();
      };

      __proto._stopLoop = function () {
        this._ctx.cancelAnimationFrame(this._rafId);

        this._rafId = -1;
      };

      __proto._getDeltaTime = function () {
        var lastTime = this._clock;

        this._updateClock();

        return this._clock - lastTime;
      };

      __proto._updateClock = function () {
        this._clock = Date.now();
      };

      return Animation;
    }(EventEmitter);

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Rotation indicator for ARHoverSession
     * @category Controls-AR
     */

    var RotationIndicator =
    /*#__PURE__*/
    function () {
      /**
       * Create new RotationIndicator
       * @param {RotationIndicatorOption} [options={}] Options
       */
      function RotationIndicator(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.ringColor,
            ringColor = _c === void 0 ? 0xffffff : _c,
            _d = _b.axisColor,
            axisColor = _d === void 0 ? 0xffffff : _d;

        var ringGeometry = new THREE.RingGeometry(0.99, 1, 150, 1, 0, Math.PI * 2);
        var ringMaterial = new THREE.MeshBasicMaterial({
          color: ringColor,
          side: THREE.DoubleSide
        });
        this._ring = new THREE.Mesh(ringGeometry, ringMaterial);
        var axisVertices = [new THREE.Vector3(0, 0, -1000), new THREE.Vector3(0, 0, +1000)];
        var axisGeometry = new THREE.BufferGeometry().setFromPoints(axisVertices);
        var axisMaterial = new THREE.LineBasicMaterial({
          color: axisColor
        });
        this._axis = new THREE.Line(axisGeometry, axisMaterial);
        this._obj = new THREE.Group();

        this._obj.add(this._ring);

        this._obj.add(this._axis);

        this.hide();
      }

      var __proto = RotationIndicator.prototype;
      Object.defineProperty(__proto, "object", {
        /**
         * {@link https://threejs.org/docs/index.html#api/en/objects/Group THREE.Group} object that contains ring & axis.
         */
        get: function () {
          return this._obj;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Show indicator
       */

      __proto.show = function () {
        this._obj.visible = true;
      };
      /**
       * Hide indicator
       */


      __proto.hide = function () {
        this._obj.visible = false;
      };
      /**
       * Change the position of the indicator
       * @param position New position
       */


      __proto.updatePosition = function (position) {
        this._obj.position.copy(position);
      };
      /**
       * Update scale of the ring
       * @param scale New scale
       */


      __proto.updateScale = function (scale) {
        this._ring.scale.setScalar(scale);
      };
      /**
       * Update indicator's rotation
       * @param rotation Quaternion value set as new rotation.
       */


      __proto.updateRotation = function (rotation) {
        this._obj.quaternion.copy(rotation);
      };

      return RotationIndicator;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * One finger swirl control on single axis
     * @category Controls-AR
     */

    var ARSwirlControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new ARSwirlControl
       * @param {ARSwirlControlOption} [options={}] Options
       */
      function ARSwirlControl(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.scale,
            scale = _c === void 0 ? 1 : _c,
            _d = _b.showIndicator,
            showIndicator = _d === void 0 ? true : _d;
        /**
         * Current rotation value
         */


        this.rotation = new THREE.Quaternion(); // Internal States

        this._axis = new THREE.Vector3(0, 1, 0);
        this._enabled = true;
        this._active = false;
        this._prevPos = new THREE.Vector2();
        this._fromQuat = new THREE.Quaternion();
        this._toQuat = new THREE.Quaternion();
        this._motion = new Motion({
          range: INFINITE_RANGE
        });
        this._userScale = scale;

        if (showIndicator) {
          this._rotationIndicator = new RotationIndicator();
        }
      }

      var __proto = ARSwirlControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not.
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scale", {
        /**
         * Scale(speed) factor of this control.
         */
        get: function () {
          return this._userScale;
        },
        set: function (val) {
          this._userScale = val;
        },
        enumerable: false,
        configurable: true
      });

      __proto.init = function (_a) {
        var view3d = _a.view3d;
        var initialRotation = view3d.model.scene.quaternion;
        this.updateRotation(initialRotation);

        if (this._rotationIndicator) {
          view3d.scene.add(this._rotationIndicator.object);
        }
      };

      __proto.destroy = function (_a) {
        var view3d = _a.view3d;

        if (this._rotationIndicator) {
          view3d.scene.remove(this._rotationIndicator.object);
        }
      };

      __proto.updateRotation = function (rotation) {
        this.rotation.copy(rotation);

        this._fromQuat.copy(rotation);

        this._toQuat.copy(rotation);
      };
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._enabled = true;
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._enabled = false;
      };

      __proto.activate = function (_a, gesture) {
        var view3d = _a.view3d;
        if (!this._enabled) return;
        this._active = true;
        var model = view3d.model;
        var rotationIndicator = this._rotationIndicator;

        if (rotationIndicator) {
          rotationIndicator.show();
          rotationIndicator.updatePosition(model.bbox.getCenter(new THREE.Vector3()));
          rotationIndicator.updateScale(model.size / 2);
          rotationIndicator.updateRotation(model.scene.quaternion);
        }
      };

      __proto.deactivate = function () {
        this._active = false;

        if (this._rotationIndicator) {
          this._rotationIndicator.hide();
        }
      };

      __proto.updateAxis = function (axis) {
        this._axis.copy(axis);
      };

      __proto.setInitialPos = function (coords) {
        this._prevPos.copy(coords[0]);
      };

      __proto.process = function (_a, _b) {
        var view3d = _a.view3d,
            xrCam = _a.xrCam;
        var coords = _b.coords;
        if (!this._active || coords.length !== 1) return;
        var prevPos = this._prevPos;
        var motion = this._motion;
        var model = view3d.model;
        var coord = coords[0];
        var modelPos = model.scene.position.clone();
        var ndcModelPos = new THREE.Vector2().fromArray(modelPos.project(xrCam).toArray()); // Get the rotation angle with the model's NDC coordinates as the center.

        var rotationAngle = getRotationAngle(ndcModelPos, prevPos, coord) * this._userScale;

        var rotation = new THREE.Quaternion().setFromAxisAngle(this._axis, rotationAngle);

        var interpolated = this._getInterpolatedQuaternion();

        this._fromQuat.copy(interpolated);

        this._toQuat.premultiply(rotation);

        motion.reset(0);
        motion.setEndDelta(1);
        prevPos.copy(coord);
      };

      __proto.update = function (_a, deltaTime) {
        var model = _a.model;
        if (!this._active) return;
        var motion = this._motion;
        motion.update(deltaTime);

        var interpolated = this._getInterpolatedQuaternion();

        this.rotation.copy(interpolated);
        model.scene.quaternion.copy(interpolated);
      };

      __proto._getInterpolatedQuaternion = function () {
        var motion = this._motion;
        var toEuler = this._toQuat;
        var fromEuler = this._fromQuat;
        var progress = motion.val;
        return new THREE.Quaternion().copy(fromEuler).slerp(toEuler, progress);
      };

      return ARSwirlControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    var STATE;

    (function (STATE) {
      STATE[STATE["WAITING"] = 0] = "WAITING";
      STATE[STATE["TRANSLATING"] = 1] = "TRANSLATING";
      STATE[STATE["BOUNCING"] = 2] = "BOUNCING";
    })(STATE || (STATE = {}));
    /**
     * Model's translation(position) control for {@link ARFloorControl}
     * @category Controls-AR
     */


    var ARFloorTranslateControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of ARTranslateControl
       * @param {ARFloorTranslateControlOption} [options={}] Options
       */
      function ARFloorTranslateControl(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.hoverAmplitude,
            hoverAmplitude = _c === void 0 ? 0.01 : _c,
            _d = _b.hoverHeight,
            hoverHeight = _d === void 0 ? 0.1 : _d,
            _e = _b.hoverPeriod,
            hoverPeriod = _e === void 0 ? 1000 : _e,
            _f = _b.hoverEasing,
            hoverEasing = _f === void 0 ? SINE_WAVE : _f,
            _g = _b.bounceDuration,
            bounceDuration = _g === void 0 ? 1000 : _g,
            _h = _b.bounceEasing,
            bounceEasing = _h === void 0 ? EASE_OUT_BOUNCE : _h; // Internal states


        this._modelPosition = new THREE.Vector3();
        this._hoverPosition = new THREE.Vector3();
        this._floorPosition = new THREE.Vector3();
        this._dragPlane = new THREE.Plane();
        this._enabled = true;
        this._state = STATE.WAITING;
        this._initialPos = new THREE.Vector2();
        this._hoverAmplitude = hoverAmplitude;
        this._hoverHeight = hoverHeight;
        this._hoverMotion = new Motion({
          loop: true,
          duration: hoverPeriod,
          easing: hoverEasing
        });
        this._bounceMotion = new Motion({
          duration: bounceDuration,
          easing: bounceEasing,
          range: INFINITE_RANGE
        });
      }

      var __proto = ARFloorTranslateControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "modelPosition", {
        /**
         * Position including hover/bounce animation offset from the floor.
         * @readonly
         */
        get: function () {
          return this._modelPosition.clone();
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "floorPosition", {
        /**
         * Last detected floor position
         * @readonly
         */
        get: function () {
          return this._floorPosition.clone();
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "hoverAmplitude", {
        /**
         * How much model will hover up and down, in meter.
         */
        get: function () {
          return this._hoverAmplitude;
        },
        set: function (val) {
          this._hoverAmplitude = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "hoverHeight", {
        /**
         * How much model will float from the floor, in meter.
         */
        get: function () {
          return this._hoverHeight;
        },
        set: function (val) {
          this._hoverHeight = val;
        },
        enumerable: false,
        configurable: true
      });

      __proto.initFloorPosition = function (position) {
        this._modelPosition.copy(position);

        this._floorPosition.copy(position);

        this._hoverPosition.copy(position);

        this._hoverPosition.setY(position.y + this._hoverHeight);
      }; // tslint:disable-next-line no-empty


      __proto.init = function (ctx) {}; // tslint:disable-next-line no-empty


      __proto.destroy = function (ctx) {};
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._enabled = true;
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._enabled = false;
        this.deactivate();
      };

      __proto.activate = function (_a, gesture) {
        var model = _a.model;
        if (!this._enabled) return;
        var modelBbox = model.bbox;
        var modelBboxYOffset = modelBbox.getCenter(new THREE.Vector3()).y - modelBbox.min.y;

        this._dragPlane.set(new THREE.Vector3(0, 1, 0), -(this._floorPosition.y + this._hoverHeight + modelBboxYOffset));

        this._hoverMotion.reset(0);

        this._hoverMotion.setEndDelta(1);

        this._state = STATE.TRANSLATING;
      };

      __proto.deactivate = function () {
        if (!this._enabled || this._state === STATE.WAITING) {
          this._state = STATE.WAITING;
          return;
        }

        this._state = STATE.BOUNCING;
        var floorPosition = this._floorPosition;
        var modelPosition = this._modelPosition;
        var hoverPosition = this._hoverPosition;
        var bounceMotion = this._bounceMotion;
        var hoveringAmount = modelPosition.y - floorPosition.y;
        bounceMotion.reset(modelPosition.y);
        bounceMotion.setEndDelta(-hoveringAmount); // Restore hover pos

        hoverPosition.copy(floorPosition);
        hoverPosition.setY(floorPosition.y + this._hoverHeight);
      };

      __proto.setInitialPos = function (coords) {
        this._initialPos.copy(coords[0]);
      };

      __proto.process = function (_a, _b) {
        var view3d = _a.view3d,
            model = _a.model,
            frame = _a.frame,
            referenceSpace = _a.referenceSpace,
            xrCam = _a.xrCam;
        var hitResults = _b.hitResults;
        var state = this._state;
        var notActive = state === STATE.WAITING || state === STATE.BOUNCING;
        if (!hitResults || hitResults.length !== 1 || notActive) return;
        var hitResult = hitResults[0];

        var prevFloorPosition = this._floorPosition.clone();

        var floorPosition = this._floorPosition;
        var hoverPosition = this._hoverPosition;
        var hoverHeight = this._hoverHeight;
        var dragPlane = this._dragPlane;
        var modelBbox = model.bbox;
        var modelBboxYOffset = modelBbox.getCenter(new THREE.Vector3()).y - modelBbox.min.y;
        var hitPose = hitResult.results[0] && hitResult.results[0].getPose(referenceSpace);
        var isFloorHit = hitPose && hitPose.transform.matrix[5] >= 0.75;
        var camPos = new THREE.Vector3().setFromMatrixPosition(xrCam.matrixWorld);

        if (!hitPose || !isFloorHit) {
          // Use previous drag plane if no hit plane is found
          var targetRayPose = frame.getPose(hitResult.inputSource.targetRaySpace, view3d.renderer.threeRenderer.xr.getReferenceSpace());
          var fingerDir = new THREE.Vector3().copy(targetRayPose.transform.position).sub(camPos).normalize();
          var fingerRay = new THREE.Ray(camPos, fingerDir);
          var intersection = fingerRay.intersectPlane(dragPlane, new THREE.Vector3());

          if (intersection) {
            floorPosition.copy(intersection);
            floorPosition.setY(prevFloorPosition.y);
            hoverPosition.copy(intersection);
            hoverPosition.setY(intersection.y - modelBboxYOffset);
          }

          return;
        }

        var hitMatrix = new THREE.Matrix4().fromArray(hitPose.transform.matrix);
        var hitPosition = new THREE.Vector3().setFromMatrixPosition(hitMatrix); // Set new floor level when it's increased at least 10cm

        var currentDragPlaneHeight = -dragPlane.constant;
        var hitDragPlaneHeight = hitPosition.y + hoverHeight + modelBboxYOffset;

        if (hitDragPlaneHeight - currentDragPlaneHeight > 0.1) {
          dragPlane.constant = -hitDragPlaneHeight;
        }

        var camToHitDir = new THREE.Vector3().subVectors(hitPosition, camPos).normalize();
        var camToHitRay = new THREE.Ray(camPos, camToHitDir);
        var hitOnDragPlane = camToHitRay.intersectPlane(dragPlane, new THREE.Vector3());
        if (!hitOnDragPlane) return;
        floorPosition.copy(hitOnDragPlane);
        floorPosition.setY(hitPosition.y);
        hoverPosition.copy(hitOnDragPlane);
        hoverPosition.setY(hitOnDragPlane.y - modelBboxYOffset);
      };

      __proto.update = function (_a, delta) {
        var model = _a.model;
        var state = this._state;
        var modelPosition = this._modelPosition;
        var hoverPosition = this._hoverPosition;
        if (state === STATE.WAITING) return;

        if (state !== STATE.BOUNCING) {
          // Hover
          var hoverMotion = this._hoverMotion;
          hoverMotion.update(delta); // Change only x, y component of position

          var hoverOffset = hoverMotion.val * this._hoverAmplitude;
          modelPosition.copy(hoverPosition);
          modelPosition.setY(hoverPosition.y + hoverOffset);
        } else {
          // Bounce
          var bounceMotion = this._bounceMotion;
          bounceMotion.update(delta);
          modelPosition.setY(bounceMotion.val);

          if (bounceMotion.progress >= 1) {
            this._state = STATE.WAITING;
          }
        }

        var modelBbox = model.bbox;
        var modelYOffset = modelBbox.getCenter(new THREE.Vector3()).y - modelBbox.min.y; // modelPosition = where model.bbox.min.y should be

        model.scene.position.copy(modelPosition.clone().setY(modelPosition.y + modelYOffset));
      };

      return ARFloorTranslateControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * UI element displaying model's scale percentage info when user chaning model's scale.
     * @category Controls-AR
     */

    var ScaleUI =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of ScaleUI
       * @param {ScaleUIOption} [options={}] Options
       */
      function ScaleUI(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.width,
            width = _c === void 0 ? 0.1 : _c,
            _d = _b.padding,
            padding = _d === void 0 ? 20 : _d,
            _e = _b.offset,
            offset = _e === void 0 ? 0.05 : _e,
            _f = _b.font,
            font = _f === void 0 ? "64px sans-serif" : _f,
            _g = _b.color,
            color = _g === void 0 ? "white" : _g;

        var canvas = document.createElement("canvas");
        var ctx = canvas.getContext("2d");
        ctx.font = font; // Maximum canvas width should be equal to this

        var maxText = ctx.measureText("100%"); // Following APIs won't work on IE, but it's WebXR so I think it's okay

        var maxWidth = maxText.actualBoundingBoxLeft + maxText.actualBoundingBoxRight;
        var maxHeight = maxText.actualBoundingBoxAscent + maxText.actualBoundingBoxDescent;
        var widthPowerOfTwo = toPowerOfTwo(maxWidth);
        canvas.width = widthPowerOfTwo;
        canvas.height = widthPowerOfTwo; // This considers increased amount by making width to power of two

        var planeWidth = width * (widthPowerOfTwo / maxWidth);
        this._ctx = ctx;
        this._canvas = canvas;
        this._height = planeWidth * maxHeight / maxWidth; // Text height inside plane

        this._texture = new THREE.CanvasTexture(canvas); // Plane is square

        var uiGeometry = new THREE.PlaneGeometry(planeWidth, planeWidth);
        var mesh = new THREE.Mesh(uiGeometry, new THREE.MeshBasicMaterial({
          map: this._texture,
          transparent: true
        }));
        mesh.matrixAutoUpdate = false;
        this._mesh = mesh;
        this._font = font;
        this._color = color;
        this._padding = padding;
        this._offset = offset;
      }

      var __proto = ScaleUI.prototype;
      Object.defineProperty(__proto, "mesh", {
        /**
         * Scale UI's plane mesh
         * @readonly
         */
        get: function () {
          return this._mesh;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "height", {
        /**
         * Scale UI's height value
         * @readonly
         */
        get: function () {
          return this._height;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "visible", {
        /**
         * Whether UI is visible or not.
         * @readonly
         */
        get: function () {
          return this._mesh.visible;
        },
        enumerable: false,
        configurable: true
      });

      __proto.updatePosition = function (position, focus) {
        // Update mesh
        var mesh = this._mesh;
        mesh.lookAt(focus);
        mesh.position.copy(position);
        mesh.position.setY(position.y + this._height / 2 + this._offset);
        mesh.updateMatrix();
      };

      __proto.updateScale = function (scale) {
        var ctx = this._ctx;
        var canvas = this._canvas;
        var padding = this._padding;
        var scalePercentage = (scale * 100).toFixed(0);
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        var centerX = canvas.width / 2;
        var centerY = canvas.height / 2; // Draw round rect

        var textSize = ctx.measureText(scalePercentage + "%");
        var halfWidth = (textSize.actualBoundingBoxLeft + textSize.actualBoundingBoxRight) / 2;
        var halfHeight = (textSize.actualBoundingBoxAscent + textSize.actualBoundingBoxDescent) / 2;
        ctx.beginPath();
        ctx.moveTo(centerX - halfWidth, centerY - halfHeight - padding);
        ctx.lineTo(centerX + halfWidth, centerY - halfHeight - padding);
        ctx.quadraticCurveTo(centerX + halfWidth + padding, centerY - halfHeight - padding, centerX + halfWidth + padding, centerY - halfHeight);
        ctx.lineTo(centerX + halfWidth + padding, centerY + halfHeight);
        ctx.quadraticCurveTo(centerX + halfWidth + padding, centerY + halfHeight + padding, centerX + halfWidth, centerY + halfHeight + padding);
        ctx.lineTo(centerX - halfWidth, centerY + halfHeight + padding);
        ctx.quadraticCurveTo(centerX - halfWidth - padding, centerY + halfHeight + padding, centerX - halfWidth - padding, centerY + halfHeight);
        ctx.lineTo(centerX - halfWidth - padding, centerY - halfHeight);
        ctx.quadraticCurveTo(centerX - halfWidth - padding, centerY - halfHeight - padding, centerX - halfWidth, centerY - halfHeight - padding);
        ctx.closePath();
        ctx.lineWidth = 5;
        ctx.fillStyle = "rgba(0, 0, 0, 0.3)";
        ctx.fill();
        ctx.stroke(); // Draw text

        ctx.font = this._font;
        ctx.textAlign = "center";
        ctx.textBaseline = "middle";
        ctx.strokeStyle = this._color;
        ctx.fillStyle = this._color;
        ctx.fillText(scalePercentage + "%", centerX, centerY);
        this._texture.needsUpdate = true;
      };
      /**
       * Show UI
       */


      __proto.show = function () {
        this._mesh.visible = true;
      };
      /**
       * Hide UI
       */


      __proto.hide = function () {
        this._mesh.visible = false;
      };

      return ScaleUI;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Model's scale controller which works on AR(WebXR) mode.
     * @category Controls-AR
     */

    var ARScaleControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of ARScaleControl
       * @param {ARScaleControlOption} [options={}] Options
       */
      function ARScaleControl(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.min,
            min = _c === void 0 ? 0.05 : _c,
            _d = _b.max,
            max = _d === void 0 ? 2 : _d;

        this._enabled = true;
        this._active = false;
        this._prevCoordDistance = -1;
        this._scaleMultiplier = 1;
        this._initialScale = new THREE.Vector3();
        this._ui = new ScaleUI();
        this._motion = new Motion({
          duration: 0,
          range: {
            min: min,
            max: max
          }
        });

        this._motion.reset(1); // default scale is 1(100%)


        this._ui = new ScaleUI();
      }

      var __proto = ARScaleControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scale", {
        get: function () {
          return this._initialScale.clone().multiplyScalar(this._scaleMultiplier);
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scaleMultiplier", {
        get: function () {
          return this._scaleMultiplier;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "range", {
        /**
         * Range of the scale
         * @readonly
         */
        get: function () {
          return this._motion.range;
        },
        enumerable: false,
        configurable: true
      });

      __proto.init = function (_a) {
        var view3d = _a.view3d;

        this._initialScale.copy(view3d.model.scene.scale);

        view3d.scene.add(this._ui.mesh);
      };

      __proto.destroy = function (_a) {
        var view3d = _a.view3d;
        view3d.scene.remove(this._ui.mesh);
      };

      __proto.setInitialPos = function (coords) {
        this._prevCoordDistance = new THREE.Vector2().subVectors(coords[0], coords[1]).length();
      };
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._enabled = true;
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._enabled = false;
        this.deactivate();
      };

      __proto.activate = function (ctx, gesture) {
        this._active = true;

        this._ui.show();

        this._updateUIPosition(ctx);
      };

      __proto.deactivate = function () {
        this._active = false;

        this._ui.hide();

        this._prevCoordDistance = -1;
      };
      /**
       * Update scale range
       * @param min Minimum scale
       * @param max Maximum scale
       */


      __proto.setRange = function (min, max) {
        this._motion.range = {
          min: min,
          max: max
        };
      };

      __proto.process = function (ctx, _a) {
        var coords = _a.coords;
        if (coords.length !== 2 || !this._enabled || !this._active) return;
        var motion = this._motion;
        var distance = new THREE.Vector2().subVectors(coords[0], coords[1]).length();
        var delta = distance - this._prevCoordDistance;
        motion.setEndDelta(delta);
        this._prevCoordDistance = distance;

        this._updateUIPosition(ctx);
      };

      __proto.update = function (_a, deltaTime) {
        var model = _a.model;
        if (!this._enabled || !this._active) return;
        var motion = this._motion;
        motion.update(deltaTime);
        this._scaleMultiplier = motion.val;

        this._ui.updateScale(this._scaleMultiplier);

        model.scene.scale.copy(this.scale);
      };

      __proto._updateUIPosition = function (_a) {
        var view3d = _a.view3d,
            xrCam = _a.xrCam; // Update UI

        var model = view3d.model;
        var camPos = new THREE.Vector3().setFromMatrixPosition(xrCam.matrixWorld);
        var uiPos = model.scene.position.clone().setY(model.bbox.max.y);

        this._ui.updatePosition(uiPos, camPos);
      };

      return ARScaleControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Ring type indicator for showing where the model's at.
     * @category Controls-AR
     */

    var FloorIndicator =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of FloorIndicator
       * @param {FloorIndicatorOption} [options={}] Options
       */
      function FloorIndicator(_a) {
        var _b = _a === void 0 ? {} : _a,
            _c = _b.ringOpacity,
            ringOpacity = _c === void 0 ? 0.3 : _c,
            _d = _b.dirIndicatorOpacity,
            dirIndicatorOpacity = _d === void 0 ? 1 : _d,
            _e = _b.fadeoutDuration,
            fadeoutDuration = _e === void 0 ? 1000 : _e;

        var deg10 = Math.PI / 18;
        var dimmedRingGeomtry = new THREE.RingGeometry(0.975, 1, 150, 1, -6 * deg10, 30 * deg10);
        var reticle = new THREE.CircleGeometry(0.1, 30, 0, Math.PI * 2);
        dimmedRingGeomtry.merge(reticle);
        var highlightedRingGeometry = new THREE.RingGeometry(0.96, 1.015, 30, 1, 25 * deg10, 4 * deg10); // Create little triangle in ring

        var ringVertices = highlightedRingGeometry.vertices;
        var trianglePart = ringVertices.slice(Math.floor(11 * ringVertices.length / 16), Math.floor(13 * ringVertices.length / 16));
        var firstY = trianglePart[0].y;
        var midIndex = Math.floor(trianglePart.length / 2);
        trianglePart.forEach(function (vec, vecIdx) {
          var offsetAmount = 0.025 * (midIndex - Math.abs(vecIdx - midIndex));
          vec.setY(firstY - offsetAmount);
        });
        var indicatorMat = new THREE.Matrix4().makeRotationX(-Math.PI / 2);
        var mergedGeometry = new THREE.Geometry();
        mergedGeometry.merge(dimmedRingGeomtry, indicatorMat, 0);
        mergedGeometry.merge(highlightedRingGeometry, indicatorMat, 1);
        var dimmedMaterial = new THREE.MeshBasicMaterial({
          transparent: true,
          opacity: ringOpacity,
          color: 0xffffff
        });
        var highlightMaterial = new THREE.MeshBasicMaterial({
          transparent: true,
          opacity: dirIndicatorOpacity,
          color: 0xffffff
        });
        var materials = [dimmedMaterial, highlightMaterial];
        this._mesh = new THREE.Mesh(mergedGeometry, materials);
        this._mesh.matrixAutoUpdate = false;
        this._animator = new Motion({
          duration: fadeoutDuration
        });
        this._opacityRange = {
          min: ringOpacity,
          max: dirIndicatorOpacity
        };
      }

      var __proto = FloorIndicator.prototype;
      Object.defineProperty(__proto, "mesh", {
        /**
         * Ring mesh
         */
        get: function () {
          return this._mesh;
        },
        enumerable: false,
        configurable: true
      });

      __proto.update = function (_a) {
        var delta = _a.delta,
            scale = _a.scale,
            position = _a.position,
            rotation = _a.rotation;
        var mesh = this._mesh;
        var animator = this._animator;
        if (!this._mesh.visible) return;
        animator.update(delta);
        var materials = this._mesh.material;
        var minOpacityMat = materials[0];
        var maxOpacityMat = materials[1];
        var opacityRange = this._opacityRange;
        minOpacityMat.opacity = animator.val * opacityRange.min;
        maxOpacityMat.opacity = animator.val * opacityRange.max;

        if (animator.val <= 0) {
          mesh.visible = false;
        } // Update mesh


        mesh.scale.setScalar(scale);
        mesh.position.copy(position);
        mesh.quaternion.copy(rotation);
        mesh.updateMatrix();
      };

      __proto.show = function () {
        this._mesh.visible = true;

        this._animator.reset(1);
      };

      __proto.fadeout = function () {
        this._animator.setEndDelta(-1);
      };

      return FloorIndicator;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    var GESTURE;

    (function (GESTURE) {
      GESTURE[GESTURE["NONE"] = 0] = "NONE";
      GESTURE[GESTURE["ONE_FINGER_HORIZONTAL"] = 1] = "ONE_FINGER_HORIZONTAL";
      GESTURE[GESTURE["ONE_FINGER_VERTICAL"] = 2] = "ONE_FINGER_VERTICAL";
      GESTURE[GESTURE["ONE_FINGER"] = 3] = "ONE_FINGER";
      GESTURE[GESTURE["TWO_FINGER_HORIZONTAL"] = 4] = "TWO_FINGER_HORIZONTAL";
      GESTURE[GESTURE["TWO_FINGER_VERTICAL"] = 8] = "TWO_FINGER_VERTICAL";
      GESTURE[GESTURE["TWO_FINGER"] = 12] = "TWO_FINGER";
      GESTURE[GESTURE["PINCH"] = 16] = "PINCH";
    })(GESTURE || (GESTURE = {}));

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    var STATE$1;

    (function (STATE) {
      STATE[STATE["WAITING"] = 0] = "WAITING";
      STATE[STATE["IN_DEADZONE"] = 1] = "IN_DEADZONE";
      STATE[STATE["OUT_OF_DEADZONE"] = 2] = "OUT_OF_DEADZONE";
    })(STATE$1 || (STATE$1 = {}));
    /**
     * Deadzone checker for deadzone-based controls
     * @category Controls-AR
     */


    var DeadzoneChecker =
    /*#__PURE__*/
    function () {
      /**
       * Create new DeadzoneChecker
       * @param {DeadzoneCheckerOption} [options={}] Options
       */
      function DeadzoneChecker(_a) {
        var _b = (_a === void 0 ? {} : _a).size,
            size = _b === void 0 ? 0.1 : _b; // Internal States

        this._state = STATE$1.WAITING;
        this._detectedGesture = GESTURE.NONE;
        this._testingGestures = GESTURE.NONE;
        this._lastFingerCount = 0;
        this._aspect = 1; // Store two prev positions, as it should be maintained separately

        this._prevOneFingerPos = new THREE.Vector2();
        this._prevTwoFingerPos = new THREE.Vector2();
        this._initialTwoFingerDistance = 0;
        this._prevOneFingerPosInitialized = false;
        this._prevTwoFingerPosInitialized = false;
        this._size = size;
      }

      var __proto = DeadzoneChecker.prototype;
      Object.defineProperty(__proto, "size", {
        /**
         * Size of the deadzone.
         * @type number
         */
        get: function () {
          return this._size;
        },
        set: function (val) {
          this._size = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "inDeadzone", {
        get: function () {
          return this._state === STATE$1.IN_DEADZONE;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Set screen aspect(height / width)
       * @param aspect Screen aspect value
       */

      __proto.setAspect = function (aspect) {
        this._aspect = aspect;
      };

      __proto.setFirstInput = function (inputs) {
        var fingerCount = inputs.length;

        if (fingerCount === 1 && !this._prevOneFingerPosInitialized) {
          this._prevOneFingerPos.copy(inputs[0]);

          this._prevOneFingerPosInitialized = true;
        } else if (fingerCount === 2 && !this._prevTwoFingerPosInitialized) {
          this._prevTwoFingerPos.copy(new THREE.Vector2().addVectors(inputs[0], inputs[1]).multiplyScalar(0.5));

          this._initialTwoFingerDistance = new THREE.Vector2().subVectors(inputs[0], inputs[1]).length();
          this._prevTwoFingerPosInitialized = true;
        }

        this._lastFingerCount = fingerCount;
        this._state = STATE$1.IN_DEADZONE;
      };

      __proto.addTestingGestures = function () {
        var gestures = [];

        for (var _i = 0; _i < arguments.length; _i++) {
          gestures[_i] = arguments[_i];
        }

        this._testingGestures = this._testingGestures | gestures.reduce(function (gesture, accumulated) {
          return gesture | accumulated;
        }, GESTURE.NONE);
      };

      __proto.cleanup = function () {
        this._testingGestures = GESTURE.NONE;
        this._lastFingerCount = 0;
        this._prevOneFingerPosInitialized = false;
        this._prevTwoFingerPosInitialized = false;
        this._initialTwoFingerDistance = 0;
        this._detectedGesture = GESTURE.NONE;
        this._state = STATE$1.WAITING;
      };

      __proto.applyScreenAspect = function (inputs) {
        var aspect = this._aspect;
        inputs.forEach(function (input) {
          if (aspect > 1) {
            input.setY(input.y * aspect);
          } else {
            input.setX(input.x / aspect);
          }
        });
      };

      __proto.check = function (inputs) {
        var state = this._state;
        var deadzone = this._size;
        var testingGestures = this._testingGestures;
        var lastFingerCount = this._lastFingerCount;
        var fingerCount = inputs.length;

        if (state === STATE$1.OUT_OF_DEADZONE) {
          return this._detectedGesture;
        }

        this._lastFingerCount = fingerCount;
        this.applyScreenAspect(inputs);

        if (fingerCount !== lastFingerCount) {
          this.setFirstInput(inputs);
          return GESTURE.NONE;
        }

        if (fingerCount === 1) {
          var input = inputs[0];

          var prevPos = this._prevOneFingerPos.clone();

          var diff = new THREE.Vector2().subVectors(input, prevPos);

          if (diff.length() > deadzone) {
            if (Math.abs(diff.x) > Math.abs(diff.y)) {
              if (GESTURE.ONE_FINGER_HORIZONTAL & testingGestures) {
                this._detectedGesture = GESTURE.ONE_FINGER_HORIZONTAL;
              }
            } else {
              if (GESTURE.ONE_FINGER_VERTICAL & testingGestures) {
                this._detectedGesture = GESTURE.ONE_FINGER_VERTICAL;
              }
            }
          }
        } else if (fingerCount === 2) {
          var middle = new THREE.Vector2().addVectors(inputs[1], inputs[0]).multiplyScalar(0.5);

          var prevPos = this._prevTwoFingerPos.clone();

          var diff = new THREE.Vector2().subVectors(middle, prevPos);

          if (diff.length() > deadzone) {
            if (Math.abs(diff.x) > Math.abs(diff.y)) {
              if (GESTURE.TWO_FINGER_HORIZONTAL & testingGestures) {
                this._detectedGesture = GESTURE.TWO_FINGER_HORIZONTAL;
              }
            } else {
              if (GESTURE.TWO_FINGER_VERTICAL & testingGestures) {
                this._detectedGesture = GESTURE.TWO_FINGER_VERTICAL;
              }
            }
          }

          var distance = new THREE.Vector2().subVectors(inputs[1], inputs[0]).length();

          if (Math.abs(distance - this._initialTwoFingerDistance) > deadzone) {
            if (GESTURE.PINCH & testingGestures) {
              this._detectedGesture = GESTURE.PINCH;
            }
          }
        }

        if (this._detectedGesture !== GESTURE.NONE) {
          this._state = STATE$1.OUT_OF_DEADZONE;
        }

        return this._detectedGesture;
      };

      return DeadzoneChecker;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * AR control for {@link FloorARSession}
     * @category Controls-AR
     */

    var ARFloorControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of ARFloorControl
       * @param {ARFloorControlOption} options Options
       */
      function ARFloorControl(options) {
        var _this = this;

        if (options === void 0) {
          options = {};
        }

        this._enabled = true;
        this._initialized = false;
        this._modelHit = false;
        this._hitTestSource = null;

        this.onSelectStart = function (ctx) {
          var view3d = ctx.view3d,
              frame = ctx.frame,
              xrCam = ctx.xrCam,
              referenceSpace = ctx.referenceSpace;
          var hitTestSource = _this._hitTestSource;
          if (!hitTestSource || !_this._enabled) return;
          var deadzoneChecker = _this._deadzoneChecker;
          var rotateControl = _this._rotateControl;
          var translateControl = _this._translateControl;
          var scaleControl = _this._scaleControl; // Update deadzone testing gestures

          if (rotateControl.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.ONE_FINGER);
          }

          if (translateControl.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.ONE_FINGER);
          }

          if (scaleControl.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.PINCH);
          }

          var hitResults = frame.getHitTestResultsForTransientInput(hitTestSource);

          var coords = _this._hitResultToVector(hitResults);

          deadzoneChecker.applyScreenAspect(coords);
          deadzoneChecker.setFirstInput(coords);

          if (coords.length === 1) {
            // Check finger is on the model
            var modelBbox = view3d.model.bbox;
            var targetRayPose = frame.getPose(hitResults[0].inputSource.targetRaySpace, referenceSpace);
            var camPos = new THREE.Vector3().setFromMatrixPosition(xrCam.matrixWorld);
            var fingerDir = new THREE.Vector3().copy(targetRayPose.transform.position).sub(camPos).normalize();
            var fingerRay = new THREE.Ray(camPos, fingerDir);
            var intersection = fingerRay.intersectBox(modelBbox, new THREE.Vector3());

            if (intersection) {
              // Touch point intersected with model
              _this._modelHit = true;
            }
          }

          _this._floorIndicator.show();
        };

        this.onSelectEnd = function () {
          _this.deactivate();

          _this._floorIndicator.fadeout();
        };

        this._rotateControl = new ARSwirlControl(__assign({
          showIndicator: false
        }, options.rotate));
        this._translateControl = new ARFloorTranslateControl(options.translate);
        this._scaleControl = new ARScaleControl(options.scale);
        this._floorIndicator = new FloorIndicator(options.floorIndicator);
        this._deadzoneChecker = new DeadzoneChecker(options.deadzone);
      }

      var __proto = ARFloorControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        /**
         * Return whether this control is enabled or not
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "rotate", {
        /**
         * {@link ARSwirlControl} in this control
         */
        get: function () {
          return this._rotateControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "translate", {
        /**
         * {@link ARFloorTranslateControl} in this control
         */
        get: function () {
          return this._translateControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scale", {
        /**
         * {@link ARScaleControl} in this control
         */
        get: function () {
          return this._scaleControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "controls", {
        get: function () {
          return [this._rotateControl, this._translateControl, this._scaleControl];
        },
        enumerable: false,
        configurable: true
      });

      __proto.init = function (ctx, initialFloorPos) {
        var _this = this;

        var session = ctx.session,
            view3d = ctx.view3d,
            size = ctx.size;
        this.controls.forEach(function (control) {
          return control.init(ctx);
        });

        this._translateControl.initFloorPosition(initialFloorPos);

        this._deadzoneChecker.setAspect(size.height / size.width);

        view3d.scene.add(this._floorIndicator.mesh);
        this._initialized = true;
        session.requestHitTestSourceForTransientInput({
          profile: INPUT_PROFILE.TOUCH
        }).then(function (transientHitTestSource) {
          _this._hitTestSource = transientHitTestSource;
        });
      };
      /**
       * Destroy this control and deactivate it
       * @param view3d Instance of the {@link View3D}
       */


      __proto.destroy = function (ctx) {
        if (!this._initialized) return;

        if (this._hitTestSource) {
          this._hitTestSource.cancel();

          this._hitTestSource = null;
        }

        ctx.view3d.scene.remove(this._floorIndicator.mesh);
        this.deactivate();
        this.controls.forEach(function (control) {
          return control.destroy(ctx);
        });
        this._initialized = false;
      };

      __proto.deactivate = function () {
        this._modelHit = false;

        this._deadzoneChecker.cleanup();

        this.controls.forEach(function (control) {
          return control.deactivate();
        });
      };
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._enabled = true;
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._enabled = false;
        this.deactivate();
      };

      __proto.update = function (ctx) {
        var view3d = ctx.view3d,
            session = ctx.session,
            frame = ctx.frame;
        var hitTestSource = this._hitTestSource;
        if (!hitTestSource || !view3d.model) return;
        var deadzoneChecker = this._deadzoneChecker;
        var inputSources = session.inputSources;
        var hitResults = frame.getHitTestResultsForTransientInput(hitTestSource);

        var coords = this._hitResultToVector(hitResults);

        var xrInputs = {
          coords: coords,
          inputSources: inputSources,
          hitResults: hitResults
        };

        if (deadzoneChecker.inDeadzone) {
          this._checkDeadzone(ctx, xrInputs);
        } else {
          this._processInput(ctx, xrInputs);
        }

        this._updateControls(ctx);
      };

      __proto._checkDeadzone = function (ctx, _a) {
        var coords = _a.coords;

        var gesture = this._deadzoneChecker.check(coords.map(function (coord) {
          return coord.clone();
        }));

        var rotateControl = this._rotateControl;
        var translateControl = this._translateControl;
        var scaleControl = this._scaleControl;
        if (gesture === GESTURE.NONE) return;

        switch (gesture) {
          case GESTURE.ONE_FINGER_HORIZONTAL:
          case GESTURE.ONE_FINGER_VERTICAL:
            if (this._modelHit) {
              translateControl.activate(ctx, gesture);
              translateControl.setInitialPos(coords);
            } else {
              rotateControl.activate(ctx, gesture);
              rotateControl.setInitialPos(coords);
            }

            break;

          case GESTURE.PINCH:
            scaleControl.activate(ctx, gesture);
            scaleControl.setInitialPos(coords);
            break;
        }
      };

      __proto._processInput = function (ctx, inputs) {
        this.controls.forEach(function (control) {
          return control.process(ctx, inputs);
        });
      };

      __proto._updateControls = function (ctx) {
        var view3d = ctx.view3d,
            model = ctx.model,
            delta = ctx.delta;
        var deltaMilisec = delta * 1000;
        this.controls.forEach(function (control) {
          return control.update(ctx, deltaMilisec);
        });
        model.scene.updateMatrix();
        var modelRotation = this._rotateControl.rotation;
        var floorPosition = this._translateControl.floorPosition;
        view3d.scene.update(model, {
          floorPosition: floorPosition
        }); // Get a scaled bbox, which only has scale applied on it.

        var scaleControl = this._scaleControl;
        var scaledBbox = model.initialBbox;
        scaledBbox.min.multiply(scaleControl.scale);
        scaledBbox.max.multiply(scaleControl.scale);
        var floorIndicator = this._floorIndicator;
        var boundingSphere = scaledBbox.getBoundingSphere(new THREE.Sphere());
        floorIndicator.update({
          delta: deltaMilisec,
          scale: boundingSphere.radius,
          position: floorPosition,
          rotation: modelRotation
        });
      };

      __proto._hitResultToVector = function (hitResults) {
        return hitResults.map(function (input) {
          return new THREE.Vector2().set(input.inputSource.gamepad.axes[0], -input.inputSource.gamepad.axes[1]);
        });
      };

      return ARFloorControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * WebXR based AR session which puts model on the detected floor.
     * @category XR
     * @fires WebARSession#start
     * @fires WebARSession#end
     * @fires WebARSession#canPlace
     * @fires WebARSession#modelPlaced
     */

    var FloorARSession =
    /*#__PURE__*/
    function (_super) {
      __extends(FloorARSession, _super);
      /**
       * Create new instance of FloorARSession
       * @param {FloorARSessionOption} options Options
       */


      function FloorARSession(options) {
        if (options === void 0) {
          options = {};
        }

        var _this = _super.call(this, options) || this;

        _this.onStart = function (ctx) {
          var view3d = ctx.view3d,
              session = ctx.session;

          _super.prototype.onStart.call(_this, ctx);

          _this._control = new ARFloorControl(_this._options);
          view3d.scene.hide();

          _this._hitTest.init(session);
        };

        _this.onEnd = function (ctx) {
          var view3d = ctx.view3d,
              session = ctx.session;

          _super.prototype.onEnd.call(_this, ctx);

          _this._renderContext = null;
          _this._modelPlaced = false;
          session.removeEventListener(EVENTS$1.SELECT_START, _this._onSelectStart);
          session.removeEventListener(EVENTS$1.SELECT_END, _this._onSelectEnd);

          _this._hitTest.destroy();

          _this._control.destroy(ctx);

          _this._control = null;
          view3d.scene.show();
        };

        _this._beforeRender = function (ctx) {
          _this._renderContext = ctx;

          if (!_this._modelPlaced) {
            _this._initModelPosition(ctx);
          } else {
            _this._control.update(ctx);
          }
        };

        _this._onSelectStart = function (e) {
          _this._control.onSelectStart(__assign(__assign({}, _this._renderContext), {
            frame: e.frame
          }));
        };

        _this._onSelectEnd = function () {
          _this._control.onSelectEnd();
        };

        _this._control = null;
        _this._renderContext = null;
        _this._modelPlaced = false;
        _this._hitTest = new HitTest();
        _this._features = merge(_this._features, _this._hitTest.features);
        _this._options = options;
        return _this;
      }

      var __proto = FloorARSession.prototype;
      Object.defineProperty(__proto, "control", {
        /**
         * {@link ARControl} instance of this session
         * @type ARFloorControl | null
         */
        get: function () {
          return this._control;
        },
        enumerable: false,
        configurable: true
      });

      __proto._initModelPosition = function (ctx) {
        var _a;

        var view3d = ctx.view3d,
            frame = ctx.frame,
            session = ctx.session;
        var model = view3d.model;
        var hitTest = this._hitTest; // Make sure the model is loaded

        if (!hitTest.ready || !model) return;
        var control = this._control;
        var referenceSpace = view3d.renderer.threeRenderer.xr.getReferenceSpace();
        var hitTestResults = hitTest.getResults(frame);
        if (hitTestResults.length <= 0) return;
        var hit = hitTestResults[0];
        var hitMatrix = new THREE.Matrix4().fromArray(hit.getPose(referenceSpace).transform.matrix); // If transformed coords space's y axis is not facing up, don't use it.

        if (hitMatrix.elements[5] < 0.75) return;
        var modelRoot = model.scene;
        var hitPosition = new THREE.Vector3().setFromMatrixPosition(hitMatrix); // Reset rotation & update position

        modelRoot.quaternion.set(0, 0, 0, 1);
        modelRoot.position.copy(hitPosition);
        modelRoot.position.setY(modelRoot.position.y - model.bbox.min.y);
        modelRoot.updateMatrix();
        view3d.scene.update(model);
        view3d.scene.show();
        this.emit("canPlace"); // Don't need it

        hitTest.destroy();
        session.addEventListener(EVENTS$1.SELECT_START, this._onSelectStart);
        session.addEventListener(EVENTS$1.SELECT_END, this._onSelectEnd);
        (_a = this._domOverlay) === null || _a === void 0 ? void 0 : _a.hideLoading();
        this._modelPlaced = true;
        this.emit("modelPlaced"); // Show scale up animation

        var originalModelScale = modelRoot.scale.clone();
        var scaleUpAnimation = new Animation({
          context: session
        });
        scaleUpAnimation.on("progress", function (evt) {
          var newScale = originalModelScale.clone().multiplyScalar(evt.easedProgress);
          modelRoot.scale.copy(newScale);
        });
        scaleUpAnimation.on("finish", function () {
          modelRoot.scale.copy(originalModelScale);
          control.init(ctx, hitPosition);
        });
        scaleUpAnimation.start();
      };

      return FloorARSession;
    }(WebARSession);

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Arrow indicator for AR model translatioon.
     * @category Controls-AR
     */

    var ArrowIndicator =
    /*#__PURE__*/
    function () {
      /**
       * Create new ArrowIndicator
       * @param {ArrowIndicatorOption} [options={}] Options
       */
      function ArrowIndicator(_a) {
        var _this = this;

        var _b = (_a === void 0 ? {} : _a).color,
            color = _b === void 0 ? 0xffffff : _b;
        var bodyGeometry = new THREE.CylinderBufferGeometry(0.1, 0.1, 1);
        var coneGeometry = new THREE.CylinderBufferGeometry(0, 0.5, 1, 30, 1);
        bodyGeometry.translate(0, 0.5, 0);
        coneGeometry.translate(0, 1.5, 0);
        var body = new THREE.Mesh(bodyGeometry, new THREE.MeshBasicMaterial({
          color: color
        }));
        var cone = new THREE.Mesh(coneGeometry, new THREE.MeshBasicMaterial({
          color: color
        }));
        var arrow = new THREE.Group();
        arrow.add(body);
        arrow.add(cone);
        this._arrows = [arrow];
        this._obj = new THREE.Group();

        this._obj.add(arrow);

        range(3).forEach(function (idx) {
          var copied = arrow.clone(true);
          copied.rotateZ(Math.PI / 2 * (idx + 1));

          _this._obj.add(copied);

          _this._arrows.push(copied);
        });
        this.hide();
      }

      var __proto = ArrowIndicator.prototype;
      Object.defineProperty(__proto, "object", {
        /**
         * {@link https://threejs.org/docs/index.html#api/en/objects/Group THREE.Group} object that contains arrows.
         */
        get: function () {
          return this._obj;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Show indicator
       */

      __proto.show = function () {
        this._obj.visible = true;
      };
      /**
       * Hide indicator
       */


      __proto.hide = function () {
        this._obj.visible = false;
      };
      /**
       * Change the center of the arrows to a given position
       * @param position Position to set as center of the arrows
       */


      __proto.updatePosition = function (position) {
        this._obj.position.copy(position);
      };
      /**
       * Update the arrow's offset from the center
       * @param offset Offset vector.
       */


      __proto.updateOffset = function (offset) {
        this._arrows.forEach(function (arrow, idx) {
          var facingDirection = new THREE.Vector3(0, 1, 0).applyQuaternion(arrow.quaternion);
          var facingOffset = facingDirection.multiply(offset);
          arrow.position.copy(facingOffset);
        });
      };
      /**
       * Update arrow's scale
       * @param scale Scale vector
       */


      __proto.updateScale = function (scale) {
        this._arrows.forEach(function (arrow) {
          return arrow.scale.setScalar(scale);
        });
      };
      /**
       * Update arrow's rotation.
       * @param rotation Quaternion value to rotate arrows.
       */


      __proto.updateRotation = function (rotation) {
        this._obj.quaternion.copy(rotation);
      };

      return ArrowIndicator;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Model's translation(position) control for {@link ARWallControl}
     * @category Controls-AR
     */

    var ARWallTranslateControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of ARTranslateControl
       * @param {ARWallTranslateControlOption} [options={}] Options
       */
      function ARWallTranslateControl(options) {
        if (options === void 0) {
          options = {};
        }

        this.position = new THREE.Vector3();
        this.wallPosition = new THREE.Vector3();
        this.hitRotation = new THREE.Quaternion(); // Global Y guaranteed rotation matrix

        this.wallRotation = new THREE.Quaternion(); // Options
        // Internal states

        this._dragPlane = new THREE.Plane();
        this._enabled = true;
        this._active = false;
        this._initialPos = new THREE.Vector2();
        this._arrowIndicator = new ArrowIndicator(options.arrow);
      }

      var __proto = ARWallTranslateControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });

      __proto.initWallTransform = function (_a) {
        var hitPosition = _a.hitPosition,
            hitRotation = _a.hitRotation,
            modelPosition = _a.modelPosition,
            wallRotation = _a.wallRotation;
        this.position.copy(modelPosition);
        this.hitRotation.copy(hitRotation);
        this.wallPosition.copy(hitPosition);
        this.wallRotation.copy(wallRotation);
        var wallNormal = new THREE.Vector3(0, 1, 0).applyQuaternion(wallRotation);

        this._dragPlane.set(wallNormal, -wallNormal.dot(modelPosition));
      };

      __proto.init = function (_a) {
        var view3d = _a.view3d;
        view3d.scene.add(this._arrowIndicator.object);
      };

      __proto.destroy = function (_a) {
        var view3d = _a.view3d;
        view3d.scene.remove(this._arrowIndicator.object);
      };
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._enabled = true;
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._enabled = false;
        this.deactivate();
      };

      __proto.activate = function (_a, gesture) {
        var model = _a.model;
        if (!this._enabled) return;
        this._active = true; // Update arrows

        var arrowIndicator = this._arrowIndicator;
        var modelBbox = model.initialBbox;
        modelBbox.min.multiply(model.scene.scale);
        modelBbox.max.multiply(model.scene.scale);
        modelBbox.translate(model.scene.position);
        arrowIndicator.show();
        arrowIndicator.updatePosition(modelBbox.getCenter(new THREE.Vector3()));
        arrowIndicator.updateScale(model.size / 16);
        var arrowPlaneRotation = model.scene.quaternion.clone();
        arrowIndicator.updateRotation(arrowPlaneRotation);
        arrowIndicator.updateOffset(new THREE.Vector3().subVectors(modelBbox.max, modelBbox.min).multiplyScalar(0.5));
      };

      __proto.deactivate = function () {
        this._active = false;

        this._arrowIndicator.hide();
      };

      __proto.setInitialPos = function (coords) {
        this._initialPos.copy(coords[0]);
      };

      __proto.process = function (_a, _b) {
        var view3d = _a.view3d,
            model = _a.model,
            frame = _a.frame,
            referenceSpace = _a.referenceSpace,
            xrCam = _a.xrCam;
        var hitResults = _b.hitResults;
        if (!hitResults || hitResults.length !== 1 || !this._active) return;
        var dragPlane = this._dragPlane;
        var modelRoot = model.scene;
        var modelZOffset = -model.initialBbox.min.z * modelRoot.scale.z;
        var camPos = new THREE.Vector3().setFromMatrixPosition(xrCam.matrixWorld);
        var hitResult = hitResults[0];
        var hitPose = hitResult.results[0] && hitResult.results[0].getPose(referenceSpace);
        var isWallHit = hitPose && hitPose.transform.matrix[5] < 0.25;

        if (!hitPose || !isWallHit) {
          // Use previous drag plane if no hit plane is found
          var targetRayPose = frame.getPose(hitResult.inputSource.targetRaySpace, view3d.renderer.threeRenderer.xr.getReferenceSpace());
          var fingerDir = new THREE.Vector3().copy(targetRayPose.transform.position).sub(camPos).normalize();
          var fingerRay = new THREE.Ray(camPos, fingerDir);
          var intersection = fingerRay.intersectPlane(dragPlane, new THREE.Vector3());

          if (intersection) {
            this.wallPosition.copy(intersection.clone().sub(dragPlane.normal.clone().multiplyScalar(modelZOffset)));
            this.position.copy(intersection);
          }

          return;
        }

        var hitMatrix = new THREE.Matrix4().fromArray(hitPose.transform.matrix);
        var hitOrientation = new THREE.Quaternion().copy(hitPose.transform.orientation);
        var hitPosition = new THREE.Vector3().setFromMatrixPosition(hitMatrix);
        var worldYAxis = new THREE.Vector3(0, 1, 0);
        /*
         * ^ wallU
         * |
         * ⨀---> wallV
         * wallNormal
         */

        var wallNormal = new THREE.Vector3(0, 1, 0).applyQuaternion(hitOrientation).normalize();
        var wallU = new THREE.Vector3().crossVectors(worldYAxis, wallNormal);
        var wallV = wallNormal.clone().applyAxisAngle(wallU, -Math.PI / 2); // Reconstruct wall matrix with prev Y(normal) direction as Z axis

        var wallMatrix = new THREE.Matrix4().makeBasis(wallU, wallV, wallNormal);
        var modelPosition = hitPosition.clone().add(wallNormal.clone().multiplyScalar(modelZOffset)); // Update position

        this.position.copy(modelPosition);
        this.wallPosition.copy(hitPosition); // Update rotation if it differs more than 10deg

        var prevWallNormal = new THREE.Vector3(0, 1, 0).applyQuaternion(this.hitRotation).normalize();

        if (Math.acos(Math.abs(prevWallNormal.dot(wallNormal))) >= Math.PI / 18) {
          var prevWallRotation = this.wallRotation.clone();
          var wallRotation = new THREE.Quaternion().setFromRotationMatrix(wallMatrix);
          var rotationDiff = prevWallRotation.inverse().premultiply(wallRotation);
          modelRoot.quaternion.premultiply(rotationDiff);
          this.wallRotation.copy(wallRotation);
          this.hitRotation.copy(hitOrientation);

          this._arrowIndicator.updateRotation(modelRoot.quaternion); // Update drag plane


          dragPlane.set(wallNormal, -modelPosition.dot(wallNormal));
        }
      };

      __proto.update = function (_a, delta) {
        var model = _a.model;
        model.scene.position.copy(this.position);

        this._arrowIndicator.updatePosition(this.position);

        model.scene.updateMatrix();
      };

      return ARWallTranslateControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * AR control for {@link WallARSession}.
     * @category Controls-AR
     */

    var ARWallControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of ARControl
       * @param {ARWallControlOption} options Options
       */
      function ARWallControl(options) {
        var _this = this;

        if (options === void 0) {
          options = {};
        }

        this._enabled = true;
        this._initialized = false;
        this._modelHit = false;
        this._hitTestSource = null;

        this.onSelectStart = function (ctx) {
          var view3d = ctx.view3d,
              session = ctx.session,
              frame = ctx.frame,
              referenceSpace = ctx.referenceSpace,
              xrCam = ctx.xrCam;
          var hitTestSource = _this._hitTestSource;
          if (!hitTestSource || !_this._enabled) return;
          var deadzoneChecker = _this._deadzoneChecker;
          var rotateControl = _this._rotateControl;
          var translateControl = _this._translateControl;
          var scaleControl = _this._scaleControl; // Update deadzone testing gestures

          if (rotateControl.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.ONE_FINGER);
          }

          if (translateControl.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.ONE_FINGER);
          }

          if (scaleControl.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.PINCH);
          }

          var hitResults = frame.getHitTestResultsForTransientInput(hitTestSource);

          var coords = _this._hitResultToVector(hitResults);

          deadzoneChecker.applyScreenAspect(coords);
          deadzoneChecker.setFirstInput(coords);

          if (coords.length === 1) {
            // Check finger is on the model
            var modelBbox = view3d.model.bbox;
            var targetRayPose = frame.getPose(session.inputSources[0].targetRaySpace, referenceSpace);
            var camPos = new THREE.Vector3().setFromMatrixPosition(xrCam.matrixWorld);
            var fingerDir = new THREE.Vector3().copy(targetRayPose.transform.position).sub(camPos).normalize();
            var fingerRay = new THREE.Ray(camPos, fingerDir);
            var intersection = fingerRay.intersectBox(modelBbox, new THREE.Vector3());

            if (intersection) {
              // Touch point intersected with model
              _this._modelHit = true;
            }
          }

          _this._floorIndicator.show();
        };

        this.onSelectEnd = function () {
          _this.deactivate();

          _this._floorIndicator.fadeout();
        }; // TODO: bind options


        this._rotateControl = new ARSwirlControl(__assign(__assign({}, options.rotate), {
          showIndicator: false
        }));
        this._translateControl = new ARWallTranslateControl(options.translate);
        this._scaleControl = new ARScaleControl(options.scale);
        this._floorIndicator = new FloorIndicator(options.floorIndicator);
        this._deadzoneChecker = new DeadzoneChecker(options.deadzone);
      }

      var __proto = ARWallControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        /**
         * Return whether this control is enabled or not
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "rotate", {
        /**
         * {@link ARSwirlControlOptions} in this control
         */
        get: function () {
          return this._rotateControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "translate", {
        /**
         * {@link ARTranslateControl} in this control
         */
        get: function () {
          return this._translateControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scale", {
        /**
         * {@link ARScaleControl} in this control
         */
        get: function () {
          return this._scaleControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "controls", {
        get: function () {
          return [this._rotateControl, this._translateControl, this._scaleControl];
        },
        enumerable: false,
        configurable: true
      });

      __proto.init = function (ctx, initialTransform) {
        var _this = this;

        var session = ctx.session,
            view3d = ctx.view3d,
            size = ctx.size;
        this.controls.forEach(function (control) {
          return control.init(ctx);
        });

        this._translateControl.initWallTransform(initialTransform);

        this._deadzoneChecker.setAspect(size.height / size.width);

        view3d.scene.add(this._floorIndicator.mesh);
        this._initialized = true;
        session.requestHitTestSourceForTransientInput({
          profile: INPUT_PROFILE.TOUCH
        }).then(function (transientHitTestSource) {
          _this._hitTestSource = transientHitTestSource;
        });
      };
      /**
       * Destroy this control and deactivate it
       * @param view3d Instance of the {@link View3D}
       */


      __proto.destroy = function (ctx) {
        if (!this._initialized) return;

        if (this._hitTestSource) {
          this._hitTestSource.cancel();

          this._hitTestSource = null;
        }

        ctx.view3d.scene.remove(this._floorIndicator.mesh);
        this.deactivate();
        this.controls.forEach(function (control) {
          return control.destroy(ctx);
        });
        this._initialized = false;
      };

      __proto.deactivate = function () {
        this._modelHit = false;

        this._deadzoneChecker.cleanup();

        this.controls.forEach(function (control) {
          return control.deactivate();
        });
      };
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._enabled = true;
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._enabled = false;
        this.deactivate();
      };

      __proto.update = function (ctx) {
        var view3d = ctx.view3d,
            session = ctx.session,
            frame = ctx.frame;
        var hitTestSource = this._hitTestSource;
        if (!hitTestSource || !view3d.model) return;
        var deadzoneChecker = this._deadzoneChecker;
        var inputSources = session.inputSources;
        var hitResults = frame.getHitTestResultsForTransientInput(hitTestSource);

        var coords = this._hitResultToVector(hitResults);

        var xrInputs = {
          coords: coords,
          inputSources: inputSources,
          hitResults: hitResults
        };

        if (deadzoneChecker.inDeadzone) {
          this._checkDeadzone(ctx, xrInputs);
        } else {
          this._processInput(ctx, xrInputs);
        }

        this._updateControls(ctx);
      };

      __proto._checkDeadzone = function (ctx, _a) {
        var coords = _a.coords;
        var model = ctx.model;

        var gesture = this._deadzoneChecker.check(coords.map(function (coord) {
          return coord.clone();
        }));

        var rotateControl = this._rotateControl;
        var translateControl = this._translateControl;
        var scaleControl = this._scaleControl;
        if (gesture === GESTURE.NONE) return;

        switch (gesture) {
          case GESTURE.ONE_FINGER_HORIZONTAL:
          case GESTURE.ONE_FINGER_VERTICAL:
            if (this._modelHit) {
              translateControl.activate(ctx, gesture);
              translateControl.setInitialPos(coords);
            } else {
              rotateControl.activate(ctx, gesture);
              rotateControl.updateAxis(new THREE.Vector3(0, 1, 0).applyQuaternion(translateControl.hitRotation));
              rotateControl.updateRotation(model.scene.quaternion);
              rotateControl.setInitialPos(coords);
            }

            break;

          case GESTURE.PINCH:
            scaleControl.activate(ctx, gesture);
            scaleControl.setInitialPos(coords);
            break;
        }
      };

      __proto._processInput = function (ctx, inputs) {
        this.controls.forEach(function (control) {
          return control.process(ctx, inputs);
        });
      };

      __proto._updateControls = function (ctx) {
        var view3d = ctx.view3d,
            model = ctx.model,
            delta = ctx.delta;
        var deltaMilisec = delta * 1000;
        this.controls.forEach(function (control) {
          return control.update(ctx, deltaMilisec);
        });
        model.scene.updateMatrix();
        var translateControl = this._translateControl;
        var floorPosition = translateControl.wallPosition;
        view3d.scene.update(model, {
          floorPosition: floorPosition,
          floorRotation: translateControl.hitRotation
        }); // Get a scaled bbox, which only has scale applied on it.

        var scaleControl = this._scaleControl;
        var scaledBbox = model.initialBbox;
        scaledBbox.min.multiply(scaleControl.scale);
        scaledBbox.max.multiply(scaleControl.scale);
        var floorIndicator = this._floorIndicator;
        var boundingSphere = scaledBbox.getBoundingSphere(new THREE.Sphere());
        var rotX90 = new THREE.Quaternion().setFromEuler(new THREE.Euler(Math.PI / 2, 0, 0));
        var floorRotation = model.scene.quaternion.clone().multiply(rotX90);
        floorIndicator.update({
          delta: deltaMilisec,
          scale: boundingSphere.radius,
          position: floorPosition,
          rotation: floorRotation
        });
      };

      __proto._hitResultToVector = function (hitResults) {
        return hitResults.map(function (input) {
          return new THREE.Vector2().set(input.inputSource.gamepad.axes[0], -input.inputSource.gamepad.axes[1]);
        });
      };

      return ARWallControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * AR session which places model on the wall
     * @category XR
     * @fires WebARSession#start
     * @fires WebARSession#end
     * @fires WebARSession#canPlace
     * @fires WebARSession#modelPlaced
     */

    var WallARSession =
    /*#__PURE__*/
    function (_super) {
      __extends(WallARSession, _super);
      /**
       * Create new instance of WallARSession
       * @param {WallARSessionOption} [options={}] Options
       */


      function WallARSession(options) {
        if (options === void 0) {
          options = {};
        }

        var _this = _super.call(this, options) || this;

        _this.onStart = function (ctx) {
          var view3d = ctx.view3d,
              session = ctx.session;

          _super.prototype.onStart.call(_this, ctx);

          _this._control = new ARWallControl(_this._options);
          view3d.scene.hide();

          _this._hitTest.init(session);
        };

        _this.onEnd = function (ctx) {
          var view3d = ctx.view3d,
              session = ctx.session;

          _super.prototype.onEnd.call(_this, ctx);

          _this._renderContext = null;
          _this._modelPlaced = false;
          session.removeEventListener(EVENTS$1.SELECT_START, _this._onSelectStart);
          session.removeEventListener(EVENTS$1.SELECT_END, _this._onSelectEnd);

          _this._hitTest.destroy();

          _this._control.destroy(ctx);

          _this._control = null;
          view3d.scene.show();
        };

        _this._beforeRender = function (ctx) {
          _this._renderContext = ctx;

          if (!_this._modelPlaced) {
            _this._initModelPosition(ctx);
          } else {
            _this._control.update(ctx);
          }
        };

        _this._onSelectStart = function (e) {
          _this._control.onSelectStart(__assign(__assign({}, _this._renderContext), {
            frame: e.frame
          }));
        };

        _this._onSelectEnd = function () {
          _this._control.onSelectEnd();
        };

        _this._control = null;
        _this._renderContext = null;
        _this._modelPlaced = false;
        _this._hitTest = new HitTest();
        _this._features = merge(_this._features, _this._hitTest.features);
        _this._options = options;
        return _this;
      }

      var __proto = WallARSession.prototype;
      Object.defineProperty(__proto, "control", {
        /**
         * {@link ARWallControl} instance of this session
         * @type ARWallControl | null
         */
        get: function () {
          return this._control;
        },
        enumerable: false,
        configurable: true
      });

      __proto._initModelPosition = function (ctx) {
        var _a;

        var view3d = ctx.view3d,
            frame = ctx.frame,
            session = ctx.session;
        var model = view3d.model;
        var hitTest = this._hitTest; // Make sure the model is loaded

        if (!hitTest.ready || !model) return;
        var control = this._control;
        var referenceSpace = view3d.renderer.threeRenderer.xr.getReferenceSpace();
        var hitTestResults = hitTest.getResults(frame);
        if (hitTestResults.length <= 0) return;
        var hit = hitTestResults[0];
        var hitPose = hit.getPose(referenceSpace);
        var hitMatrix = new THREE.Matrix4().fromArray(hitPose.transform.matrix); // If transformed coord space's y axis is facing up or down, don't use it.

        if (hitMatrix.elements[5] >= 0.25 || hitMatrix.elements[5] <= -0.25) return;
        var modelRoot = model.scene;
        var hitRotation = new THREE.Quaternion().copy(hitPose.transform.orientation);
        var hitPosition = new THREE.Vector3().setFromMatrixPosition(hitMatrix);
        var modelZOffset = -model.initialBbox.min.z * modelRoot.scale.z;
        var modelPosition = hitPosition.clone().setZ(hitPosition.z + modelZOffset);
        var worldYAxis = new THREE.Vector3(0, 1, 0);
        /*
         * ^ wallU
         * |
         * ⨀---> wallV
         * wallNormal
         */

        var wallNormal = new THREE.Vector3(0, 1, 0).applyQuaternion(hitRotation).normalize();
        var wallU = new THREE.Vector3().crossVectors(worldYAxis, wallNormal);
        var wallV = wallNormal.clone().applyAxisAngle(wallU, -Math.PI / 2); // Reconstruct wall matrix with prev Y(normal) direction as Z axis

        var wallMatrix = new THREE.Matrix4().makeBasis(wallU, wallV, wallNormal);
        var wallRotation = new THREE.Quaternion().setFromRotationMatrix(wallMatrix);
        var modelRotation = model.scene.quaternion.clone().premultiply(wallRotation); // Update rotation & position

        modelRoot.quaternion.copy(modelRotation);
        modelRoot.position.copy(modelPosition);
        modelRoot.updateMatrix();
        view3d.scene.update(model);
        view3d.scene.show(); // Don't need it

        hitTest.destroy();
        session.addEventListener(EVENTS$1.SELECT_START, this._onSelectStart);
        session.addEventListener(EVENTS$1.SELECT_END, this._onSelectEnd);
        (_a = this._domOverlay) === null || _a === void 0 ? void 0 : _a.hideLoading();
        this._modelPlaced = true; // Show scale up animation

        var originalModelScale = model.scene.scale.clone();
        var scaleUpAnimation = new Animation({
          context: session
        });
        scaleUpAnimation.on("progress", function (evt) {
          var newScale = originalModelScale.clone().multiplyScalar(evt.easedProgress);
          model.scene.scale.copy(newScale);
        });
        scaleUpAnimation.on("finish", function () {
          model.scene.scale.copy(originalModelScale);
          control.init(ctx, {
            hitPosition: hitPosition,
            hitRotation: hitRotation,
            wallRotation: wallRotation,
            modelPosition: modelPosition
          });
        });
        scaleUpAnimation.start();
      };

      return WallARSession;
    }(WebARSession);

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    var STATE$2;

    (function (STATE) {
      STATE[STATE["WAITING"] = 0] = "WAITING";
      STATE[STATE["ROTATE_HORIZONTAL"] = 1] = "ROTATE_HORIZONTAL";
      STATE[STATE["ROTATE_VERTICAL"] = 2] = "ROTATE_VERTICAL";
    })(STATE$2 || (STATE$2 = {}));
    /**
     * Two finger swipe control
     * @category Controls-AR
     */


    var ARSwipeControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new ARSwipeControl
       * @param {ARSwipeControlOption} [options={}] Options
       */
      function ARSwipeControl(_a) {
        var _b = (_a === void 0 ? {} : _a).scale,
            scale = _b === void 0 ? 1 : _b;
        /**
         * Current rotation value
         */

        this.rotation = new THREE.Quaternion(); // Internal States

        this._state = STATE$2.WAITING;
        this._enabled = true;
        this._active = false;
        this._prevPos = new THREE.Vector2();
        this._fromQuat = new THREE.Quaternion();
        this._toQuat = new THREE.Quaternion();
        this._horizontalAxis = new THREE.Vector3();
        this._verticalAxis = new THREE.Vector3();
        this._motion = new Motion({
          range: INFINITE_RANGE
        });
        this._rotationIndicator = new RotationIndicator();
        this._userScale = scale;
      }

      var __proto = ARSwipeControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not.
         * @readonly
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scale", {
        /**
         * Scale(speed) factor of this control.
         */
        get: function () {
          return this._userScale;
        },
        set: function (val) {
          this._userScale = val;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "horizontalAxis", {
        get: function () {
          return this._horizontalAxis;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "verticalAxis", {
        get: function () {
          return this._verticalAxis;
        },
        enumerable: false,
        configurable: true
      });

      __proto.init = function (_a) {
        var view3d = _a.view3d;
        var initialRotation = view3d.model.scene.quaternion;
        this.updateRotation(initialRotation);
        view3d.scene.add(this._rotationIndicator.object);
      };

      __proto.destroy = function (_a) {
        var view3d = _a.view3d;
        view3d.scene.remove(this._rotationIndicator.object);
      };

      __proto.updateRotation = function (rotation) {
        this.rotation.copy(rotation);

        this._fromQuat.copy(rotation);

        this._toQuat.copy(rotation);
      };
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._enabled = true;
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._enabled = false;
      };

      __proto.updateAxis = function (horizontal, vertical) {
        this._horizontalAxis.copy(horizontal);

        this._verticalAxis.copy(vertical);
      };

      __proto.activate = function (_a, gesture) {
        var view3d = _a.view3d;
        if (!this._enabled) return;
        var model = view3d.model;
        var rotationIndicator = this._rotationIndicator;
        this._active = true;
        rotationIndicator.show();
        rotationIndicator.updatePosition(model.bbox.getCenter(new THREE.Vector3()));
        rotationIndicator.updateScale(model.size / 2);

        if (gesture === GESTURE.TWO_FINGER_HORIZONTAL) {
          rotationIndicator.updateRotation(model.scene.quaternion.clone().multiply(new THREE.Quaternion().setFromEuler(new THREE.Euler(-Math.PI / 2, 0, 0))));
          this._state = STATE$2.ROTATE_HORIZONTAL;
        } else if (gesture === GESTURE.TWO_FINGER_VERTICAL) {
          rotationIndicator.updateRotation(model.scene.quaternion.clone().multiply(new THREE.Quaternion().setFromEuler(new THREE.Euler(0, Math.PI / 2, 0))));
          this._state = STATE$2.ROTATE_VERTICAL;
        }
      };

      __proto.deactivate = function () {
        this._active = false;

        this._rotationIndicator.hide();

        this._state = STATE$2.WAITING;
      };

      __proto.setInitialPos = function (coords) {
        if (coords.length < 2) return;

        this._prevPos.set((coords[0].x + coords[1].x) / 2, (coords[0].y + coords[1].y) / 2);
      };

      __proto.process = function (ctx, _a) {
        var coords = _a.coords;
        if (!this._active || coords.length !== 2) return;
        var state = this._state;
        var prevPos = this._prevPos;
        var motion = this._motion;
        var scale = this._userScale;
        var middlePos = new THREE.Vector2((coords[0].x + coords[1].x) / 2, (coords[0].y + coords[1].y) / 2);
        var posDiff = new THREE.Vector2().subVectors(prevPos, middlePos);
        var rotationAxis = state === STATE$2.ROTATE_HORIZONTAL ? this._horizontalAxis : this._verticalAxis;
        var rotationAngle = state === STATE$2.ROTATE_HORIZONTAL ? posDiff.x * scale : -posDiff.y * scale;
        var rotation = new THREE.Quaternion().setFromAxisAngle(rotationAxis, rotationAngle);

        var interpolated = this._getInterpolatedQuaternion();

        this._fromQuat.copy(interpolated);

        this._toQuat.premultiply(rotation);

        motion.reset(0);
        motion.setEndDelta(1);
        prevPos.copy(middlePos);
      };

      __proto.update = function (_a, deltaTime) {
        var model = _a.model;
        var motion = this._motion;
        motion.update(deltaTime);

        var interpolated = this._getInterpolatedQuaternion();

        this.rotation.copy(interpolated);
        model.scene.quaternion.copy(this.rotation);
      };

      __proto._getInterpolatedQuaternion = function () {
        var motion = this._motion;
        var toEuler = this._toQuat;
        var fromEuler = this._fromQuat;
        var progress = motion.val;
        return new THREE.Quaternion().copy(fromEuler).slerp(toEuler, progress);
      };

      return ARSwipeControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Model's yaw(local y-axis rotation) controller which works on AR(WebXR) mode.
     * @category Controls-AR
     */

    var ARHoverRotateControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of ARRotateControl
       * @param {ARHoverRotateControlOption} options Options
       */
      function ARHoverRotateControl(options) {
        if (options === void 0) {
          options = {};
        }
        /**
         * Current rotation value
         */


        this.rotation = new THREE.Quaternion();
        this._zRotationControl = new ARSwirlControl(options.swirl);
        this._xyRotationControl = new ARSwipeControl(options.swipe);
        this._activatedControl = null;
      }

      var __proto = ARHoverRotateControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        /**
         * Whether this control is enabled or not.
         * This returns true when either one finger control or two finger control is enabled.
         * @readonly
         */
        get: function () {
          return this._zRotationControl.enabled || this._xyRotationControl.enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "swirl", {
        /**
         * {@link ARSwirlControl} of this control.
         */
        get: function () {
          return this._zRotationControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "swipe", {
        /**
         * {@link ARSwipeControl} of this control.
         */
        get: function () {
          return this._xyRotationControl;
        },
        enumerable: false,
        configurable: true
      });

      __proto.init = function (ctx) {
        var initialRotation = ctx.view3d.model.scene.quaternion;
        this.rotation.copy(initialRotation);

        this._zRotationControl.init(ctx);

        this._xyRotationControl.init(ctx);
      };

      __proto.destroy = function (ctx) {
        this._zRotationControl.destroy(ctx);

        this._xyRotationControl.destroy(ctx);
      };
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._zRotationControl.enable();

        this._xyRotationControl.enable();
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._zRotationControl.disable();

        this._xyRotationControl.disable();
      };

      __proto.activate = function (ctx, gesture) {
        var zRotationControl = this._zRotationControl;
        var xyRotationControl = this._xyRotationControl;

        if (gesture & GESTURE.ONE_FINGER) {
          zRotationControl.activate(ctx, gesture);
          zRotationControl.updateRotation(this.rotation);
          this._activatedControl = zRotationControl;
        } else if (gesture & GESTURE.TWO_FINGER) {
          xyRotationControl.activate(ctx, gesture);
          xyRotationControl.updateRotation(this.rotation);
          this._activatedControl = xyRotationControl;
        }
      };

      __proto.deactivate = function () {
        this._zRotationControl.deactivate();

        this._xyRotationControl.deactivate();
      };

      __proto.process = function (ctx, inputs) {
        this._zRotationControl.process(ctx, inputs);

        this._xyRotationControl.process(ctx, inputs);
      };

      __proto.setInitialPos = function (coords) {
        this._zRotationControl.setInitialPos(coords);

        this._xyRotationControl.setInitialPos(coords);
      };

      __proto.update = function (ctx, deltaTime) {
        if (this._activatedControl) {
          this._activatedControl.update(ctx, deltaTime);

          this.rotation.copy(this._activatedControl.rotation);
        }
      };

      __proto.updateRotateAxis = function (_a) {
        var view3d = _a.view3d,
            xrCam = _a.xrCam;
        var model = view3d.model;
        var zRotateAxis = new THREE.Vector3();
        var horizontalRotateAxis = new THREE.Vector3();
        var verticalRotateAxis = new THREE.Vector3();
        var cameraRotation = new THREE.Quaternion().setFromRotationMatrix(xrCam.matrixWorld);
        var cameraBasis = [new THREE.Vector3(1, 0, 0), new THREE.Vector3(0, 1, 0), new THREE.Vector3(0, 0, 1)].map(function (axis) {
          return axis.applyQuaternion(cameraRotation).normalize();
        });
        var modelBasis = [new THREE.Vector3(1, 0, 0), new THREE.Vector3(0, 1, 0), new THREE.Vector3(0, 0, 1)].map(function (axis) {
          return axis.applyQuaternion(model.scene.quaternion);
        }); // Always use z-rotation

        zRotateAxis.copy(modelBasis[2]); // Use more appropriate one between x/y axis

        horizontalRotateAxis.copy(modelBasis[1]);
        verticalRotateAxis.copy(modelBasis[0]); // If it's facing other direction, negate it to face correct direction

        if (zRotateAxis.dot(cameraBasis[2]) < 0) {
          zRotateAxis.negate();
        }

        if (horizontalRotateAxis.dot(cameraBasis[1]) > 0) {
          horizontalRotateAxis.negate();
        }

        if (verticalRotateAxis.dot(cameraBasis[0]) > 0) {
          verticalRotateAxis.negate();
        }

        this._zRotationControl.updateAxis(zRotateAxis);

        this._xyRotationControl.updateAxis(horizontalRotateAxis, verticalRotateAxis);
      };

      return ARHoverRotateControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Model's translation(position) control for {@link ARHoverControl}
     * @category Controls-AR
     */

    var ARHoverTranslateControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of ARTranslateControl
       * @param {ARHoverTranslateControlOption} [options={}] Options
       */
      function ARHoverTranslateControl(options) {
        if (options === void 0) {
          options = {};
        } // Internal states


        this._position = new THREE.Vector3();
        this._dragPlane = new THREE.Plane();
        this._enabled = true;
        this._active = false;
        this._initialPos = new THREE.Vector2();
        this._arrowIndicator = new ArrowIndicator(options.arrow);
      }

      var __proto = ARHoverTranslateControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "position", {
        get: function () {
          return this._position.clone();
        },
        enumerable: false,
        configurable: true
      });

      __proto.init = function (_a) {
        var view3d = _a.view3d;

        this._position.copy(view3d.model.scene.position);

        view3d.scene.add(this._arrowIndicator.object);
      };

      __proto.destroy = function (_a) {
        var view3d = _a.view3d;
        view3d.scene.remove(this._arrowIndicator.object);
      };
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._enabled = true;
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._enabled = false;
        this.deactivate();
      };

      __proto.activate = function (_a, gesture) {
        var model = _a.model,
            xrCam = _a.xrCam;
        if (!this._enabled) return;
        var modelPos = model.scene.position;
        var camPos = new THREE.Vector3().setFromMatrixPosition(xrCam.matrixWorld);
        var modelBasis = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
        model.scene.matrixWorld.extractBasis(modelBasis[0], modelBasis[1], modelBasis[2]);
        modelBasis.forEach(function (axes) {
          return axes.normalize();
        });
        var camToModelDir = new THREE.Vector3().subVectors(modelPos, camPos).clone().normalize();
        var primaryAxisIdx = getPrimaryAxisIndex(modelBasis, camToModelDir);
        var primaryAxis = modelBasis[primaryAxisIdx]; // If axes is facing the opposite of camera, negate it

        if (primaryAxis.dot(camToModelDir) < 0) {
          primaryAxis.negate();
        }

        var originToDragPlane = new THREE.Plane(primaryAxis, 0).distanceToPoint(modelPos);

        this._dragPlane.set(primaryAxis, -originToDragPlane);

        this._active = true; // Update arrows

        var arrowIndicator = this._arrowIndicator;
        var modelBbox = model.initialBbox;
        modelBbox.min.multiply(model.scene.scale);
        modelBbox.max.multiply(model.scene.scale);
        modelBbox.translate(modelPos);
        arrowIndicator.show();
        arrowIndicator.updatePosition(modelBbox.getCenter(new THREE.Vector3()));
        arrowIndicator.updateScale(model.size / 16);
        var arrowPlaneRotation = model.scene.quaternion.clone();

        if (primaryAxisIdx === 0) {
          arrowPlaneRotation.multiply(new THREE.Quaternion().setFromEuler(new THREE.Euler(0, Math.PI / 2, 0)));
        } else if (primaryAxisIdx === 1) {
          arrowPlaneRotation.multiply(new THREE.Quaternion().setFromEuler(new THREE.Euler(Math.PI / 2, 0, 0)));
        }

        arrowIndicator.updateRotation(arrowPlaneRotation);
        arrowIndicator.updateOffset(new THREE.Vector3().subVectors(modelBbox.max, modelBbox.min).multiplyScalar(0.5));
      };

      __proto.deactivate = function () {
        this._active = false;

        this._arrowIndicator.hide();
      };

      __proto.setInitialPos = function (coords) {
        this._initialPos.copy(coords[0]);
      };

      __proto.process = function (_a, _b) {
        var view3d = _a.view3d,
            frame = _a.frame,
            referenceSpace = _a.referenceSpace,
            xrCam = _a.xrCam;
        var inputSources = _b.inputSources;
        if (inputSources.length !== 1 || !this._active) return;
        var inputSource = inputSources[0];
        var dragPlane = this._dragPlane;
        var targetRayPose = frame.getPose(inputSource.targetRaySpace, referenceSpace);
        var camPos = new THREE.Vector3().setFromMatrixPosition(xrCam.matrixWorld);
        var fingerDir = new THREE.Vector3().copy(targetRayPose.transform.position).sub(camPos).normalize();
        var fingerRay = new THREE.Ray(camPos, fingerDir);
        var intersection = fingerRay.intersectPlane(dragPlane, new THREE.Vector3());

        if (intersection) {
          this._position.copy(intersection); // Update arrow position. As position is not a center of model, we should apply offset from it


          var model = view3d.model;
          var centerYOffset = model.initialBbox.getCenter(new THREE.Vector3()).multiply(model.scene.scale).y;
          var modelLocalYDir = new THREE.Vector3().applyQuaternion(model.scene.quaternion);
          var newCenter = intersection.add(modelLocalYDir.multiplyScalar(centerYOffset));

          this._arrowIndicator.updatePosition(newCenter);
        }
      };

      __proto.update = function (_a, delta) {
        var model = _a.model;
        model.scene.position.copy(this._position);
      };

      return ARHoverTranslateControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * AR control for {@link HoverARSession}
     * @category Controls-AR
     */

    var ARHoverControl =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of ARHoverControl
       * @param {ARHoverControlOption} options Options
       */
      function ARHoverControl(options) {
        var _this = this;

        if (options === void 0) {
          options = {};
        }

        this._enabled = true;
        this._initialized = false;
        this._modelHit = false;

        this.onSelectStart = function (ctx) {
          var view3d = ctx.view3d,
              session = ctx.session,
              frame = ctx.frame,
              referenceSpace = ctx.referenceSpace,
              xrCam = ctx.xrCam;
          if (!_this._enabled) return;
          var deadzoneChecker = _this._deadzoneChecker;
          var rotateControl = _this._rotateControl;
          var translateControl = _this._translateControl;
          var scaleControl = _this._scaleControl; // Update rotation axis

          if (rotateControl.enabled) {
            rotateControl.updateRotateAxis(ctx);
          } // Update deadzone testing gestures


          if (rotateControl.swirl.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.ONE_FINGER);
          }

          if (rotateControl.swipe.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.TWO_FINGER);
          }

          if (translateControl.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.ONE_FINGER);
          }

          if (scaleControl.enabled) {
            deadzoneChecker.addTestingGestures(GESTURE.PINCH);
          }

          var coords = _this._inputSourceToVector(session.inputSources);

          deadzoneChecker.applyScreenAspect(coords);
          deadzoneChecker.setFirstInput(coords);

          if (coords.length === 1) {
            // Check finger is on the model
            var modelBbox = view3d.model.bbox;
            var targetRayPose = frame.getPose(session.inputSources[0].targetRaySpace, referenceSpace);
            var camPos = new THREE.Vector3().setFromMatrixPosition(xrCam.matrixWorld);
            var fingerDir = new THREE.Vector3().copy(targetRayPose.transform.position).sub(camPos).normalize();
            var fingerRay = new THREE.Ray(camPos, fingerDir);
            var intersection = fingerRay.intersectBox(modelBbox, new THREE.Vector3());

            if (intersection) {
              // Touch point intersected with model
              _this._modelHit = true;
            }
          }
        };

        this.onSelectEnd = function () {
          _this.deactivate();
        };

        this._rotateControl = new ARHoverRotateControl(options.rotate);
        this._translateControl = new ARHoverTranslateControl(options.translate);
        this._scaleControl = new ARScaleControl(options.scale);
        this._deadzoneChecker = new DeadzoneChecker();
      }

      var __proto = ARHoverControl.prototype;
      Object.defineProperty(__proto, "enabled", {
        /**
         * Return whether this control is enabled or not
         */
        get: function () {
          return this._enabled;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "rotate", {
        /**
         * {@link ARHoverRotateControlOption} in this control
         */
        get: function () {
          return this._rotateControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "translate", {
        /**
         * {@link ARHoverTranslateControlOption} in this control
         */
        get: function () {
          return this._translateControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "scale", {
        /**
         * {@link ARScaleControl} in this control
         */
        get: function () {
          return this._scaleControl;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "controls", {
        get: function () {
          return [this._rotateControl, this._translateControl, this._scaleControl];
        },
        enumerable: false,
        configurable: true
      });

      __proto.init = function (ctx) {
        var size = ctx.size;
        this.controls.forEach(function (control) {
          return control.init(ctx);
        });

        this._deadzoneChecker.setAspect(size.height / size.width);

        this._initialized = true;
      };
      /**
       * Destroy this control and deactivate it
       * @param view3d Instance of the {@link View3D}
       */


      __proto.destroy = function (ctx) {
        if (!this._initialized) return;
        this.deactivate();
        this.controls.forEach(function (control) {
          return control.destroy(ctx);
        });
        this._initialized = false;
      };

      __proto.deactivate = function () {
        this._modelHit = false;

        this._deadzoneChecker.cleanup();

        this.controls.forEach(function (control) {
          return control.deactivate();
        });
      };
      /**
       * Enable this control
       */


      __proto.enable = function () {
        this._enabled = true;
      };
      /**
       * Disable this control
       */


      __proto.disable = function () {
        this._enabled = false;
        this.deactivate();
      };

      __proto.update = function (ctx) {
        var session = ctx.session;
        if (!this._initialized) return;
        var deadzoneChecker = this._deadzoneChecker;
        var inputSources = session.inputSources;

        if (deadzoneChecker.inDeadzone) {
          this._checkDeadzone(ctx, inputSources);
        } else {
          this._processInput(ctx, inputSources);
        }

        this._updateControls(ctx);
      };

      __proto._checkDeadzone = function (ctx, inputSources) {
        var coords = this._inputSourceToVector(inputSources);

        var gesture = this._deadzoneChecker.check(coords.map(function (coord) {
          return coord.clone();
        }));

        var rotateControl = this._rotateControl;
        var translateControl = this._translateControl;
        var scaleControl = this._scaleControl;
        if (gesture === GESTURE.NONE) return;

        switch (gesture) {
          case GESTURE.ONE_FINGER_HORIZONTAL:
          case GESTURE.ONE_FINGER_VERTICAL:
            if (this._modelHit) {
              translateControl.activate(ctx, gesture);
              translateControl.setInitialPos(coords);
            } else {
              rotateControl.activate(ctx, gesture);
              rotateControl.setInitialPos(coords);
            }

            break;

          case GESTURE.TWO_FINGER_HORIZONTAL:
          case GESTURE.TWO_FINGER_VERTICAL:
            rotateControl.activate(ctx, gesture);
            rotateControl.setInitialPos(coords);
            break;

          case GESTURE.PINCH:
            scaleControl.activate(ctx, gesture);
            scaleControl.setInitialPos(coords);
            break;
        }
      };

      __proto._processInput = function (ctx, inputSources) {
        var coords = this._inputSourceToVector(inputSources);

        this.controls.forEach(function (control) {
          return control.process(ctx, {
            coords: coords,
            inputSources: inputSources
          });
        });
      };

      __proto._updateControls = function (ctx) {
        var view3d = ctx.view3d,
            model = ctx.model,
            delta = ctx.delta;
        var deltaMilisec = delta * 1000;
        this.controls.forEach(function (control) {
          return control.update(ctx, deltaMilisec);
        });
        model.scene.updateMatrix();
        view3d.scene.update(model);
      };

      __proto._inputSourceToVector = function (inputSources) {
        return Array.from(inputSources).map(function (inputSource) {
          var axes = inputSource.gamepad.axes;
          return new THREE.Vector2(axes[0], -axes[1]);
        });
      };

      return ARHoverControl;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * WebXR based AR session which puts model at the space front of camera.
     * @category XR
     * @fires WebARSession#start
     * @fires WebARSession#end
     * @fires WebARSession#canPlace
     * @fires WebARSession#modelPlaced
     */

    var HoverARSession =
    /*#__PURE__*/
    function (_super) {
      __extends(HoverARSession, _super);
      /**
       * Create new instance of HoverARSession
       * @param {HoverARSessionOption} options Options
       */


      function HoverARSession(options) {
        if (options === void 0) {
          options = {};
        }

        var _this = _super.call(this, options) || this;

        _this.onStart = function (ctx) {
          var view3d = ctx.view3d;

          _super.prototype.onStart.call(_this, ctx);

          _this._control = new ARHoverControl(_this._options);
          view3d.scene.hide();
        };

        _this.onEnd = function (ctx) {
          var view3d = ctx.view3d,
              session = ctx.session;

          _super.prototype.onEnd.call(_this, ctx);

          _this._renderContext = null;
          _this._modelPlaced = false;
          session.removeEventListener(EVENTS$1.SELECT_START, _this._onSelectStart);
          session.removeEventListener(EVENTS$1.SELECT_END, _this._onSelectEnd);

          _this._control.destroy(ctx);

          _this._control = null;
          view3d.scene.show();
        };

        _this._beforeRender = function (ctx) {
          _this._renderContext = ctx;

          if (!_this._modelPlaced) {
            _this._initModelPosition(ctx);
          } else {
            _this._control.update(ctx);
          }
        };

        _this._onSelectStart = function (e) {
          _this._control.onSelectStart(__assign(__assign({}, _this._renderContext), {
            frame: e.frame
          }));
        };

        _this._onSelectEnd = function () {
          _this._control.onSelectEnd();
        };

        _this._control = null;
        _this._renderContext = null;
        _this._modelPlaced = false;
        _this._options = options;
        return _this;
      }

      var __proto = HoverARSession.prototype;
      Object.defineProperty(__proto, "control", {
        /**
         * {@link ARControl} instance of this session
         * @type ARHoverControl | null
         */
        get: function () {
          return this._control;
        },
        enumerable: false,
        configurable: true
      });
      /**
       * Place model on the current position
       */

      __proto.placeModel = function () {
        var ctx = this._renderContext; // Not ready to place model yet

        if (!ctx || !ctx.view3d.scene.visible || this._modelPlaced) return;
        var session = ctx.session,
            view3d = ctx.view3d;
        var modelRoot = view3d.model.scene;
        var control = this._control;
        session.addEventListener(EVENTS$1.SELECT_START, this._onSelectStart);
        session.addEventListener(EVENTS$1.SELECT_END, this._onSelectEnd);
        this._modelPlaced = true;
        this.emit("modelPlaced"); // Show scale up animation

        var originalModelScale = modelRoot.scale.clone();
        var scaleUpAnimation = new Animation({
          context: session
        });
        scaleUpAnimation.on("progress", function (evt) {
          var newScale = originalModelScale.clone().multiplyScalar(evt.easedProgress);
          modelRoot.scale.copy(newScale);
        });
        scaleUpAnimation.on("finish", function () {
          modelRoot.scale.copy(originalModelScale);
          control.init(ctx);
        });
        scaleUpAnimation.start();
      };

      __proto._initModelPosition = function (ctx) {
        var view3d = ctx.view3d,
            xrCam = ctx.xrCam;
        var model = view3d.model; // Make sure the model exist

        if (!model) return;
        var modelRoot = model.scene;
        var camPos = new THREE.Vector3().setFromMatrixPosition(xrCam.matrixWorld);
        var camQuat = new THREE.Quaternion().setFromRotationMatrix(xrCam.matrixWorld);
        var viewDir = new THREE.Vector3(0, 0, -1).applyQuaternion(camQuat);
        var modelBbox = model.bbox;
        var bboxDiff = new THREE.Vector3().subVectors(modelBbox.max, modelBbox.min);
        var maxComponent = Math.max(bboxDiff.x, bboxDiff.y, bboxDiff.z); // Reset rotation & update position

        modelRoot.position.copy(camPos);
        modelRoot.position.add(viewDir.multiplyScalar(clamp(maxComponent, 0.5, 3))); // Place at 1m from camera

        modelRoot.lookAt(camPos.setY(modelRoot.position.y));
        modelRoot.updateMatrix();
        view3d.scene.update(model);

        if (!view3d.scene.visible) {
          view3d.scene.show();
          this.emit("canPlace");
        }
      };

      return HoverARSession;
    }(WebARSession);

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    // Browser related constants
    var IS_IOS = /iPad|iPhone|iPod/.test(navigator.userAgent) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
    var IS_ANDROID = /android/i.test(navigator.userAgent);
    var IS_SAFARI = /safari/i.test(navigator.userAgent);

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * AR session using Google's scene-viewer
     * @category XR
     * @see https://developers.google.com/ar/develop/java/scene-viewer
     */

    var SceneViewerSession =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of SceneViewerSession
       * @see https://developers.google.com/ar/develop/java/scene-viewer
       * @param params Session params
       * @param {string} [params.file] This URL specifies the glTF or glb file that should be loaded into Scene Viewer. This should be URL-escaped.
       * @param {string} [params.browser_fallback_url] This is a Google Chrome feature supported only for web-based implementations. When the Google app com.google.android.googlequicksearchbox is not present on the device, this is the URL that Google Chrome navigates to.
       * @param {string} [params.mode="ar_only"] See {@link https://developers.google.com/ar/develop/java/scene-viewer} for available modes.
       * @param {string} [params.title] A name for the model. If present, it will be displayed in the UI. The name will be truncated with ellipses after 60 characters.
       * @param {string} [params.link] A URL for an external webpage. If present, a button will be surfaced in the UI that intents to this URL when clicked.
       * @param {string} [params.sound] A URL to a looping audio track that is synchronized with the first animation embedded in a glTF file. It should be provided alongside a glTF with an animation of matching length. If present, the sound is looped after the model is loaded. This should be URL-escaped.
       * @param {string} [params.resizable=true] When set to false, users will not be able to scale the model in the AR experience. Scaling works normally in the 3D experience.
       */
      function SceneViewerSession(params) {
        this.params = params;
        this.isWebXRSession = false;

        if (!this.params.mode) {
          // Default mode is "ar_only", which should use com.google.ar.core package
          this.params.mode = "ar_only";
        }
      }
      /**
       * Return the availability of SceneViewerSession.
       * Scene-viewer is available on all android devices with google ARCore installed.
       * @returns {Promise} A Promise that resolves availability of this session(boolean).
       */


      var __proto = SceneViewerSession.prototype;

      __proto.isAvailable = function () {
        return Promise.resolve(IS_ANDROID);
      };
      /**
       * Enter Scene-viewer AR session
       */


      __proto.enter = function () {
        var params = Object.assign({}, this.params);
        var fallback = params.browser_fallback_url;
        delete params.browser_fallback_url;
        var resizable = params.resizable;
        delete params.resizable;

        if (resizable === true) {
          params.resizable = "true";
        } else if (resizable === false) {
          params.resizable = "false";
        } else if (resizable) {
          params.resizable = resizable;
        }

        var queryString = Object.keys(params).filter(function (key) {
          return params[key] != null;
        }).map(function (key) {
          return key + "=" + params[key];
        }).join("&");
        var intentURL = params.mode === "ar_only" ? SCENE_VIEWER.INTENT_AR_CORE(queryString, fallback) : SCENE_VIEWER.INTENT_SEARCHBOX(queryString, fallback || SCENE_VIEWER.FALLBACK_DEFAULT(queryString));
        var anchor = document.createElement("a");
        anchor.href = intentURL;
        anchor.click();
        return Promise.resolve();
      };

      __proto.exit = function () {// DO NOTHING
      };

      return SceneViewerSession;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * AR Session using Apple AR Quick Look Viewer
     * @category XR
     * @see https://developer.apple.com/augmented-reality/quick-look/
     */

    var QuickLookSession =
    /*#__PURE__*/
    function () {
      /**
       * Create new instance of QuickLookSession
       * @param {object} [options] Quick Look options
       * @param {string} [options.file] USDZ file's location URL.
       * @param {boolean} [options.allowsContentScaling=true] Whether to allow content scaling.
       */
      function QuickLookSession(_a) {
        var file = _a.file,
            _b = _a.allowsContentScaling,
            allowsContentScaling = _b === void 0 ? true : _b;
        /**
         * Whether it's webxr-based session or not
         * @type false
         */

        this.isWebXRSession = false;
        this._file = file;
        this._allowsContentScaling = allowsContentScaling;
      }
      /**
       * Return the availability of QuickLookSession.
       * QuickLook AR is available on iOS12+ on Safari & Chrome browser
       * Note that iOS Chrome won't show up QuickLook AR when it's local dev environment
       * @returns {Promise} A Promise that resolves availability of this session(boolean).
       */


      var __proto = QuickLookSession.prototype;

      __proto.isAvailable = function () {
        // This can handle all WebKit based browsers including iOS Safari & iOS Chrome
        return Promise.resolve(QUICKLOOK_SUPPORTED && IS_IOS && IS_SAFARI);
      };
      /**
       * Enter QuickLook AR Session
       */


      __proto.enter = function () {
        var anchor = document.createElement("a");
        anchor.setAttribute("rel", "ar");
        anchor.appendChild(document.createElement("img"));
        var usdzURL = new URL(this._file, window.location.toString());

        if (!this._allowsContentScaling) {
          usdzURL.hash = "allowsContentScaling=0";
        }

        anchor.setAttribute("href", usdzURL.toString());
        anchor.click();
        return Promise.resolve();
      };

      __proto.exit = function () {// DO NOTHING
      };

      return QuickLookSession;
    }();

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var XR = {
        __proto__: null,
        WebARSession: WebARSession,
        FloorARSession: FloorARSession,
        WallARSession: WallARSession,
        HoverARSession: HoverARSession,
        SceneViewerSession: SceneViewerSession,
        QuickLookSession: QuickLookSession
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    /**
     * Texture(image) model
     * @category Extra
     */

    var TextureModel =
    /*#__PURE__*/
    function (_super) {
      __extends(TextureModel, _super);
      /**
       * Create new TextureModel
       * @param {object} options Options
       * @param {number} [options.width] Width of the model.
       * @param {number} [options.height] Height of the model.
       * @param {boolean} [options.billboard=false] When set to true, model will keep rotate to show its front face to camera. Only Y-axis rotation is considered.
       * @throws {View3DError} `CODES.PROVIDE_WIDTH_OR_HEIGHT` When both width and height are not given.
       */


      function TextureModel(_a) {
        var image = _a.image,
            width = _a.width,
            height = _a.height,
            _b = _a.billboard,
            billboard = _b === void 0 ? false : _b;

        var _this = this;

        var texture = image.isTexture ? image : new THREE.Texture(image);
        var aspect = texture.image.width / texture.image.height;

        if (width == null && height == null) {
          throw new View3DError(MESSAGES.PROVIDE_WIDTH_OR_HEIGHT, CODES.PROVIDE_WIDTH_OR_HEIGHT);
        }

        if (width == null) {
          width = height * aspect;
        } else if (height == null) {
          height = width / aspect;
        }

        texture.encoding = THREE.sRGBEncoding;
        var geometry = new THREE.PlaneGeometry(width, height);
        var material = new THREE.MeshBasicMaterial({
          map: texture,
          side: THREE.DoubleSide
        });
        var mesh = new THREE.Mesh(geometry, material);
        _this = _super.call(this, {
          scenes: [mesh]
        }) || this;
        _this._texture = texture;
        _this._mesh = mesh;

        if (billboard) {
          var root_1 = mesh;

          root_1.onBeforeRender = function (renderer, scene, camera) {
            var pos = root_1.getWorldPosition(new THREE.Vector3());
            var camPos = new THREE.Vector3().setFromMatrixPosition(camera.matrixWorld);
            root_1.lookAt(camPos.setY(pos.y));
            mesh.updateMatrix();
          };
        }

        return _this;
      }

      var __proto = TextureModel.prototype;
      Object.defineProperty(__proto, "texture", {
        /**
         * Texture that used for this model
         * @see https://threejs.org/docs/index.html#api/en/textures/Texture
         * @type THREE.Texture
         */
        get: function () {
          return this._texture;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(__proto, "mesh", {
        /**
         * Model's mesh object
         * @see https://threejs.org/docs/index.html#api/en/objects/Mesh
         * @type THREE.Mesh
         */
        get: function () {
          return this._mesh;
        },
        enumerable: false,
        configurable: true
      });
      return TextureModel;
    }(Model);

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var Extra = {
        __proto__: null,
        TextureModel: TextureModel
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */

    var Externals = {
        __proto__: null,
        THREE: THREE
    };

    /*
     * Copyright (c) 2020 NAVER Corp.
     * egjs projects are licensed under the MIT license
     */
    merge(View3D, Core);
    merge(View3D, Environments);
    merge(View3D, Controls);
    merge(View3D, Loaders);
    merge(View3D, XR);
    merge(View3D, Extra);
    merge(View3D, Externals);
    View3D.View3DError = View3DError;
    View3D.ERROR_CODES = CODES;
    View3D.EASING = EASING;

    return View3D;

})));
//# sourceMappingURL=view3d.js.map