whs.module.js

/* WhitestormJS Framework v2.0.0 */
import { AmbientLight, AnimationClip, AnimationMixer, BoxBufferGeometry, BoxGeometry, BufferAttribute, BufferGeometry, CircleBufferGeometry, CircleGeometry, Clock, Color, ConeBufferGeometry, ConeGeometry, CubeCamera, CylinderBufferGeometry, CylinderGeometry, DepthStencilFormat, DepthTexture, DirectionalLight, DodecahedronBufferGeometry, DodecahedronGeometry, EventDispatcher, ExtrudeGeometry, Fog, FogExp2, Font, FontLoader, Geometry, HemisphereLight, IcosahedronBufferGeometry, IcosahedronGeometry, JSONLoader, LatheBufferGeometry, LatheGeometry, Line, LineCurve3, LinearFilter, LinearMipMapLinearFilter, MOUSE, Mesh, NearestFilter, Object3D, OctahedronBufferGeometry, OctahedronGeometry, OrthographicCamera, ParametricBufferGeometry, ParametricGeometry, PerspectiveCamera, Plane, PlaneBufferGeometry, PlaneGeometry, PointLight, PolyhedronBufferGeometry, PolyhedronGeometry, Quaternion, REVISION, RGBAFormat, RGBFormat, Raycaster, RectAreaLight, RepeatWrapping, RingBufferGeometry, RingGeometry, Scene, ShaderMaterial, ShapeBufferGeometry, ShapeGeometry, SphereBufferGeometry, SphereGeometry, Spherical, SpotLight, TetrahedronBufferGeometry, TetrahedronGeometry, TextGeometry, TextureLoader, TorusGeometry, TorusKnotBufferGeometry, TorusKnotGeometry, TubeBufferGeometry, TubeGeometry, UVMapping, Uniform, UnsignedInt248Type, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from 'three';

var extend = function extend(object) {
  for (var _len = arguments.length, extensions = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    extensions[_key - 1] = arguments[_key];
  }

  // $.extend alternative, ... is the spread operator.
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = extensions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var extension = _step.value;

      // console.log(extension);
      // console.log(typeof extension);

      if (!extension) continue; // Ignore null and undefined objects and parameters.

      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = Object.getOwnPropertyNames(extension)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var prop = _step2.value;
          // Do not traverse the prototype chain.
          if (object[prop] !== undefined && extension[prop] && object[prop].toString() === '[object Object]' && extension[prop].toString() === '[object Object]') {
            // Goes deep only if object[prop] and extension[prop] are both objects !
            if (extension[prop].constructor === Object) extend(object[prop], extension[prop]);else object[prop] = extension[prop];
          } else object[prop] = typeof object[prop] === 'undefined' ? extension[prop] : object[prop];

          if (typeof object[prop] === 'undefined' && Array.isArray(extension[prop])) object[prop] = extension[prop].slice(); // Add values that do not already exist.
          else if (typeof object[prop] === 'undefined' && Array.isArray(extension[prop])) object[prop] = extension[prop];
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  return object;
};

var instruct = function instruct(array, instArray) {
  var tempObject = {};

  for (var i = 0, max = instArray.length; i < max; i++) {
    var guide = instArray[i];

    tempObject[guide] = array[i];
  }

  return tempObject;
};

var transformData = function transformData(object, instructions) {
  for (var key in instructions) {
    if (Array.isArray(object[key])) object[key] = instruct(object[key], instructions[key]);else if (object[key] instanceof Object && !Array.isArray(instructions[key])) object[key] = transformData(object[key], instructions[key]);
  }

  return object;
};

var toArray = function toArray(object, instruction) {
  var tempArray = [];

  for (var i = 0, max = instruction.length; i < max; i++) {
    var guide = instruction[i];

    tempArray[i] = object[guide];
  }

  return tempArray;
};

var minivents_commonjs = function Events(target){
  var events = {}, empty = [];
  target = target || this;
  /**
   *  On: listen to events
   */
  target.on = function(type, func, ctx){
    (events[type] = events[type] || []).push([func, ctx]);
  };
  /**
   *  Off: stop listening to event / specific callback
   */
  target.off = function(type, func){
    type || (events = {});
    var list = events[type] || empty,
        i = list.length = func ? list.length : 0;
    while(i--) func == list[i][0] && list.splice(i,1);
  };
  /** 
   * Emit: send event, callbacks will be triggered
   */
  target.emit = function(type){
    var e = events[type] || empty, list = e.length > 0 ? e.slice(0, e.length) : e, i=0, j;
    while(j=list[i++]) j[0].apply(j[1], empty.slice.call(arguments, 1));
  };
};

var classCallCheck = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

var createClass = function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();





var defineProperty = function (obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
};

var _extends = Object.assign || function (target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i];

    for (var key in source) {
      if (Object.prototype.hasOwnProperty.call(source, key)) {
        target[key] = source[key];
      }
    }
  }

  return target;
};

var get = function get(object, property, receiver) {
  if (object === null) object = Function.prototype;
  var desc = Object.getOwnPropertyDescriptor(object, property);

  if (desc === undefined) {
    var parent = Object.getPrototypeOf(object);

    if (parent === null) {
      return undefined;
    } else {
      return get(parent, property, receiver);
    }
  } else if ("value" in desc) {
    return desc.value;
  } else {
    var getter = desc.get;

    if (getter === undefined) {
      return undefined;
    }

    return getter.call(receiver);
  }
};

var inherits = function (subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
};











var possibleConstructorReturn = function (self, call) {
  if (!self) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return call && (typeof call === "object" || typeof call === "function") ? call : self;
};





var slicedToArray = function () {
  function sliceIterator(arr, i) {
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"]) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  return function (arr, i) {
    if (Array.isArray(arr)) {
      return arr;
    } else if (Symbol.iterator in Object(arr)) {
      return sliceIterator(arr, i);
    } else {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }
  };
}();

var CompositionError = function (_Error) {
  inherits(CompositionError, _Error);

  function CompositionError(classInstance, message, component) {
    classCallCheck(this, CompositionError);

    var _this = possibleConstructorReturn(this, (CompositionError.__proto__ || Object.getPrototypeOf(CompositionError)).call(this, '@' + classInstance + ': ' + message));

    var stackArray = _this.stack.split('\n');
    stackArray.splice(1, 2);

    _this.stack = stackArray.join('\n');

    if (console) console.error('Component:', component);

    _this.name = 'CompositionError';
    return _this;
  }

  return CompositionError;
}(Error);

var DependencyError = function (_Error2) {
  inherits(DependencyError, _Error2);

  function DependencyError(classInstance, message, activeModule) {
    var dependencyModule = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
    classCallCheck(this, DependencyError);

    var _this2 = possibleConstructorReturn(this, (DependencyError.__proto__ || Object.getPrototypeOf(DependencyError)).call(this, '@' + classInstance + ': ' + message));

    var stackArray = _this2.stack.split('\n');
    stackArray.splice(1, 2);

    _this2.stack = stackArray.join('\n');

    if (console) console.error('Active module:', activeModule);
    if (console && dependencyModule) console.error('Dependency published by module:', dependencyModule);

    _this2.name = 'DependencyError';
    return _this2;
  }

  return DependencyError;
}(Error);

var ManagerError = function (_Error3) {
  inherits(ManagerError, _Error3);

  function ManagerError(classInstance, message, component) {
    var activeModule = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
    classCallCheck(this, ManagerError);

    var _this3 = possibleConstructorReturn(this, (ManagerError.__proto__ || Object.getPrototypeOf(ManagerError)).call(this, '@' + classInstance + ': ' + message));

    var stackArray = _this3.stack.split('\n');
    stackArray.splice(1, 2);

    _this3.stack = stackArray.join('\n');

    if (console) console.error('Component:', dependencyModule);
    if (console && activeModule) console.error('Active module:', activeModule);

    _this3.name = 'ManagerError';
    return _this3;
  }

  return ManagerError;
}(Error);

// Check for Three.js
var warnDeps = function warnDeps() {
  throw new Error('WhitestormJS Framework requires Three.js r84. https://threejs.org/');
};

try {
  if (!REVISION) warnDeps();
} catch (err) {
  warnDeps();
}

/**
 * @class ModuleSystem
 * @category core
 * @description  Provides API for classes that will use Modules.<br/>
 * This class includes basic event system with those supported methods:
 * <pre>.on()</pre><pre>.off()</pre><pre>.emit()</pre>
 * @extends Events
 * @memberof module:core
 */

var ModuleSystem = function (_Events) {
  inherits(ModuleSystem, _Events);

  function ModuleSystem() {
    classCallCheck(this, ModuleSystem);
    return possibleConstructorReturn(this, (ModuleSystem.__proto__ || Object.getPrototypeOf(ModuleSystem)).apply(this, arguments));
  }

  createClass(ModuleSystem, [{
    key: 'integrateModules',

    // INTEGRATING

    /**
     * @method integrateModules
     * @instance
     * @description This method applies all modules from .modules collection.
     * @param {Object} [source] If source (should be a component) is provided, will replace .modules with source's one before executing modules.
     * @memberof module:core.ModuleSystem
     */
    value: function integrateModules(source) {
      if (!this.modules) return;
      if (source) this.modules = source.modules.slice(0);

      for (var i = 0, max = this.modules.length; i < max; i++) {
        this.applyModule(this.modules[i], false);
      }if (source) this.applyBridge({ onCopy: source });
    }

    // APPLYING MODULE (...and a "bridge" for module)

    /**
     * @method applyBridge
     * @instance
     * @description Makes component-specific API to work with modules.
     * @param {Object} bridgeMap
     * @return {Object} Returns object with modified values.
     * @memberof module:core.ModuleSystem
     */

  }, {
    key: 'applyBridge',
    value: function applyBridge() {
      var bridgeMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var modules = this.modules;
      if (!modules) return bridgeMap;

      for (var i = 0, max = modules.length; i < max; i++) {
        for (var key in bridgeMap) {
          if (bridgeMap[key]) {
            var module = modules[i];

            if (module && module.bridge && module.bridge[key]) bridgeMap[key] = module.bridge[key].apply(this, [bridgeMap[key], module]);
          }
        }
      }

      return bridgeMap;
    }

    /**
     * @method applyCommand
     * @instance
     * @description .applyCommand runs a method called `name` on all modules.
     * @param {String} name the method name.
     * @param {Function} [cb=(func, moduleScope) => func.apply(this, [moduleScope])] How the function is wrapped/
     * @memberof module:core.ModuleSystem
     */

  }, {
    key: 'applyCommand',
    value: function applyCommand(name) {
      var _this2 = this;

      var cb = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (func, moduleScope) {
        return func.apply(_this2, [moduleScope]);
      };

      var modules = this.modules;
      if (!modules) return;

      for (var i = 0, max = modules.length; i < max; i++) {
        var module = modules[i];
        if (name in module) cb(module[name], module);
      }
    }

    /**
     * @method applyModule
     * @instance
     * @description .applyModule is also used in .integrateModules() function.
     * It does exactly what its name says (applies module to component or app).
     * @param {Object} module the module to apply
     * @param {Boolean} [push=true]
     * @return {Object} Returns module that was applied.
     * @throws {ManagerError}
     * @memberof module:core.ModuleSystem
     */

  }, {
    key: 'applyModule',
    value: function applyModule(module) {
      var push = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      if (!module) return;
      if (push && this.modules) this.modules.push(module);else if (push) this.modules = [module];

      if (this.manager) this.manager.active(module);

      if (module.manager && this.manager) module.manager(this.manager);else if (module.manager) {
        throw new ManagerError('Component', 'Module requires ModuleManager that is turned off for this component', this, module);
      }

      if (module.integrate) module.integrate.bind(this)(module);

      return module;
    }

    /**
     * @method disposeModules
     * @instance
     * @description Disposes of all modules
     * @memberof module:core.ModuleSystem
     */

  }, {
    key: 'disposeModules',
    value: function disposeModules() {
      while (this.modules.length) {
        this.disposeModule(this.modules[0]);
      }
    }

    /**
     * @method disposeModule
     * @instance
     * @description Disposes of the given module
     * @param {Object} module the module to dispose
     * @return {Module} Returns module that was removed.
     * @memberof module:core.ModuleSystem
     */

  }, {
    key: 'disposeModule',
    value: function disposeModule(module) {
      if (!module) return;

      this.modules.splice(this.modules.indexOf(module), 1);

      if (module.dispose) module.dispose.bind(this)(module);

      return module;
    }

    // PIPED METHOD

    /**
     * @method module
     * @instance
     * @description piped version of .applyModule().
     * @param {Object} module the module to apply
     * @return {this} returns this - app/component
     * @throws {ManagerError}
     * @memberof module:core.ModuleSystem
     * @example <caption>Piped modules</caption>
     * component
     *   .module(new Module1())
     *   .module(new Module2())
     *   .module(new Module3())
     */

  }, {
    key: 'module',
    value: function module(_module) {
      this.applyModule(_module);
      return this;
    }
  }]);
  return ModuleSystem;
}(minivents_commonjs);

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

var Symbol$1 = root.Symbol;

var objectProto$1 = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty$1 = objectProto$1.hasOwnProperty;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString = objectProto$1.toString;

/** Built-in value references. */
var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : undefined;

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */
function getRawTag(value) {
  var isOwn = hasOwnProperty$1.call(value, symToStringTag$1),
      tag = value[symToStringTag$1];

  try {
    value[symToStringTag$1] = undefined;
    var unmasked = true;
  } catch (e) {}

  var result = nativeObjectToString.call(value);
  if (unmasked) {
    if (isOwn) {
      value[symToStringTag$1] = tag;
    } else {
      delete value[symToStringTag$1];
    }
  }
  return result;
}

/** Used for built-in method references. */
var objectProto$2 = Object.prototype;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString$1 = objectProto$2.toString;

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */
function objectToString(value) {
  return nativeObjectToString$1.call(value);
}

var nullTag = '[object Null]';
var undefinedTag = '[object Undefined]';

/** Built-in value references. */
var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : undefined;

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
function baseGetTag(value) {
  if (value == null) {
    return value === undefined ? undefinedTag : nullTag;
  }
  return (symToStringTag && symToStringTag in Object(value))
    ? getRawTag(value)
    : objectToString(value);
}

/**
 * Creates a unary function that invokes `func` with its argument transformed.
 *
 * @private
 * @param {Function} func The function to wrap.
 * @param {Function} transform The argument transform.
 * @returns {Function} Returns the new function.
 */
function overArg(func, transform) {
  return function(arg) {
    return func(transform(arg));
  };
}

var getPrototype = overArg(Object.getPrototypeOf, Object);

/**
 * Checks if `value` is object-like. A value is object-like if it's not `null`
 * and has a `typeof` result of "object".
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 * @example
 *
 * _.isObjectLike({});
 * // => true
 *
 * _.isObjectLike([1, 2, 3]);
 * // => true
 *
 * _.isObjectLike(_.noop);
 * // => false
 *
 * _.isObjectLike(null);
 * // => false
 */
function isObjectLike(value) {
  return value != null && typeof value == 'object';
}

var objectTag = '[object Object]';

/** Used for built-in method references. */
var funcProto = Function.prototype;
var objectProto = Object.prototype;

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/** Used to infer the `Object` constructor. */
var objectCtorString = funcToString.call(Object);

/**
 * Checks if `value` is a plain object, that is, an object created by the
 * `Object` constructor or one with a `[[Prototype]]` of `null`.
 *
 * @static
 * @memberOf _
 * @since 0.8.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 * }
 *
 * _.isPlainObject(new Foo);
 * // => false
 *
 * _.isPlainObject([1, 2, 3]);
 * // => false
 *
 * _.isPlainObject({ 'x': 0, 'y': 0 });
 * // => true
 *
 * _.isPlainObject(Object.create(null));
 * // => true
 */
function isPlainObject(value) {
  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
    return false;
  }
  var proto = getPrototype(value);
  if (proto === null) {
    return true;
  }
  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
  return typeof Ctor == 'function' && Ctor instanceof Ctor &&
    funcToString.call(Ctor) == objectCtorString;
}

function symbolObservablePonyfill(root) {
	var result;
	var Symbol = root.Symbol;

	if (typeof Symbol === 'function') {
		if (Symbol.observable) {
			result = Symbol.observable;
		} else {
			result = Symbol('observable');
			Symbol.observable = result;
		}
	} else {
		result = '@@observable';
	}

	return result;
}

/* global window */
var root$2;

if (typeof self !== 'undefined') {
  root$2 = self;
} else if (typeof window !== 'undefined') {
  root$2 = window;
} else if (typeof global !== 'undefined') {
  root$2 = global;
} else if (typeof module !== 'undefined') {
  root$2 = module;
} else {
  root$2 = Function('return this')();
}

var result = symbolObservablePonyfill(root$2);

var ActionTypes = {
  INIT: '@@redux/INIT'

  /**
   * Creates a Redux store that holds the state tree.
   * The only way to change the data in the store is to call `dispatch()` on it.
   *
   * There should only be a single store in your app. To specify how different
   * parts of the state tree respond to actions, you may combine several reducers
   * into a single reducer function by using `combineReducers`.
   *
   * @param {Function} reducer A function that returns the next state tree, given
   * the current state tree and the action to handle.
   *
   * @param {any} [preloadedState] The initial state. You may optionally specify it
   * to hydrate the state from the server in universal apps, or to restore a
   * previously serialized user session.
   * If you use `combineReducers` to produce the root reducer function, this must be
   * an object with the same shape as `combineReducers` keys.
   *
   * @param {Function} [enhancer] The store enhancer. You may optionally specify it
   * to enhance the store with third-party capabilities such as middleware,
   * time travel, persistence, etc. The only store enhancer that ships with Redux
   * is `applyMiddleware()`.
   *
   * @returns {Store} A Redux store that lets you read the state, dispatch actions
   * and subscribe to changes.
   */
};function createStore(reducer, preloadedState, enhancer) {
  var _ref2;

  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
    enhancer = preloadedState;
    preloadedState = undefined;
  }

  if (typeof enhancer !== 'undefined') {
    if (typeof enhancer !== 'function') {
      throw new Error('Expected the enhancer to be a function.');
    }

    return enhancer(createStore)(reducer, preloadedState);
  }

  if (typeof reducer !== 'function') {
    throw new Error('Expected the reducer to be a function.');
  }

  var currentReducer = reducer;
  var currentState = preloadedState;
  var currentListeners = [];
  var nextListeners = currentListeners;
  var isDispatching = false;

  function ensureCanMutateNextListeners() {
    if (nextListeners === currentListeners) {
      nextListeners = currentListeners.slice();
    }
  }

  /**
   * Reads the state tree managed by the store.
   *
   * @returns {any} The current state tree of your application.
   */
  function getState() {
    return currentState;
  }

  /**
   * Adds a change listener. It will be called any time an action is dispatched,
   * and some part of the state tree may potentially have changed. You may then
   * call `getState()` to read the current state tree inside the callback.
   *
   * You may call `dispatch()` from a change listener, with the following
   * caveats:
   *
   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
   * If you subscribe or unsubscribe while the listeners are being invoked, this
   * will not have any effect on the `dispatch()` that is currently in progress.
   * However, the next `dispatch()` call, whether nested or not, will use a more
   * recent snapshot of the subscription list.
   *
   * 2. The listener should not expect to see all state changes, as the state
   * might have been updated multiple times during a nested `dispatch()` before
   * the listener is called. It is, however, guaranteed that all subscribers
   * registered before the `dispatch()` started will be called with the latest
   * state by the time it exits.
   *
   * @param {Function} listener A callback to be invoked on every dispatch.
   * @returns {Function} A function to remove this change listener.
   */
  function subscribe(listener) {
    if (typeof listener !== 'function') {
      throw new Error('Expected listener to be a function.');
    }

    var isSubscribed = true;

    ensureCanMutateNextListeners();
    nextListeners.push(listener);

    return function unsubscribe() {
      if (!isSubscribed) {
        return;
      }

      isSubscribed = false;

      ensureCanMutateNextListeners();
      var index = nextListeners.indexOf(listener);
      nextListeners.splice(index, 1);
    };
  }

  /**
   * Dispatches an action. It is the only way to trigger a state change.
   *
   * The `reducer` function, used to create the store, will be called with the
   * current state tree and the given `action`. Its return value will
   * be considered the **next** state of the tree, and the change listeners
   * will be notified.
   *
   * The base implementation only supports plain object actions. If you want to
   * dispatch a Promise, an Observable, a thunk, or something else, you need to
   * wrap your store creating function into the corresponding middleware. For
   * example, see the documentation for the `redux-thunk` package. Even the
   * middleware will eventually dispatch plain object actions using this method.
   *
   * @param {Object} action A plain object representing “what changed”. It is
   * a good idea to keep actions serializable so you can record and replay user
   * sessions, or use the time travelling `redux-devtools`. An action must have
   * a `type` property which may not be `undefined`. It is a good idea to use
   * string constants for action types.
   *
   * @returns {Object} For convenience, the same action object you dispatched.
   *
   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
   * return something else (for example, a Promise you can await).
   */
  function dispatch(action) {
    if (!isPlainObject(action)) {
      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
    }

    if (typeof action.type === 'undefined') {
      throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
    }

    if (isDispatching) {
      throw new Error('Reducers may not dispatch actions.');
    }

    try {
      isDispatching = true;
      currentState = currentReducer(currentState, action);
    } finally {
      isDispatching = false;
    }

    var listeners = currentListeners = nextListeners;
    for (var i = 0; i < listeners.length; i++) {
      var listener = listeners[i];
      listener();
    }

    return action;
  }

  /**
   * Replaces the reducer currently used by the store to calculate the state.
   *
   * You might need this if your app implements code splitting and you want to
   * load some of the reducers dynamically. You might also need this if you
   * implement a hot reloading mechanism for Redux.
   *
   * @param {Function} nextReducer The reducer for the store to use instead.
   * @returns {void}
   */
  function replaceReducer(nextReducer) {
    if (typeof nextReducer !== 'function') {
      throw new Error('Expected the nextReducer to be a function.');
    }

    currentReducer = nextReducer;
    dispatch({ type: ActionTypes.INIT });
  }

  /**
   * Interoperability point for observable/reactive libraries.
   * @returns {observable} A minimal observable of state changes.
   * For more information, see the observable proposal:
   * https://github.com/tc39/proposal-observable
   */
  function observable() {
    var _ref;

    var outerSubscribe = subscribe;
    return _ref = {
      /**
       * The minimal observable subscription method.
       * @param {Object} observer Any object that can be used as an observer.
       * The observer object should have a `next` method.
       * @returns {subscription} An object with an `unsubscribe` method that can
       * be used to unsubscribe the observable from the store, and prevent further
       * emission of values from the observable.
       */
      subscribe: function subscribe(observer) {
        if (typeof observer !== 'object') {
          throw new TypeError('Expected the observer to be an object.');
        }

        function observeState() {
          if (observer.next) {
            observer.next(getState());
          }
        }

        observeState();
        var unsubscribe = outerSubscribe(observeState);
        return { unsubscribe: unsubscribe };
      }
    }, _ref[result] = function () {
      return this;
    }, _ref;
  }

  // When a store is created, an "INIT" action is dispatched so that every
  // reducer returns their initial state. This effectively populates
  // the initial state tree.
  dispatch({ type: ActionTypes.INIT });

  return _ref2 = {
    dispatch: dispatch,
    subscribe: subscribe,
    getState: getState,
    replaceReducer: replaceReducer
  }, _ref2[result] = observable, _ref2;
}

/**
 * Prints a warning in the console if it exists.
 *
 * @param {String} message The warning message.
 * @returns {void}
 */
function warning(message) {
  /* eslint-disable no-console */
  if (typeof console !== 'undefined' && typeof console.error === 'function') {
    console.error(message);
  }
  /* eslint-enable no-console */
  try {
    // This error was thrown as a convenience so that if you enable
    // "break on all exceptions" in your console,
    // it would pause the execution at this line.
    throw new Error(message);
    /* eslint-disable no-empty */
  } catch (e) {}
  /* eslint-enable no-empty */
}

/**
 * Composes single-argument functions from right to left. The rightmost
 * function can take multiple arguments as it provides the signature for
 * the resulting composite function.
 *
 * @param {...Function} funcs The functions to compose.
 * @returns {Function} A function obtained by composing the argument functions
 * from right to left. For example, compose(f, g, h) is identical to doing
 * (...args) => f(g(h(...args))).
 */

function isCrushed() {}

if ("development" !== 'production' && typeof isCrushed.name === 'string' && isCrushed.name !== 'isCrushed') {
  warning('You are currently using minified code outside of NODE_ENV === \'production\'. ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or DefinePlugin for webpack (http://stackoverflow.com/questions/30030031) ' + 'to ensure you have the correct code for your production build.');
}

var ModuleManager = function () {
  function ModuleManager(object) {
    classCallCheck(this, ModuleManager);

    this.handler = object;
    this.currentModule = null;

    this.store = createStore(function () {
      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [{}, ''];
      var action = arguments[1];

      state[0][action.key] = action.data;
      state[1] = action.key;

      return state;
    });

    this.modules = {};
  }

  /**
   * @method active
   * @instance
   * @description Sets .currentModule to provided module.
   * @param {Object} module the module to make current
   * @memberof module:core.ModuleManager
   */


  createClass(ModuleManager, [{
    key: 'active',
    value: function active(module) {
      this.currentModule = module;
    }

    /**
     * @method reset
     * @instance
     * @description Set's .currentModule to null.
     * @memberof module:core.ModuleManager
     */

  }, {
    key: 'reset',
    value: function reset() {
      this.currentModule = null;
    }

    /**
     * @method define
     * @instance
     * @description Define the module in manager
     * @param name The module name
     * @memberof module:core.ModuleManager
     */

  }, {
    key: 'define',
    value: function define(name) {
      this.modules[name] = this.currentModule;
    }

    /**
     * @method use
     * @instance
     * @description Get the defined module from manager
     * @param name The module name
     * @memberof module:core.ModuleManager
     */

  }, {
    key: 'use',
    value: function use(name) {
      return this.modules[name];
    }

    /**
     * @method set
     * @instance
     * @description An alias for .add() <br/><br/>
     * Use this method if you know that you will overwrite existing dependency.<br/>
     * Use it in your app, but not in module that you provide to other people.
     * @param {String} key the key of the dependency
     * @param {Object} data the value of the dependency
     * @memberof module:core.ModuleManager
     */

  }, {
    key: 'set',
    value: function set$$1(key, data) {
      this.store.dispatch({
        type: 'ADD',
        key: key,
        data: data
      });
    }

    /**
     * @method get
     * @instance
     * @description Returns dependency in store object, by key.
     * @param {String} key the key of the dependency
     * @memberof module:core.ModuleManager
     * @return {Object|Module}
     * @throws {DependencyError} if dependency is not in the store
     * @example <caption>Get the 'hello' dependency</caption>
     * manager.get('hello'); // -> {world: true}
     */

  }, {
    key: 'get',
    value: function get$$1(key) {
      if (!this.store.getState()[0][key]) {
        throw new DependencyError('ModuleManager', 'Module requires \'' + key + '\' dependency', this.currentModule);
      }

      return this.store.getState()[0][key];
    }

    /**
     * @method has
     * @instance
     * @description Returns whether manager has a dependency with the given key
     * @param {String} key the key of the dependency
     * @memberof module:core.ModuleManager
     * @return {Boolean} Promise that is resolved when all promises completed.
     * @example <caption>Check whether the store has the 'hello' dependency</caption>
     * manager.has('hello'); // -> true
     */

  }, {
    key: 'has',
    value: function has(key) {
      return Boolean(this.store.getState()[0][key]);
    }

    /**
     * @method update
     * @instance
     * @description Updates deps
     * @param {Object} [depsMap={}]
     * @memberof module:core.ModuleManager
     */

  }, {
    key: 'update',
    value: function update() {
      var _this = this;

      var depsMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      this.store.subscribe(function () {
        var _store$getState = _this.store.getState(),
            _store$getState2 = slicedToArray(_store$getState, 2),
            data = _store$getState2[0],
            changedKey = _store$getState2[1];

        var callback = depsMap[changedKey];

        if (callback) callback(data[changedKey]);
      });
    }

    /**
     * @method add
     * @alias module:core.ModuleManager#set
     * @memberof module:core.ModuleManager
     */

  }, {
    key: 'add',
    value: function add() {
      console.warn('.add() method is deprecated. Use .set() instead');
      return this.set.apply(this, arguments);
    }

    /**
     * @method require
     * @instance
     * @description Require module
     * @param {String} name Defined name
     * @param {Function} moduleExecutor Function that returns applied module
     * @memberof module:core.ModuleManager
     */

  }, {
    key: 'require',
    value: function require(name, moduleExecutor) {
      if (this.use(name) === undefined) this.handler.applyModule(moduleExecutor());
    }
  }]);
  return ModuleManager;
}();

var _class;
var _temp;

var Component = (_temp = _class = function (_ModuleSystem) {
  inherits(Component, _ModuleSystem);

  // For keeping children components;

  // Collection of promises;

  /**
   * Collection of `modules`.
   * @member {Array} module:core.Component#modules
   * @public
   */


  /**
   * Static instructions
   * @member {Object} module:core.Component#instructions
   * @static
   * @default {}
   */
  function Component() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var defaults$$1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Component.defaults;
    var instructions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Component.instructions;
    classCallCheck(this, Component);

    // Apply polyfilled parameters to .params;
    var _this = possibleConstructorReturn(this, (Component.__proto__ || Object.getPrototypeOf(Component)).call(this));

    _this._wait = [];
    _this.modules = [];
    _this.children = [];
    _this.params = extend(transformData(params, instructions), defaults$$1);
    if (_this.params.manager) _this.manager = new ModuleManager();

    _this.modules = _this.params.modules;

    _this.integrateModules();
    return _this;
  }

  /**
   * @method wait
   * @instance
   * @description Wait for a promise.
   * @param {Promise} [promise] - The promise that should be added to a queue.
   * @return {Promise} Promise that is resolved when all promises completed.
   * @memberof module:core.Component
   */
  // Collection of modules;

  /**
   * Collection of `child` Components.
   * @member {Array} module:core.Component#children
   * @public
   */


  /**
   * Array of promises that should be resolved before Component is ready.
   * @member {Array} module:core.Component#_wait
   * @private
   */

  /**
   * Default values for parameters
   * @member {Object} module:core.Component#defaults
   * @static
   * @default {
   *   modules: [],
   *   manager: true
   * }
   */


  createClass(Component, [{
    key: 'wait',
    value: function wait(promise) {
      if (promise) this._wait.push(promise);
      return Promise.all(this._wait);
    }

    /**
     * @method defer
     * @instance
     * @description Execute `func` (Callback) when Component is ready.
     * @param {Function} func - Callback.
     * @memberof module:core.Component
     */

  }, {
    key: 'defer',
    value: function defer(func) {
      var _this2 = this;

      if (this.isDeffered) this.wait().then(function () {
        return func(_this2);
      });else func(this);
    }

    // PARAMETERS

    /**
     * @method updateParams
     * @instance
     * @description Updates parameters of the Component.
     * @return {Object} Params of this Component
     * @memberof module:core.Component
     */

  }, {
    key: 'updateParams',
    value: function updateParams() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      this.params = extend(params, this.params);
      return this.params;
    }

    // COPYING & CLONING

    /**
     * @method clone
     * @instance
     * @description Clone this component
     * @return {object} a cloned component with all its source component' params copied.
     * @memberof module:core.Component
     */

  }, {
    key: 'clone',
    value: function clone() {
      return new this.constructor(this.params).copy(this);
    }

    /**
     * @method copy
     * @instance
     * @description Copy source native and integrate `modules` to it.
     * @param {Component} source - Source component that is used for `copy()` action.
     * @param {Function} [customize] - Callback executed before modules integration process.
     * @return {this} Component
     * @memberof module:core.Component
     */

  }, {
    key: 'copy',
    value: function copy(source, customize) {
      this.params = _extends({}, source.params);

      if (source.native) this.native = source.native.clone(source.params);
      if (customize) customize();
      this.integrateModules(source);

      return this;
    }

    /**
     * @method add
     * @instance
     * @description Add a child `Component`.
     * @param {Component} object - Component that should be added as a `child`.
     * @return {Promise} Resolved when action is done.
     * @memberof module:core.Component
     */

  }, {
    key: 'add',
    value: function add(object) {
      var _this3 = this;

      object.parent = this;

      return new Promise(function (resolve, reject) {
        _this3.defer(function () {
          var native = object.native;

          if (!native) reject();

          var addPromise = _this3.applyBridge({ onAdd: object }).onAdd;

          var resolver = function resolver() {
            _this3.native.add(native);
            _this3.children.push(object);

            resolve(object);
          };

          if (addPromise instanceof Promise) addPromise.then(resolver);else resolver();
        });
      });
    }

    /**
     * @method remove
     * @instance
     * @description Remove a child `Component`.
     * @param {Component} object - Component that should be a **child** of this Component.
     * @memberof module:core.Component
     */

  }, {
    key: 'remove',
    value: function remove(object) {
      object.parent = null;
      this.native.remove(object.native);
    }

    /**
     * @method addTo
     * @instance
     * @description Adds `this` Component to specified `App`/`Component`.
     * @param {Component} object - Component that will be a parent of `this`.
     * @memberof module:core.Component
     */

  }, {
    key: 'addTo',
    value: function addTo(object) {
      return object.add(this);
    }

    /**
     * Returns whether the object is `async` (`wait` promises are more than `0`).
     * @member {Boolean} module:core.Component#isDeffered
     */

  }, {
    key: 'isDeffered',
    get: function get$$1() {
      return this._wait.length > 0;
    }

    /**
     * Returns the `ModuleManager` used for this component.
     * @member {ModuleManager} module:core.Component#manager
     * @throws {ManagerError}
     */

  }, {
    key: 'manager',
    get: function get$$1() {
      if (this._manager) return this._manager;

      throw new ManagerError('Component', 'ModuleManager is not used in this component. \'manager\' parameter should be set as \'true\'', this);
    },
    set: function set$$1(manager) {
      this._manager = manager;
    }

    /**
     * Returns the `native` object used for this component.
     * @member {Object} module:core.Component#native
     */

  }, {
    key: 'native',
    get: function get$$1() {
      return this._native;
    },
    set: function set$$1(mesh) {
      this._native = mesh;
      this._native.component = this;
      return this._native;
    }
  }]);
  return Component;
}(ModuleSystem), _class.defaults = {
  modules: null,
  manager: true
}, _class.instructions = {}, _temp);

function attributes() {
  for (var _len = arguments.length, mappers = Array(_len), _key = 0; _key < _len; _key++) {
    mappers[_key] = arguments[_key];
  }

  return function (target) {
    for (var i = 0; i < mappers.length; i++) {
      var mapper = mappers[i];

      for (var k = 0; k < mapper.map.length; k++) {
        var attribute = mapper.map[k];

        Object.defineProperty(target.prototype, attribute, {
          get: mapper.getter(attribute),
          set: mapper.setter(attribute),
          configurable: mapper.configurable,
          enumerable: mapper.enumerable
        });
      }
    }
  };
}

function copy() {
  for (var _len2 = arguments.length, map = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    map[_key2] = arguments[_key2];
  }

  return {
    map: map,
    getter: function getter(name) {
      return function () {
        return this.native[name];
      };
    },
    setter: function setter(name) {
      return function (value) {
        this.native[name].copy(value);
      };
    },

    configurable: true,
    enumerable: true
  };
}

function mirror() {
  for (var _len3 = arguments.length, map = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
    map[_key3] = arguments[_key3];
  }

  return {
    map: map,
    getter: function getter(name) {
      return function () {
        return this.native[name];
      };
    },
    setter: function setter(name) {
      return function (value) {
        this.native[name] = value;
      };
    },

    configurable: true,
    enumerable: true
  };
}

var _dec;
var _class$1;
var _class2;
var _temp$1;

var MeshComponent = (_dec = attributes(copy('position', 'rotation', 'quaternion', 'scale'), mirror('material', 'geometry')), _dec(_class$1 = (_temp$1 = _class2 = function (_Component) {
  inherits(MeshComponent, _Component);
  createClass(MeshComponent, null, [{
    key: 'custom',


    // CUSTOM GEOMETRY HANDLING

    /**
     * Default values for parameters
     * @member {Object} module:core.MeshComponent#defaults
     * @static
     * @default
     * {
     *   build: true,
     *   geometry: {},
     *   material: false,
     *
     *   shadow: {
     *     cast: true,
     *     receive: true
     *   },
     *
     *   position: {x: 0, y: 0, z: 0},
     *   rotation: {x: 0, y: 0, z: 0},
     *   scale: {x: 1, y: 1, z: 1}
     * }
     */
    value: function custom(geom) {
      var constructor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Mesh;

      return function (_MeshComponent) {
        inherits(_class3, _MeshComponent);

        function _class3() {
          classCallCheck(this, _class3);
          return possibleConstructorReturn(this, (_class3.__proto__ || Object.getPrototypeOf(_class3)).apply(this, arguments));
        }

        createClass(_class3, [{
          key: 'build',
          value: function build() {
            var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

            var _applyBridge = this.applyBridge({
              geometry: geom,
              material: params.material
            }),
                geometry = _applyBridge.geometry,
                material = _applyBridge.material;

            return this.applyBridge({ mesh: new constructor(geometry, material) }).mesh;
          }
        }]);
        return _class3;
      }(MeshComponent);
    }

    /**
     * Static instructions
     * @member {Object} module:core.MeshComponent#instructions
     * @static
     * @default
     * {
     *   position: ['x', 'y', 'z'],
     *   rotation: ['x', 'y', 'z'],
     *   scale: ['x', 'y', 'z']
     * }
     */

  }, {
    key: 'create',
    value: function create(geom, params, constructor) {
      return new (MeshComponent.custom(geom, constructor))(params);
    }
  }]);

  function MeshComponent(params) {
    var defaults$$1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : MeshComponent.defaults;
    var instructions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : MeshComponent.instructions;
    classCallCheck(this, MeshComponent);

    var _this = possibleConstructorReturn(this, (MeshComponent.__proto__ || Object.getPrototypeOf(MeshComponent)).call(this, params, defaults$$1, instructions));

    if (_this.params.build) {
      var build = _this.build(_this.params);

      if (!build) {
        throw new CompositionError('MeshComponent', '.build() method should return a THREE.Object3D or a Promise resolved with THREE.Object3D.', _this);
      }

      if (build instanceof Promise) {
        _this.wait(build);

        _this.wait(new Promise(function (resolve) {
          build.then(function (native) {
            _this.native = native;
            _this.wrap().then(resolve);
          });
        }));
      } else {
        _this.native = build;
        _this.wait(_this.wrap());
      }
    }

    _this.applyCommand('postIntegrate');
    return _this;
  }

  // BUILDING & WRAPPING

  /**
   * @method build
   * @description Build livecycle should return a native object.
   * @throws {CompositionError}
   * @memberof module:core.MeshComponent
   */


  createClass(MeshComponent, [{
    key: 'build',
    value: function build() {
      throw new CompositionError('MeshComponent', 'Instance should have it\'s own .build().', this);
    }

    /**
     * @method wrap
     * @instance
     * @description Wraps transforms (`position` & `rotation`)
     * @return {Promise} Resolved when action is completed
     * @memberof module:core.MeshComponent
     */

  }, {
    key: 'wrap',
    value: function wrap() {
      var _this3 = this;

      return new Promise(function (resolve) {
        // TODO: Fix defer with physics
        // this.defer(() => {
        var _params = _this3.params,
            position = _params.position,
            rotation = _params.rotation,
            scale = _params.scale,
            shadow = _params.shadow;


        _this3.position.set(position.x, position.y, position.z);
        _this3.rotation.set(rotation.x, rotation.y, rotation.z);
        _this3.scale.set(scale.x, scale.y, scale.z);

        _this3.native.castShadow = shadow.cast;
        _this3.native.receiveShadow = shadow.receive;

        _this3.applyBridge({ onWrap: 1 });

        resolve(_this3);
        // });
      });
    }

    // COPYING & CLONING

    /**
     * @method copy
     * @instance
     * @description Copy source transforms & execute `Component.copy()`
     * @return {this} MeshComponent
     * @memberof module:core.MeshComponent
     */

  }, {
    key: 'copy',
    value: function copy$$1(source) {
      var _this4 = this;

      return get(MeshComponent.prototype.__proto__ || Object.getPrototypeOf(MeshComponent.prototype), 'copy', this).call(this, source, function () {
        _this4.position.copy(source.position);
        _this4.rotation.copy(source.rotation);
        _this4.quaternion.copy(source.quaternion);
      });
    }

    /**
     * @method clone
     * @instance
     * @description Make a clone of this MeshComponent using `.copy()`
     * @return {MeshComponent} clone of this object
     * @memberof module:core.MeshComponent
     */

  }, {
    key: 'clone',
    value: function clone(geometry, material) {
      var dest = new this.constructor({ build: false }).copy(this);

      if (geometry) dest.geometry = dest.geometry.clone();
      if (material) dest.material = dest.material.clone();

      return dest;
    }
  }]);
  return MeshComponent;
}(Component), _class2.defaults = _extends({}, Component.defaults, {

  build: true,
  geometry: {},
  material: false,

  shadow: {
    cast: true,
    receive: true
  },

  position: { x: 0, y: 0, z: 0 },
  rotation: { x: 0, y: 0, z: 0 },
  scale: { x: 1, y: 1, z: 1 }
}), _class2.instructions = {
  position: ['x', 'y', 'z'],
  rotation: ['x', 'y', 'z'],
  scale: ['x', 'y', 'z']
}, _temp$1)) || _class$1);

var _dec$1;
var _class$2;
var _class2$1;
var _temp$2;

var LightComponent = (_dec$1 = attributes(copy('position', 'rotation', 'quaternion', 'target')), _dec$1(_class$2 = (_temp$2 = _class2$1 = function (_Component) {
  inherits(LightComponent, _Component);

  /**
   * Default values for parameters
   * @member {Object} module:core.LightComponent#defaults
   * @static
   * @default
   * {
   *   build: true,
   *
   *   shadow: {
   *     cast: true,
   *
   *     bias: 0,
   *     radius: 1,
   *
   *     mapSize: {
   *       width: 1024,
   *       height: 1024
   *     },
   *
   *     camera: {
   *       near: true,
   *       far: 400,
   *       fov: 90,
   *
   *       top: 200,
   *       bottom: -200,
   *       left: -200,
   *       right: 200
   *     }
   *   },
   *
   *   position: {x: 0, y: 0, z: 0},
   *   rotation: {x: 0, y: 0, z: 0}
   * }
   */
  function LightComponent(params) {
    var defaults$$1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : LightComponent.defaults;
    var instructions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : LightComponent.instructions;
    classCallCheck(this, LightComponent);

    var _this = possibleConstructorReturn(this, (LightComponent.__proto__ || Object.getPrototypeOf(LightComponent)).call(this, params, defaults$$1, instructions));

    if (_this.params.build) {
      var build = _this.build(_this.params);

      if (!build) {
        throw new CompositionError('LightComponent', '.build() method should return a THREE.Object3D or a Promise resolved with THREE.Object3D.', _this);
      }

      if (build instanceof Promise) {
        build.then(function (native) {
          _this.native = native;
        });
      } else _this.native = build;

      _this.wait(_this.wrap());
    }

    _this.applyCommand('postIntegrate');
    return _this;
  }

  // BUILDING & WRAPPING

  /**
   * @method build
   * @instance
   * @description Build livecycle should return a native object.
   * @throws {CompositionError}
   * @memberof module:core.LightComponent
   */


  /**
   * Static instructions
   * @member {Object} module:core.LightComponent#instructions
   * @static
   * @default
   * {
   *   position: ['x', 'y', 'z'],
   *   rotation: ['x', 'y', 'z']
   * }
   */


  createClass(LightComponent, [{
    key: 'build',
    value: function build() {
      throw new CompositionError('MeshComponent', 'Instance should have it\'s own .build().', this);
    }

    /**
     * @method wrap
     * @instance
     * @description Wraps transforms (`position` & `rotation`)
     * @return {Promise} Resolved when action is completed
     * @memberof module:core.LightComponent
     */

  }, {
    key: 'wrap',
    value: function wrap() {
      var _this2 = this;

      return new Promise(function (resolve) {
        _this2.defer(function () {
          var _params = _this2.params,
              position = _params.position,
              rotation = _params.rotation;


          _this2.position.set(position.x, position.y, position.z);
          _this2.rotation.set(rotation.x, rotation.y, rotation.z);

          _this2.applyBridge({ onWrap: 1 });

          resolve(_this2);
        });
      });
    }

    /**
     * @method wrapShadow
     * @instance
     * @description Wraps shadow properties
     * @memberof module:core.LightComponent
     */

  }, {
    key: 'wrapShadow',
    value: function wrapShadow() {
      var native = this.native,
          shadow = this.params.shadow;


      native.castShadow = shadow.cast;
      native.shadow.mapSize.width = shadow.mapSize.width;
      native.shadow.mapSize.height = shadow.mapSize.height;
      native.shadow.bias = shadow.bias;
      native.shadow.radius = shadow.radius;

      var shadowCamera = native.shadow.camera;
      var camera = shadow.camera;

      shadowCamera.near = camera.near;
      shadowCamera.far = camera.far;
      shadowCamera.fov = camera.fov;

      shadowCamera.left = camera.left;
      shadowCamera.right = camera.right;
      shadowCamera.top = camera.top;
      shadowCamera.bottom = camera.bottom;
    }

    // COPYING & CLONING

    /**
     * @method copy
     * @instance
     * @description Copy source transforms & execute `Component.copy()`
     * @return {this} LightComponent
     * @memberof module:core.LightComponent
     */

  }, {
    key: 'copy',
    value: function copy$$1(source) {
      var _this3 = this;

      return get(LightComponent.prototype.__proto__ || Object.getPrototypeOf(LightComponent.prototype), 'copy', this).call(this, source, function () {
        if (_this3.target) _this3.target.copy(source.target());

        _this3.position.copy(source.position);
        _this3.rotation.copy(source.rotation);
        _this3.quaternion.copy(source.quaternion);
      });
    }

    /**
     * @method clone
     * @instance
     * @description Make a clone of this LightComponent using `.copy()`
     * @return {LightComponent} clone of this object
     * @memberof module:core.LightComponent
     */

  }, {
    key: 'clone',
    value: function clone() {
      return new this.constructor({ build: false }).copy(this);
    }
  }]);
  return LightComponent;
}(Component), _class2$1.defaults = _extends({}, Component.defaults, {

  build: true,

  shadow: {
    cast: true,

    bias: 0,
    radius: 1,

    mapSize: {
      width: 1024,
      height: 1024
    },

    camera: {
      near: true,
      far: 400,
      fov: 90,

      top: 200,
      bottom: -200,
      left: -200,
      right: 200
    }
  },

  position: { x: 0, y: 0, z: 0 },
  rotation: { x: 0, y: 0, z: 0 }
}), _class2$1.instructions = {
  position: ['x', 'y', 'z'],
  rotation: ['x', 'y', 'z']
}, _temp$2)) || _class$2);

var _dec$2;
var _class$3;
var _class2$2;
var _temp$3;

var CameraComponent = (_dec$2 = attributes(copy('position', 'rotation', 'quaternion', 'target')), _dec$2(_class$3 = (_temp$3 = _class2$2 = function (_Component) {
  inherits(CameraComponent, _Component);

  /**
   * Default values for parameters
   * @member {Object} module:core.CameraComponent#defaults
   * @static
   * @default
   * {
   *   build: true,
   *
   *   position: {x: 0, y: 0, z: 0},
   *   rotation: {x: 0, y: 0, z: 0}
   * }
   */
  function CameraComponent(params) {
    var defaults$$1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CameraComponent.defaults;
    var instructions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : CameraComponent.instructions;
    classCallCheck(this, CameraComponent);

    var _this = possibleConstructorReturn(this, (CameraComponent.__proto__ || Object.getPrototypeOf(CameraComponent)).call(this, params, defaults$$1, instructions));

    if (_this.params.build) {
      var build = _this.build(_this.params);

      if (!build) {
        throw new CompositionError('CameraComponent', '.build() method should return a THREE.Object3D or a Promise resolved with THREE.Object3D.', _this);
      }

      if (build instanceof Promise) {
        build.then(function (native) {
          _this.native = native;
        });
      } else _this.native = build;

      _this.wait(_this.wrap());
    }

    _this.applyCommand('postIntegrate');
    return _this;
  }

  // BUILDING & WRAPPING

  /**
   * @method build
   * @instance
   * @description Build livecycle should return a native object.
   * @throws {CompositionError}
   * @memberof module:core.CameraComponent
   */


  /**
   * Static instructions
   * @member {Object} module:core.CameraComponent#instructions
   * @static
   * @default
   * {
   *   position: ['x', 'y', 'z'],
   *   rotation: ['x', 'y', 'z'],
   *   scale: ['x', 'y', 'z']
   * }
   */


  createClass(CameraComponent, [{
    key: 'build',
    value: function build() {
      throw new CompositionError('CameraComponent', 'Instance should have it\'s own .build().', this);
    }

    /**
     * @method wrap
     * @instance
     * @description Wraps transforms (`position` & `rotation`)
     * @return {Promise} Resolved when action is completed
     * @memberof module:core.CameraComponent
     */

  }, {
    key: 'wrap',
    value: function wrap() {
      var _this2 = this;

      return new Promise(function (resolve) {
        _this2.defer(function () {
          _this2.position.set(_this2.params.position.x, _this2.params.position.y, _this2.params.position.z);
          _this2.rotation.set(_this2.params.rotation.x, _this2.params.rotation.y, _this2.params.rotation.z);

          _this2.applyBridge({ onWrap: 1 });

          resolve(_this2);
        });
      });
    }

    /**
     * @method copy
     * @instance
     * @description Copy source transforms & execute `Component.copy()`
     * @return {this} CameraComponent
     * @memberof module:core.CameraComponent
     */

  }, {
    key: 'copy',
    value: function copy$$1(source) {
      var _this3 = this;

      return get(CameraComponent.prototype.__proto__ || Object.getPrototypeOf(CameraComponent.prototype), 'copy', this).call(this, source, function () {
        if (_this3.target) _this3.target.copy(source.target());

        _this3.position.copy(source.position);
        _this3.rotation.copy(source.rotation);
        _this3.quaternion.copy(source.quaternion);
      });
    }

    /**
     * @method clone
     * @instance
     * @description Make a clone of this CameraComponent using `.copy()`
     * @return {CameraComponent} clone of this object
     * @memberof module:core.CameraComponent
     */

  }, {
    key: 'clone',
    value: function clone() {
      return new this.constructor({ build: false }).copy(this);
    }
  }]);
  return CameraComponent;
}(Component), _class2$2.defaults = _extends({}, Component.defaults, {

  build: true,

  position: { x: 0, y: 0, z: 0 },
  rotation: { x: 0, y: 0, z: 0 }
}), _class2$2.instructions = {
  position: ['x', 'y', 'z'],
  rotation: ['x', 'y', 'z'],
  scale: ['x', 'y', 'z']
}, _temp$3)) || _class$3);

const version = "2.0.0";

var presentNode = function () {
  var time = process.hrtime();
  return time[0] * 1e3 + time[1] / 1e6;
};

var system = {
  window: typeof window === 'undefined' ? global : window
};

if (typeof global !== 'undefined') {
  global.performance = {
    now: presentNode
  };
}

var App = function (_ModuleSystem) {
  inherits(App, _ModuleSystem);

  /**
   * @description Defines whether the scene should render or not
   * @member {Boolean} module:core.App#updateEnabled
   * @public
   */
  function App() {
    var modules = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    classCallCheck(this, App);

    console.log('WHS.App ' + version);

    var _this = possibleConstructorReturn(this, (App.__proto__ || Object.getPrototypeOf(App)).call(this));

    _this.simulate = false;
    _this.updateEnabled = true;
    _this.loops = [];

    _this.manager = new ModuleManager(_this);
    _this.modules = modules;

    _this.integrateModules();
    return _this;
  }

  // CONTROLS & UPDATING

  /**
   * @method start
   * @description Start rendering loop and physics simulation (if you use version with physics).
   * @memberof module:core.App
   */

  /**
   * Loops in this app
   * @description Array of loops that are executed by this app.
   * @member {Array} module:core.App#loops
   * @public
   */

  /**
   * Simulate flag
   * @description Same as .updateEnabled, but for physics. Defines if physics is simulated each frame.
   * @member {Boolean} module:core.App#simulate
   * @public
   */


  createClass(App, [{
    key: 'start',
    value: function start() {
      var requestAnimFrame = function () {
        return system.window.requestAnimationFrame || system.window.webkitRequestAnimationFrame || system.window.mozRequestAnimationFrame || function (callback) {
          system.window.setTimeout(callback, 1000 / 60);
        };
      }();

      var loops = this.loops,
          updateEnabled = this.updateEnabled;


      function process() {
        requestAnimFrame(process);
        if (!updateEnabled) return;

        for (var i = 0, ll = loops.length; i < ll; i++) {
          var e = loops[i];
          if (e.enabled) e.execute(e.clock);
        }
      }

      this.updateEnabled = true;
      process();
    }

    /**
     * @method stop
     * @description Stops rendering loops
     * @memberof module:core.App
     */

  }, {
    key: 'stop',
    value: function stop() {
      this.updateEnabled = false;
    }

    /**
     * @method addLoop
     * @description Adds loop to this app.
     * @param {Object} loop - the loop to add
     * @return {Promise} Promise that is resolved when promises completed.
     * @memberof module:core.App
     * @example <caption>Adding a loop to an app</caption>
     * const loop = new Loop(() => {
     *  // ...
     * });
     *
     * const app = new App();
     *
     * app.addLoop(loop);
     * loop.start();
     */

  }, {
    key: 'addLoop',
    value: function addLoop(loop) {
      var _this2 = this;

      return new Promise(function (resolve) {
        _this2.loops.push(loop);
        resolve(loop);
      });
    }

    /**
     * @method removeLoop
     * @description Removes loop from this app.
     * @param {Object} loop - the loop to remove
     * @return {Promise} Promise that is resolved when promises completed.
     * @memberof module:core.App
     */

  }, {
    key: 'removeLoop',
    value: function removeLoop(loop) {
      var _this3 = this;

      return new Promise(function (resolve) {
        var index = _this3.loops.indexOf(loop);
        if (index !== -1) _this3.loops.splice(index, 1);

        resolve(loop);
      });
    }
  }, {
    key: 'get',
    value: function get$$1(key) {
      return this.manager.get(key);
    }
  }, {
    key: 'use',
    value: function use(key) {
      return this.manager.use(key);
    }
  }]);
  return App;
}(ModuleSystem);

var Loop = function () {
  function Loop(func) {
    var useClock = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
    classCallCheck(this, Loop);

    this.func = func;
    this.clock = useClock ? new Clock() : null;
    this.enabled = false;
  }

  // CONTROLS

  /**
   * @method start
   * @instance
   * @description Starts this loop, clock if it has one. Won't do anything if loop enabled already.
   * @param {Component} [world] app to add this loop to, if provided.
   * @memberof module:core.Loop
   */


  createClass(Loop, [{
    key: 'start',
    value: function start(world) {
      if (this.enabled) return;

      if (world) world.addLoop(this);

      if (this.clock) this.clock.start();
      this.enabled = true;
    }

    /**
     * @method stop
     * @instance
     * @description Stops this loop and its clock if it has one, won't do anything if this loop is not enabled)
     * @param {Component} [world] app to remove this loop from, if provided.
     * @memberof module:core.Loop
     */

  }, {
    key: 'stop',
    value: function stop(world) {
      if (!this.enabled) return;

      if (this.clock) this.clock.stop();
      this.enabled = false;

      if (world) world.removeLoop(this);
    }

    // EXECUTION

    /**
     * @method execute
     * @instance
     * @description Executes the function of this loop
     * @memberof module:core.Loop
     * @returns {*} whatever the function of this loop returns
     */

  }, {
    key: 'execute',
    value: function execute() {
      return this.func(this.clock);
    }
  }]);
  return Loop;
}();

/** @module core */

var _class$4;
var _temp$4;

var AmbientLight$1 = (_temp$4 = _class$4 = function (_LightComponent) {
  inherits(AmbientLight$$1, _LightComponent);

  function AmbientLight$$1() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, AmbientLight$$1);
    return possibleConstructorReturn(this, (AmbientLight$$1.__proto__ || Object.getPrototypeOf(AmbientLight$$1)).call(this, params, AmbientLight$$1.defaults));
  }

  createClass(AmbientLight$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.applyBridge({ light: new AmbientLight(params.color, params.intensity) }).light;
    }
  }]);
  return AmbientLight$$1;
}(LightComponent), _class$4.defaults = _extends({}, LightComponent.defaults, {

  color: 0xffffff,
  intensity: 1
}), _temp$4);

var _class$5;
var _temp$5;

var DirectionalLight$1 = (_temp$5 = _class$5 = function (_LightComponent) {
  inherits(DirectionalLight$$1, _LightComponent);

  function DirectionalLight$$1() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, DirectionalLight$$1);

    var _this = possibleConstructorReturn(this, (DirectionalLight$$1.__proto__ || Object.getPrototypeOf(DirectionalLight$$1)).call(this, params, DirectionalLight$$1.defaults));

    _this.wrapShadow();
    return _this;
  }

  createClass(DirectionalLight$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.applyBridge({ light: new DirectionalLight(params.color, params.intensity) }).light;
    }
  }]);
  return DirectionalLight$$1;
}(LightComponent), _class$5.defaults = _extends({}, LightComponent.defaults, {

  color: 0xffffff,
  intensity: 1
}), _temp$5);

var _class$6;
var _temp$6;

var HemisphereLight$1 = (_temp$6 = _class$6 = function (_LightComponent) {
  inherits(HemisphereLight$$1, _LightComponent);

  function HemisphereLight$$1() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, HemisphereLight$$1);
    return possibleConstructorReturn(this, (HemisphereLight$$1.__proto__ || Object.getPrototypeOf(HemisphereLight$$1)).call(this, params, HemisphereLight$$1.defaults));
  }

  createClass(HemisphereLight$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.applyBridge({ light: new HemisphereLight(params.skyColor, params.groundColor, params.intensity) }).light;
    }
  }]);
  return HemisphereLight$$1;
}(LightComponent), _class$6.defaults = _extends({}, LightComponent.defaults, {

  skyColor: 0xffffff,
  groundColor: 0xffffff,
  intensity: 1
}), _temp$6);

var _class$7;
var _temp$7;

var PointLight$1 = (_temp$7 = _class$7 = function (_LightComponent) {
  inherits(PointLight$$1, _LightComponent);

  function PointLight$$1() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, PointLight$$1);

    var _this = possibleConstructorReturn(this, (PointLight$$1.__proto__ || Object.getPrototypeOf(PointLight$$1)).call(this, params, PointLight$$1.defaults));

    _this.wrapShadow();
    return _this;
  }

  createClass(PointLight$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.applyBridge({ light: new PointLight(params.color, params.intensity, params.distance, params.decay) }).light;
    }
  }]);
  return PointLight$$1;
}(LightComponent), _class$7.defaults = _extends({}, LightComponent.defaults, {

  color: 0xffffff,
  intensity: 1,
  distance: 100,
  decay: 1
}), _temp$7);

var _class$8;
var _temp$8;

var SpotLight$1 = (_temp$8 = _class$8 = function (_LightComponent) {
  inherits(SpotLight$$1, _LightComponent);

  function SpotLight$$1() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, SpotLight$$1);

    var _this = possibleConstructorReturn(this, (SpotLight$$1.__proto__ || Object.getPrototypeOf(SpotLight$$1)).call(this, params, SpotLight$$1.defaults));

    _this.wrapShadow();
    return _this;
  }

  createClass(SpotLight$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.applyBridge({ light: new SpotLight(params.color, params.intensity, params.distance, params.angle, params.exponent, params.decay) }).light;
    }
  }]);
  return SpotLight$$1;
}(LightComponent), _class$8.defaults = _extends({}, LightComponent.defaults, {

  color: 0xffffff,
  intensity: 1,
  distance: 100,
  angle: Math.PI / 3,
  exponent: 0,
  decay: 1
}), _temp$8);

var _class$9;
var _temp$9;

var AreaLight = (_temp$9 = _class$9 = function (_LightComponent) {
  inherits(AreaLight, _LightComponent);

  function AreaLight() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, AreaLight);
    return possibleConstructorReturn(this, (AreaLight.__proto__ || Object.getPrototypeOf(AreaLight)).call(this, params, AreaLight.defaults));
  }

  createClass(AreaLight, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.applyBridge({ light: new RectAreaLight(params.color, params.intensity, params.width, params.height) }).light;
    }
  }]);
  return AreaLight;
}(LightComponent), _class$9.defaults = _extends({}, LightComponent.defaults, {

  color: 0xffffff,
  intensity: 1,
  width: 10,
  height: 10
}), _temp$9);

/** @module components/lights */

var _class$10;
var _temp$10;

var CubeCamera$1 = (_temp$10 = _class$10 = function (_CameraComponent) {
  inherits(CubeCamera$$1, _CameraComponent);

  function CubeCamera$$1() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, CubeCamera$$1);
    return possibleConstructorReturn(this, (CubeCamera$$1.__proto__ || Object.getPrototypeOf(CubeCamera$$1)).call(this, params, CubeCamera$$1.defaults));
  }

  /**
   * Default values for parameters
   * @member {Object} module:components/cameras.CubeCamera#defaults
   * @static
   * @default <pre>
   * {
   *   camera: {
   *     near: 1,
   *     far: 1000,
   *     cubeResolution: 128
   *   }
   * }</pre>
   */


  createClass(CubeCamera$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.applyBridge({ camera: new CubeCamera(params.near, params.far, params.cubeResolution) }).camera;
    }
  }]);
  return CubeCamera$$1;
}(CameraComponent), _class$10.defaults = _extends({}, CameraComponent.defaults, {

  near: 1,
  far: 1000,
  cubeResolution: 128
}), _temp$10);

var _class$11;
var _temp$11;

var OrthographicCamera$1 = (_temp$11 = _class$11 = function (_CameraComponent) {
  inherits(OrthographicCamera$$1, _CameraComponent);

  function OrthographicCamera$$1() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, OrthographicCamera$$1);
    return possibleConstructorReturn(this, (OrthographicCamera$$1.__proto__ || Object.getPrototypeOf(OrthographicCamera$$1)).call(this, params, OrthographicCamera$$1.defaults));
  }
  /**
   * Default values for parameters
   * @member {Object} module:components/cameras.OrthographicCamera#defaults
   * @static
   * @default <pre>
   * {
   *   near: 1,
   *   far: 1000,
   *   left: system.window.innerWidth / -2,
   *   right: system.window.innerWidth / 2,
   *   top: system.window.innerHeight / 2,
   *   bottom: system.window.innerHeight / -2
   * }</pre>
   */


  createClass(OrthographicCamera$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.applyBridge({ camera: new OrthographicCamera(params.left, params.right, params.top, params.bottom, params.near, params.far) }).camera;
    }
  }]);
  return OrthographicCamera$$1;
}(CameraComponent), _class$11.defaults = _extends({}, CameraComponent.defaults, {

  near: 1,
  far: 1000,
  left: system.window.innerWidth / -2,
  right: system.window.innerWidth / 2,
  top: system.window.innerHeight / 2,
  bottom: system.window.innerHeight / -2
}), _temp$11);

var _class$12;
var _temp$12;

var PerspectiveCamera$1 = (_temp$12 = _class$12 = function (_CameraComponent) {
  inherits(PerspectiveCamera$$1, _CameraComponent);

  function PerspectiveCamera$$1() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, PerspectiveCamera$$1);
    return possibleConstructorReturn(this, (PerspectiveCamera$$1.__proto__ || Object.getPrototypeOf(PerspectiveCamera$$1)).call(this, params, PerspectiveCamera$$1.defaults));
  }
  /**
   * Default values for parameters
   * @member {Object} module:components/cameras.PerspectiveCamera#defaults
   * @static
   * @default <pre>
   * {
   *   near: 1,
   *   far: 1000,
   *   fov: 75,
   *   aspect: system.window.innerWidth / system.window.innerHeight
   * }</pre>
   */


  createClass(PerspectiveCamera$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return this.applyBridge({ camera: new PerspectiveCamera(params.fov, params.aspect, params.near, params.far) }).camera;
    }
  }]);
  return PerspectiveCamera$$1;
}(CameraComponent), _class$12.defaults = _extends({}, CameraComponent.defaults, {

  near: 1,
  far: 1000,
  fov: 75,
  aspect: system.window.innerWidth / system.window.innerHeight
}), _temp$12);

/** @module components/cameras */

var _class$13;
var _temp$13;

var Box = (_temp$13 = _class$13 = function (_MeshComponent) {
  inherits(Box, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Box#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     width: 1,
   *     height: 1,
   *     depth: 1,
   *     widthSegments: 1,
   *     heightSegments: 1,
   *     depthSegments: 1
   *   }
   * }</pre>
   */
  function Box() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Box);
    return possibleConstructorReturn(this, (Box.__proto__ || Object.getPrototypeOf(Box)).call(this, params, Box.defaults, Box.instructions));
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Box
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Box#instructions
   * @static
   * @default geometry: ['width', 'height', 'depth', 'widthSegments', 'heightSegments', 'depthSegements']
   */


  createClass(Box, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var geometry = new (params.buffer ? BoxBufferGeometry : BoxGeometry)(params.geometry.width, params.geometry.height, params.geometry.depth, params.geometry.widthSegments, params.geometry.heightSegments, params.geometry.depthSegments);

      return geometry;
    }
  }]);
  return Box;
}(MeshComponent), _class$13.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    width: 1,
    height: 1,
    depth: 1,
    widthSegments: 1,
    heightSegments: 1,
    depthSegments: 1
  }
}), _class$13.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['width', 'height', 'depth', 'widthSegments', 'heightSegments', 'depthSegements']
}), _temp$13);

var _class$14;
var _temp$14;

var Circle = (_temp$14 = _class$14 = function (_MeshComponent) {
  inherits(Circle, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Circle#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     radius: 50,
   *     segments: 8,
   *     thetaStart: 0,
   *     thetaLength: Math.PI * 2
   *   }
   * }</pre>
   */
  function Circle() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Circle);
    return possibleConstructorReturn(this, (Circle.__proto__ || Object.getPrototypeOf(Circle)).call(this, params, Circle.defaults, Circle.instructions));
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Circle
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Circle#instructions
   * @static
   * @default geometry: ['radius', 'segments', 'thetaStart', 'thetaLength']
   */


  createClass(Circle, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var geometry = new (params.buffer ? CircleBufferGeometry : CircleGeometry)(params.geometry.radius, params.geometry.segments, params.geometry.thetaStart, params.geometry.thetaLength);

      return geometry;
    }
  }]);
  return Circle;
}(MeshComponent), _class$14.defaults = _extends({}, MeshComponent.defaults, {

  geometry: {
    radius: 50,
    segments: 8,
    thetaStart: 0,
    thetaLength: Math.PI * 2
  }
}), _class$14.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['radius', 'segments', 'thetaStart', 'thetaLength']
}), _temp$14);

var _class$15;
var _temp$15;

var Cone = (_temp$15 = _class$15 = function (_MeshComponent) {
  inherits(Cone, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Cone#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     radius: 20,
   *     height: 100,
   *     radiusSegments: 32,
   *     heightSegments: 1,
   *     openEnded: false,
   *     thetaStart: 0,
   *     thetaLength: Math.PI * 2
   *   }
   * }</pre>
   */
  function Cone() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Cone);

    var _this = possibleConstructorReturn(this, (Cone.__proto__ || Object.getPrototypeOf(Cone)).call(this, params, Cone.defaults, Cone.instructions));

    if (params.build) {
      _this.build(params);
      get(Cone.prototype.__proto__ || Object.getPrototypeOf(Cone.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Cone
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Cone#instructions
   * @static
   * @default <pre>
   * geometry: [
   *   'radius',
   *   'height',
   *   'radiusSegments',
   *   'heightSegments',
   *   'openEnded',
   *   'thetaStart',
   *   'thetaLength'
   * ]
   * </pre>
   */


  createClass(Cone, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var geometry = new (params.buffer ? ConeBufferGeometry : ConeGeometry)(params.geometry.radius, params.geometry.height, params.geometry.radiusSegments, params.geometry.heightSegments, params.geometry.openEnded, params.geometry.thetaStart, params.geometry.thetaLength);

      return geometry;
    }
  }]);
  return Cone;
}(MeshComponent), _class$15.defaults = _extends({}, MeshComponent.defaults, {

  geometry: {
    radius: 20,
    height: 100,
    radiusSegments: 32,
    heightSegments: 1,
    openEnded: false,
    thetaStart: 0,
    thetaLength: Math.PI * 2
  }
}), _class$15.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['radius', 'height', 'radiusSegments', 'heightSegments', 'openEnded', 'thetaStart', 'thetaLength']
}), _temp$15);

var _class$16;
var _temp$16;

var Cylinder = (_temp$16 = _class$16 = function (_MeshComponent) {
  inherits(Cylinder, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Cylinder#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     radiusTop: 20,
   *     radiusBottom: 20,
   *     height: 100,
   *     radiusSegments: 32,
   *     heightSegments: 1,
   *     openEnded: false,
   *     thetaStart: 0,
   *     thetaLength: Math.PI * 2
   *   }
   * }</pre>
   */
  function Cylinder() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Cylinder);

    var _this = possibleConstructorReturn(this, (Cylinder.__proto__ || Object.getPrototypeOf(Cylinder)).call(this, params, Cylinder.defaults, Cylinder.instructions));

    if (params.build) {
      _this.build(params);
      get(Cylinder.prototype.__proto__ || Object.getPrototypeOf(Cylinder.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Cylinder
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Cylinder#instructions
   * @static
   * @default <pre>
   * geometry: [
   *   'radiusTop',
   *   'radiusBottom',
   *   'height',
   *   'radiusSegments',
   *   'heightSegments',
   *   'openEnded',
   *   'thetaStart',
   *   'thetaLength'
   * ]
   * </pre>
   */


  createClass(Cylinder, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var geometry = new (params.buffer ? CylinderBufferGeometry : CylinderGeometry)(params.geometry.radiusTop, params.geometry.radiusBottom, params.geometry.height, params.geometry.radiusSegments, params.geometry.heightSegments, params.geometry.openEnded, params.geometry.thetaStart, params.geometry.thetaLength);

      return geometry;
    }
  }]);
  return Cylinder;
}(MeshComponent), _class$16.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    radiusTop: 0,
    radiusBottom: 1,
    height: 1,
    radiusSegments: 32,
    heightSegments: 1,
    openEnded: false,
    thetaStart: 0,
    thetaLength: Math.PI * 2
  }
}), _class$16.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['radiusTop', 'radiusBottom', 'height', 'radiusSegments', 'heightSegments', 'openEnded', 'thetaStart', 'thetaLength']
}), _temp$16);

var _class$17;
var _temp$17;

var Dodecahedron = (_temp$17 = _class$17 = function (_MeshComponent) {
  inherits(Dodecahedron, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Dodecahedron#defaults
   * @static
   * @default <pre>
   * geometry: {
   *   radius: 1,
   *   detail: 0
   * }
   * </pre>
   */
  function Dodecahedron() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Dodecahedron);

    var _this = possibleConstructorReturn(this, (Dodecahedron.__proto__ || Object.getPrototypeOf(Dodecahedron)).call(this, params, Dodecahedron.defaults, Dodecahedron.instructions));

    if (params.build) {
      _this.build(params);
      get(Dodecahedron.prototype.__proto__ || Object.getPrototypeOf(Dodecahedron.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Dodecahedron
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Dodecahedron#instructions
   * @static
   * @default <pre>
   * geometry: ['radius', 'detail']
   * </pre>
   */


  createClass(Dodecahedron, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new (params.buffer ? DodecahedronBufferGeometry : DodecahedronGeometry)(params.geometry.radius, params.geometry.detail);
    }
  }]);
  return Dodecahedron;
}(MeshComponent), _class$17.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    radius: 1,
    detail: 0
  }
}), _class$17.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['radius', 'detail']
}), _temp$17);

var _class$18;
var _temp$18;

var Extrude = (_temp$18 = _class$18 = function (_MeshComponent) {
  inherits(Extrude, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Extrude#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     shapes: [],
   *     options: {}
   *   }
   * }
   * </pre>
   */
  function Extrude() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Extrude);

    var _this = possibleConstructorReturn(this, (Extrude.__proto__ || Object.getPrototypeOf(Extrude)).call(this, params, Extrude.defaults, Extrude.instructions));

    if (params.build) {
      _this.build(params);
      get(Extrude.prototype.__proto__ || Object.getPrototypeOf(Extrude.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Extrude
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Extrude#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: ['shapes', 'options']
   * }
   * </pre>
   */


  createClass(Extrude, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var geometry = new ExtrudeGeometry(params.geometry.shapes, params.geometry.options);

      return params.buffer ? new BufferGeometry().fromGeometry(geometry) : geometry;
    }
  }]);
  return Extrude;
}(MeshComponent), _class$18.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    shapes: [],
    options: {}
  }
}), _class$18.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['shapes', 'options']
}), _temp$18);

var _class$19;
var _temp$19;

var Icosahedron = (_temp$19 = _class$19 = function (_MeshComponent) {
  inherits(Icosahedron, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Icosahedron#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     radius: 1,
   *     detail: 0
   *   }
   * }</pre>
   */
  function Icosahedron() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Icosahedron);

    var _this = possibleConstructorReturn(this, (Icosahedron.__proto__ || Object.getPrototypeOf(Icosahedron)).call(this, params, Icosahedron.defaults, Icosahedron.instructions));

    if (params.build) {
      _this.build(params);
      get(Icosahedron.prototype.__proto__ || Object.getPrototypeOf(Icosahedron.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Icosahedron
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Icosahedron#instructions
   * @static
   * @default {geometry: ['radius', 'detail']}
   */


  createClass(Icosahedron, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new (params.buffer ? IcosahedronBufferGeometry : IcosahedronGeometry)(params.geometry.radius, params.geometry.detail);
    }
  }]);
  return Icosahedron;
}(MeshComponent), _class$19.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    radius: 1,
    detail: 0
  }
}), _class$19.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['radius', 'detail']
}), _temp$19);

var _class$20;
var _temp$20;

var Lathe = (_temp$20 = _class$20 = function (_MeshComponent) {
  inherits(Lathe, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Lathe#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     points: []
   *   }
   * }
   * </pre>
   */
  function Lathe() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Lathe);

    var _this = possibleConstructorReturn(this, (Lathe.__proto__ || Object.getPrototypeOf(Lathe)).call(this, params, Lathe.defaults, Lathe.instructions));

    if (params.build) {
      _this.build(params);
      get(Lathe.prototype.__proto__ || Object.getPrototypeOf(Lathe.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Lathe
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Lathe#instructions
   * @static
   * @default <pre>{
   *   geometry: ['points']
   * }
   * </pre>
   */


  createClass(Lathe, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new (params.buffer ? LatheBufferGeometry : LatheGeometry)(params.geometry.points);
    }
  }]);
  return Lathe;
}(MeshComponent), _class$20.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    points: []
  }
}), _class$20.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['points']
}), _temp$20);

var _class$21;
var _temp$21;

var Line$1 = (_temp$21 = _class$21 = function (_MeshComponent) {
  inherits(Line$$1, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Line#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     curve: new LineCurve3(new Vector3(0, 0, 0), new Vector3(10, 0, 0)),
   *     points: 50
   *   }
   * }
   * </pre>
   */
  function Line$$1(params) {
    classCallCheck(this, Line$$1);
    return possibleConstructorReturn(this, (Line$$1.__proto__ || Object.getPrototypeOf(Line$$1)).call(this, params, Line$$1.defaults, Line$$1.instructions));
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Line
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Line#instructions
   * @static
   * @default <pre>{
   *   geometry: ['curve', 'points']
   * }
   * </pre>
   */


  createClass(Line$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Line(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var geometry = params.buffer ? new BufferGeometry() : new Geometry();

      if (params.buffer) {
        var pp = params.geometry.curve.getPoints(params.geometry.points);
        var verts = new Float32Array(pp.length * 3);

        for (var i = 0, max = pp.length; i < max; i++) {
          var i3 = i * 3;

          verts[i3] = pp[i].x;
          verts[i3 + 1] = pp[i].y;
          verts[i3 + 2] = pp[i].z;
        }

        geometry.addAttribute('position', new BufferAttribute(verts, 3));
      } else geometry.vertices = params.geometry.curve.getPoints(params.geometry.points);

      return geometry;
    }
  }]);
  return Line$$1;
}(MeshComponent), _class$21.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    curve: new LineCurve3(new Vector3(0, 0, 0), new Vector3(10, 0, 0)),
    points: 50
  }
}), _class$21.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['curve', 'points']
}), _temp$21);

var _class$22;
var _temp$22;

var Importer = (_temp$22 = _class$22 = function (_MeshComponent) {
  inherits(Importer, _MeshComponent);
  createClass(Importer, null, [{
    key: 'filter',


    /**
     * @method filter
     * @description Default values for parameters
     * @static
     * @param {THREE.Mesh} object Instance for iterating through it's children.
     * @param {Function} filter Function with child as argument, should return a boolean whether include the child or not.
     * @return {THREE.Mesh} object with children
     * @memberof module:components/meshes.Importer
     * @example <caption>Removing unnecessary lights from children</caption>
     * new Icosahedron({
     *   loader: new THREE.OBJLoader(),
     *
     *   parse(group) { // data from loader
     *     return Importer.filter(group, child => !child.isLight); // remove lights
     *   },
     *
     *   position: [0, 100, 0]
     * }).addTo(app);
     */


    /**
     * Default values for parameters
     * @member {Object} module:components/meshes.Importer#defaults
     * @static
     * @default <pre>
     * {
     *   url: '',
     *   loader: new JSONLoader(),
     *
     *   onLoad() {},
     *   onProgress() {},
     *   onError() {},
     *
     *   texturePath: null,
     *   useCustomMaterial: false,
     *
     *   parser(geometry, materials) {
     *     return new Mesh(geometry, materials);
     *   }
     * }</pre>
     */
    value: function filter(object, _filter) {
      var processFilter = function processFilter(object) {
        object.children.forEach(function (el, index) {
          if (el.children) processFilter(el);
          if (!_filter(el)) object.children.splice(index, 1);
        });

        return object;
      };

      return processFilter(object);
    }
  }]);

  function Importer() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Importer);
    return possibleConstructorReturn(this, (Importer.__proto__ || Object.getPrototypeOf(Importer)).call(this, params, Importer.defaults, Importer.instructions, false));
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Importer
   */


  createClass(Importer, [{
    key: 'build',
    value: function build() {
      var _this2 = this;

      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new Promise(function (resolve) {
        if (params.texturePath) params.laoder.setTexturePath(params.texturePath);

        params.loader.load(params.url, function () {
          // geometry, materials
          params.onLoad.apply(params, arguments);

          var object = _this2.applyBridge({ mesh: params.parser.apply(params, arguments) }).mesh;

          var _applyBridge = _this2.applyBridge({
            geometry: object.geometry,
            material: params.useCustomMaterial ? params.material : object.material
          }),
              geom = _applyBridge.geometry,
              mat = _applyBridge.material;

          if (object.geometry) object.geometry = geom;
          if (object.material) object.material = mat;

          resolve(object);
        }, params.onProgress, params.onError);
      });
    }
  }]);
  return Importer;
}(MeshComponent), _class$22.defaults = _extends({}, MeshComponent.defaults, {

  url: '',
  loader: new JSONLoader(),

  onLoad: function onLoad() {},
  onProgress: function onProgress() {},
  onError: function onError() {},


  texturePath: null,
  useCustomMaterial: false,

  parser: function parser(geometry, materials) {
    return new Mesh(geometry, materials);
  }
}), _class$22.instructions = _extends({}, MeshComponent.instructions), _temp$22);

var _class$23;
var _temp$23;

var Octahedron = (_temp$23 = _class$23 = function (_MeshComponent) {
  inherits(Octahedron, _MeshComponent);

  function Octahedron() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Octahedron);

    var _this = possibleConstructorReturn(this, (Octahedron.__proto__ || Object.getPrototypeOf(Octahedron)).call(this, params, Octahedron.defaults, Octahedron.instructions));

    if (params.build) {
      _this.build(params);
      get(Octahedron.prototype.__proto__ || Object.getPrototypeOf(Octahedron.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Octahedron
   */

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Octahedron#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     radius: 1,
   *     detail: 0
   *   }
   * }
   * </pre>
   */


  createClass(Octahedron, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new (params.buffer ? OctahedronBufferGeometry : OctahedronGeometry)(params.geometry.radius, params.geometry.detail);
    }
  }]);
  return Octahedron;
}(MeshComponent), _class$23.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    radius: 1,
    detail: 0
  }
}), _temp$23);

var _class$24;
var _temp$24;

var Parametric = (_temp$24 = _class$24 = function (_MeshComponent) {
  inherits(Parametric, _MeshComponent);

  function Parametric() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Parametric);
    return possibleConstructorReturn(this, (Parametric.__proto__ || Object.getPrototypeOf(Parametric)).call(this, params, Parametric.defaults, Parametric.instructions));
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Parametric
   */

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Parametric#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     func: (u, v) => new Vector3(u, v, 0),
   *     slices: 10,
   *     tacks: 10
   *   }
   * }
   * </pre>
   */


  createClass(Parametric, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new (params.buffer ? ParametricBufferGeometry : ParametricGeometry)(params.geometry.func, params.geometry.slices, params.geometry.stacks);
    }
  }]);
  return Parametric;
}(MeshComponent), _class$24.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    func: function func(u, v) {
      return new Vector3(u, v, 0);
    },
    slices: 10,
    stacks: 10
  }
}), _temp$24);

var _class$25;
var _temp$25;

var Plane$1 = (_temp$25 = _class$25 = function (_MeshComponent) {
  inherits(Plane$$1, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Plane#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     width: 10,
   *     height: 10,
   *     wSegments: 1,
   *     hSegments: 1
   *   }
   * }
   * </pre>
   */
  function Plane$$1() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Plane$$1);

    var _this = possibleConstructorReturn(this, (Plane$$1.__proto__ || Object.getPrototypeOf(Plane$$1)).call(this, params, Plane$$1.defaults, Plane$$1.instructions));

    if (params.build) {
      _this.build(params);
      get(Plane$$1.prototype.__proto__ || Object.getPrototypeOf(Plane$$1.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Plane
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Plane#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: ['width', 'height', 'wSegments', 'hSegments']
   * }
   * </pre>
   */


  createClass(Plane$$1, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var geometry = new (params.buffer ? PlaneBufferGeometry : PlaneGeometry)(params.geometry.width, params.geometry.height, params.geometry.wSegments, params.geometry.hSegments);

      return geometry;
    }
  }]);
  return Plane$$1;
}(MeshComponent), _class$25.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    width: 10,
    height: 10,
    wSegments: 1,
    hSegments: 1
  }
}), _class$25.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['width', 'height', 'wSegments', 'hSegments']
}), _temp$25);

var _class$26;
var _temp$26;

var verticesOfCube = [-1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1];
var indicesOfFaces = [2, 1, 0, 0, 3, 2, 0, 4, 7, 7, 3, 0, 0, 1, 5, 5, 4, 0, 1, 2, 6, 6, 5, 1, 2, 3, 7, 7, 6, 2, 4, 5, 6, 6, 7, 4];

/**
 * @class Polyhedron
 * @category components/meshes
 * @description In elementary geometry, a polyhedron is a solid in three dimensions with flat polygonal faces, straight edges and sharp corners or vertices.
 * <br/><br/>
 * `Polyhedron` creates a Polyhedron by its `radius` and `detail`.
 * <br/><br/>
 * @param {Object} [params] - The params.
 * @extends module:core.MeshComponent
 * @memberof module:components/meshes
 * @example <caption>Creating an Polyhedron, and adding to app</caption>
 * new Polyhedron({
 *   geometry: {
 *     radius: 2,
 *     detail: 1
 *   },
 *
 *   material: new THREE.MeshBasicMaterial({
 *     color: 0xffffff
 *   }),
 *
 *   position: [0, 100, 0]
 * }).addTo(app);
 */

var Polyhedron = (_temp$26 = _class$26 = function (_MeshComponent) {
  inherits(Polyhedron, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Polyhedron#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     verticesOfCube: [
   *       -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1,
   *       -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1
   *     ],
   *
   *     indicesOfFaces: [
   *       2, 1, 0, 0, 3, 2,
   *       0, 4, 7, 7, 3, 0,
   *       0, 1, 5, 5, 4, 0,
   *       1, 2, 6, 6, 5, 1,
   *       2, 3, 7, 7, 6, 2,
   *       4, 5, 6, 6, 7, 4
   *     ],
   *
   *     radius: 6,
   *     detail: 2
   *   }
   * }
   * </pre>
   */
  function Polyhedron() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Polyhedron);

    var _this = possibleConstructorReturn(this, (Polyhedron.__proto__ || Object.getPrototypeOf(Polyhedron)).call(this, params, Polyhedron.defaults, Polyhedron.instructions));

    if (params.build) {
      _this.build(params);
      get(Polyhedron.prototype.__proto__ || Object.getPrototypeOf(Polyhedron.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Polyhedron
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Polyhedron#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: ['verticesOfCube', 'indicesOfFaces', 'radius', 'detail']
   * }
   * </pre>
   */


  createClass(Polyhedron, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new (params.buffer ? PolyhedronBufferGeometry : PolyhedronGeometry)(params.geometry.verticesOfCube, params.geometry.indicesOfFaces, params.geometry.radius, params.geometry.detail);
    }
  }]);
  return Polyhedron;
}(MeshComponent), _class$26.verticesOfCube = verticesOfCube, _class$26.indicesOfFaces = indicesOfFaces, _class$26.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    verticesOfCube: verticesOfCube,
    indicesOfFaces: indicesOfFaces,
    radius: 6,
    detail: 2
  }
}), _class$26.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['verticesOfCube', 'indicesOfFaces', 'radius', 'detail']
}), _temp$26);

var _class$27;
var _temp$27;

var Ring = (_temp$27 = _class$27 = function (_MeshComponent) {
  inherits(Ring, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Ring#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     innerRadius: 0,
   *     outerRadius: 50,
   *     thetaSegments: 8,
   *     phiSegments: 8,
   *     thetaStart: 0,
   *     thetaLength: Math.PI * 2
   *   }
   * }
   * </pre>
   */
  function Ring() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Ring);

    var _this = possibleConstructorReturn(this, (Ring.__proto__ || Object.getPrototypeOf(Ring)).call(this, params, Ring.defaults, Ring.instructions));

    if (params.build) {
      _this.build(params);
      get(Ring.prototype.__proto__ || Object.getPrototypeOf(Ring.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Ring
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Ring#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: [
   *     'innerRadius',
   *     'outerRadius',
   *     'thetaSegments',
   *     'phiSegments',
   *     'thetaStart',
   *     'thetaLength'
   *   ]
   * }
   * </pre>
   */


  createClass(Ring, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new (params.buffer ? RingBufferGeometry : RingGeometry)(params.geometry.innerRadius, params.geometry.outerRadius, params.geometry.thetaSegments, params.geometry.phiSegments, params.geometry.thetaStart, params.geometry.thetaLength);
    }
  }]);
  return Ring;
}(MeshComponent), _class$27.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    innerRadius: 0,
    outerRadius: 50,
    thetaSegments: 8,
    phiSegments: 8,
    thetaStart: 0,
    thetaLength: Math.PI * 2
  }
}), _class$27.instructions = _extends({}, MeshComponent.defaults, {
  geometry: ['innerRadius', 'outerRadius', 'thetaSegments', 'phiSegments', 'thetaStart', 'thetaLength']
}), _temp$27);

var _class$28;
var _temp$28;

var Shape = (_temp$28 = _class$28 = function (_MeshComponent) {
  inherits(Shape, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Shape#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     shapes: []
   * }
   * </pre>
   */
  function Shape() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Shape);

    var _this = possibleConstructorReturn(this, (Shape.__proto__ || Object.getPrototypeOf(Shape)).call(this, params, Shape.defaults, Shape.instructions));

    if (params.build) {
      _this.build(params);
      get(Shape.prototype.__proto__ || Object.getPrototypeOf(Shape.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Shape
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Shape#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: ['shapes']
   * }
   * </pre>
   */


  createClass(Shape, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new (params.buffer ? ShapeBufferGeometry : ShapeGeometry)(params.geometry.shapes);
    }
  }]);
  return Shape;
}(MeshComponent), _class$28.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    shapes: []
  }
}), _class$28.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['shapes']
}), _temp$28);

var _class$29;
var _temp$29;

var Sphere = (_temp$29 = _class$29 = function (_MeshComponent) {
  inherits(Sphere, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Sphere#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     radius: 1,
   *     widthSegments: 8,
   *     heightSegments: 6
   * }
   * </pre>
   */
  function Sphere() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Sphere);
    return possibleConstructorReturn(this, (Sphere.__proto__ || Object.getPrototypeOf(Sphere)).call(this, params, Sphere.defaults, Sphere.instructions));
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Sphere
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Sphere#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: ['radius', 'widthSegments', 'heightSegments']
   * }
   * </pre>
   */


  createClass(Sphere, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var geometry = new (params.buffer ? SphereBufferGeometry : SphereGeometry)(params.geometry.radius, params.geometry.widthSegments, params.geometry.heightSegments);

      return geometry;
    }
  }]);
  return Sphere;
}(MeshComponent), _class$29.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    radius: 1,
    widthSegments: 8,
    heightSegments: 6
  }
}), _class$29.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['radius', 'widthSegments', 'heightSegments']
}), _temp$29);

var _class$30;
var _temp$30;

var Tetrahedron = (_temp$30 = _class$30 = function (_MeshComponent) {
  inherits(Tetrahedron, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Tetrahedron#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     radius: 1,
   *     detail: 0
   * }
   * </pre>
   */
  function Tetrahedron() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Tetrahedron);

    var _this = possibleConstructorReturn(this, (Tetrahedron.__proto__ || Object.getPrototypeOf(Tetrahedron)).call(this, params, Tetrahedron.defaults, Tetrahedron.instructions));

    if (params.build) {
      _this.build(params);
      get(Tetrahedron.prototype.__proto__ || Object.getPrototypeOf(Tetrahedron.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Tetrahedron
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Tetrahedron#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: ['radius', 'detail']
   * }
   * </pre>
   */


  createClass(Tetrahedron, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new (params.buffer ? TetrahedronBufferGeometry : TetrahedronGeometry)(params.geometry.radius, params.geometry.detail);
    }
  }]);
  return Tetrahedron;
}(MeshComponent), _class$30.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    radius: 1,
    detail: 0
  }
}), _class$30.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['radius', 'detail']
}), _temp$30);

var _class$31;
var _temp$31;

var Text = (_temp$31 = _class$31 = function (_MeshComponent) {
  inherits(Text, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Text#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     text: 'Hello World!',
   *     loader: new FontLoader(),
   *
   *     parameters: {
   *       size: 12,
   *       height: 50,
   *       curveSegments: 12,
   *       font: new Font(),
   *       bevelEnabled: false,
   *       bevelThickness: 10,
   *       bevelSize: 8
   *     }
   *   }
   * }
   * </pre>
   */
  function Text() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Text);

    var _this = possibleConstructorReturn(this, (Text.__proto__ || Object.getPrototypeOf(Text)).call(this, params, Text.defaults, Text.instructions));

    if (params.build) {
      _this.build(params);
      get(Text.prototype.__proto__ || Object.getPrototypeOf(Text.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Text
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Text#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: ['text', 'loader', 'parameters']
   * }
   * </pre>
   */


  createClass(Text, [{
    key: 'build',
    value: function build() {
      var _this2 = this;

      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var promise = new Promise(function (resolve) {
        FontLoader.load(params.geometry.parameters.font, function (font) {
          params.geometry.parameters.font = font;

          var _applyBridge = _this2.applyBridge({
            geometry: new TextGeometry(params.geometry.text, params.geometry.parameters),

            material: params.material
          }),
              geometry = _applyBridge.geometry,
              material = _applyBridge.material;

          resolve(_this2.applyBridge({
            mesh: new Mesh(geometry, material)
          }).mesh);
        });
      });

      get(Text.prototype.__proto__ || Object.getPrototypeOf(Text.prototype), 'wait', this).call(this, promise);

      return promise;
    }
  }]);
  return Text;
}(MeshComponent), _class$31.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    text: 'Hello World!',
    loader: new FontLoader(),

    parameters: {
      size: 12,
      height: 50,
      curveSegments: 12,
      font: new Font(),
      bevelEnabled: false,
      bevelThickness: 10,
      bevelSize: 8
    }
  }
}), _class$31.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['text', 'loader', 'parameters']
}), _temp$31);

var _class$32;
var _temp$32;

var Torus = (_temp$32 = _class$32 = function (_MeshComponent) {
  inherits(Torus, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Torus#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     radius: 100,
   *     tube: 40,
   *     radialSegments: 8,
   *     tubularSegments: 6,
   *     arc: Math.PI * 2
   *   }
   * }
   * </pre>
   */
  function Torus() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Torus);

    var _this = possibleConstructorReturn(this, (Torus.__proto__ || Object.getPrototypeOf(Torus)).call(this, params, Torus.defaults, Torus.instructions));

    if (params.build) {
      _this.build(params);
      get(Torus.prototype.__proto__ || Object.getPrototypeOf(Torus.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Torus
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Torus#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: [
   *     'radius',
   *     'tube',
   *     'radialSegments',
   *     'tubularSegments',
   *     'arc'
   *   ]
   * }
   * </pre>
   */


  createClass(Torus, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      return new TorusGeometry(params.geometry.radius, params.geometry.tube, params.geometry.radialSegments, params.geometry.tubularSegments, params.geometry.arc);
    }
  }]);
  return Torus;
}(MeshComponent), _class$32.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    radius: 100,
    tube: 40,
    radialSegments: 8,
    tubularSegments: 6,
    arc: Math.PI * 2
  }
}), _class$32.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['radius', 'tube', 'radialSegments', 'tubularSegments', 'arc']
}), _temp$32);

var _class$33;
var _temp$33;

var Torusknot = (_temp$33 = _class$33 = function (_MeshComponent) {
  inherits(Torusknot, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Torusknot#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     radius: 100,
   *     tube: 40,
   *     radialSegments: 64,
   *     tubularSegments: 8,
   *     p: 2,
   *     q: 3
   *   }
   * }
   * </pre>
   */
  function Torusknot() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Torusknot);

    var _this = possibleConstructorReturn(this, (Torusknot.__proto__ || Object.getPrototypeOf(Torusknot)).call(this, params, Torusknot.defaults, Torusknot.instructions));

    if (params.build) {
      _this.build(params);
      get(Torusknot.prototype.__proto__ || Object.getPrototypeOf(Torusknot.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Torusknot
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Torusknot#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: [
   *     'radius',
   *     'tube',
   *     'radialSegments',
   *     'tubularSegments',
   *     'p',
   *     'q'
   *   ]
   * }
   * </pre>
   */


  createClass(Torusknot, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var GConstruct = params.buffer ? TorusKnotBufferGeometry : TorusKnotGeometry;

      return new GConstruct(params.geometry.radius, params.geometry.tube, params.geometry.radialSegments, params.geometry.tubularSegments, params.geometry.p, params.geometry.q);
    }
  }]);
  return Torusknot;
}(MeshComponent), _class$33.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    radius: 100,
    tube: 40,
    radialSegments: 64,
    tubularSegments: 8,
    p: 2,
    q: 3
  }
}), _class$33.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['radius', 'tube', 'radialSegments', 'tubularSegments', 'p', 'q']
}), _temp$33);

var _class$34;
var _temp$34;

var Tube = (_temp$34 = _class$34 = function (_MeshComponent) {
  inherits(Tube, _MeshComponent);

  /**
   * Default values for parameters
   * @member {Object} module:components/meshes.Tube#defaults
   * @static
   * @default <pre>
   * {
   *   geometry: {
   *     path: new THREE.LineCurve3(new Vector3(0, 0, 0), new Vector3(0, 0, 1)),
   *     segments: 20,
   *     radius: 2,
   *     radiusSegments: 8,
   *     closed: false
   *   }
   * }
   * </pre>
   */
  function Tube() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, Tube);

    var _this = possibleConstructorReturn(this, (Tube.__proto__ || Object.getPrototypeOf(Tube)).call(this, params, Tube.defaults, Tube.instructions));

    if (params.build) {
      _this.build(params);
      get(Tube.prototype.__proto__ || Object.getPrototypeOf(Tube.prototype), 'wrap', _this).call(_this);
    }
    return _this;
  }

  /**
   * @method build
   * @description Build livecycle creates a mesh using input params.
   * @param {Object} params Component parameters.
   * @return {THREE.Mesh} Built mesh
   * @memberof module:components/meshes.Tube
   */


  /**
   * Instructions
   * @member {Object} module:components/meshes.Tube#instructions
   * @static
   * @default <pre>
   * {
   *   geometry: [
   *     'path',
   *     'segments',
   *     'radius',
   *     'radiusSegments',
   *     'closed'
   *   ]
   * }
   * </pre>
   */


  createClass(Tube, [{
    key: 'build',
    value: function build() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.params;

      var _applyBridge = this.applyBridge({
        geometry: this.buildGeometry(params),
        material: params.material
      }),
          geometry = _applyBridge.geometry,
          material = _applyBridge.material;

      return this.applyBridge({ mesh: new Mesh(geometry, material) }).mesh;
    }
  }, {
    key: 'buildGeometry',
    value: function buildGeometry() {
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var geometry = new (params.buffer ? TubeBufferGeometry : TubeGeometry)(params.geometry.path, params.geometry.segments, params.geometry.radius, params.geometry.radiusSegments, params.geometry.closed);

      return geometry;
    }
  }]);
  return Tube;
}(MeshComponent), _class$34.defaults = _extends({}, MeshComponent.defaults, {
  geometry: {
    path: new LineCurve3(new Vector3(0, 0, 0), new Vector3(0, 0, 1)),
    segments: 20,
    radius: 2,
    radiusSegments: 8,
    closed: false
  }
}), _class$34.instructions = _extends({}, MeshComponent.instructions, {
  geometry: ['path', 'segments', 'radius', 'radiusSegments', 'closed']
}), _temp$34);

var Group = function (_MeshComponent) {
  inherits(Group, _MeshComponent);

  function Group() {
    classCallCheck(this, Group);

    var _this = possibleConstructorReturn(this, (Group.__proto__ || Object.getPrototypeOf(Group)).call(this, {}));

    for (var _len = arguments.length, objects = Array(_len), _key = 0; _key < _len; _key++) {
      objects[_key] = arguments[_key];
    }

    for (var i = 0; i < objects.length; i++) {
      var obj = objects[i];

      if (obj instanceof Component) obj.addTo(_this);else if (obj instanceof Object3D) _this.native.add(obj);
    }
    return _this;
  }

  createClass(Group, [{
    key: 'build',
    value: function build() {
      return new Object3D();
    }
  }]);
  return Group;
}(MeshComponent);

/** @module components/meshes */

/**
 * @class ElementModule
 * @category modules/app
 * @param {Object} [container=document.body] container is the DOM object to which application's canvas will be added to.
 * @memberof module:modules/app
 * @example <caption>Creating an element module, passing it to the App</caption>
 * new App([
 *   new ElementModule(document.getElementById('app'))
 * ]);
 */
var ElementModule = function () {
  function ElementModule() {
    var container = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document.body;
    classCallCheck(this, ElementModule);

    if (container.container) {
      console.warn('ElementModule now accepts only argument which is a DOM object, not a params object.');
      this.container = container.container;
    } else this.container = container;

    this.createElement();
  }

  /**
   * @method createElement
   * @instance
   * @description Creates a canvas element.
   * @memberof module:modules/app.ResizeModule
   */


  createClass(ElementModule, [{
    key: 'createElement',
    value: function createElement() {
      this.element = window.document.createElement('div');

      this.element.className = 'whs-app';
      this.element.style.width = 'inherit';
      this.element.style.height = 'inherit';
      this.element.style.position = 'relative';
    }
  }, {
    key: 'manager',
    value: function manager(_manager) {
      _manager.set('element', this.element);
      _manager.set('container', this.container);
    }
  }, {
    key: 'integrate',
    value: function integrate(self) {
      self.container.appendChild(self.element);
    }
  }]);
  return ElementModule;
}();

var _class$35;
var _temp$35;
var _initialiseProps;

var RenderingModule = (_temp$35 = _class$35 = function () {
  function RenderingModule() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { shadow: false },
        isShadow = _ref.shadow;

    classCallCheck(this, RenderingModule);

    _initialiseProps.call(this);

    this.params = Object.assign({
      width: window.innerWidth,
      height: window.innerHeight,

      resolution: new Vector2(1, 1),
      pixelRatio: window.devicePixelRatio,

      bgColor: 0x000000,
      bgOpacity: 1,

      renderer: {}
    }, params);

    var _params = this.params,
        bgColor = _params.bgColor,
        bgOpacity = _params.bgOpacity,
        renderer = _params.renderer,
        pixelRatio = _params.pixelRatio,
        width = _params.width,
        height = _params.height,
        resolution = _params.resolution;


    this.renderer = new WebGLRenderer(renderer);
    this.effects = [];
    this.applyAdditional('shadow', isShadow);

    this.renderer.setClearColor(bgColor, bgOpacity);

    if (pixelRatio) this.renderer.setPixelRatio(pixelRatio);

    this.setSize(Number(width * resolution.x).toFixed(), Number(height * resolution.y).toFixed());
  }

  createClass(RenderingModule, [{
    key: 'applyAdditional',
    value: function applyAdditional(name) {
      var isApplied = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

      if (!isApplied) return;
      RenderingModule.additional[name].apply(this, [this.renderer]);
    }
  }, {
    key: 'integrateRenderer',
    value: function integrateRenderer(element, scene, camera) {
      var _this = this;

      this.scene = scene;
      this.camera = camera;
      this.renderLoop = new Loop(function () {
        return _this.renderer.render(_this.scene, _this.camera);
      });
      this.attachToCanvas(element);

      return this.renderLoop;
    }
  }, {
    key: 'effect',
    value: function effect(_effect, cb) {
      var _this2 = this;

      this.defer.then(function () {
        _this2.renderLoop.stop();

        var size = _this2.renderer.getSize();
        _effect.setSize(size.width, size.height);

        var loop = new Loop(cb ? cb : function () {
          _effect.render(_this2.scene, _this2.camera);
        });

        _this2.effects.push(loop);
        if (_this2.enabled) loop.start(_this2.app);
      });
    }

    /**
     * @method setSize
     * @description Update render target width and height.
     * @param {Number} width
     * @param {Number} height
     * @memberof module:modules/app.RenderingModule
     */

  }, {
    key: 'setSize',
    value: function setSize(width, height) {
      if (this.renderer) this.renderer.setSize(width, height);
    }
  }, {
    key: 'attachToCanvas',
    value: function attachToCanvas(element) {
      var canvas = this.renderer.domElement;

      // attach to new parent world dom
      element.appendChild(canvas);
      canvas.style.width = '100%';
      canvas.style.height = '100%';
    }
  }, {
    key: 'stop',
    value: function stop() {
      this.enabled = false;
      this.renderLoop.stop();
      this.effects.forEach(function (loop) {
        return loop.stop();
      });
    }
  }, {
    key: 'play',
    value: function play() {
      this.renderLoop.start();
      this.effects.forEach(function (loop) {
        return loop.start();
      });
    }
  }, {
    key: 'manager',
    value: function manager(_manager) {
      var _this3 = this;

      _manager.define('rendering');
      _manager.set('renderer', this.renderer);

      this.app = _manager.handler;

      this.renderLoop = this.integrateRenderer(_manager.get('element'), _manager.get('scene'), _manager.get('camera').native);

      _manager.update({
        element: function element(_element) {
          _this3.attachToCanvas(_element);
        },
        scene: function scene(_scene) {
          _this3.scene = _scene;
        },
        camera: function camera(_camera) {
          _this3.camera = _camera.native;
        }
      });

      this.resolve();
    }
  }, {
    key: 'integrate',
    value: function integrate(self) {
      var _this4 = this;

      self.renderLoop.start(this);
      self.effects.forEach(function (loop) {
        return loop.start(_this4);
      });
    }
  }, {
    key: 'dispose',
    value: function dispose(self) {
      var _this5 = this;

      self.renderLoop.stop(this);
      self.effects.forEach(function (loop) {
        return loop.stop(_this5);
      });
      self.renderer.forceContextLoss();
    }
  }]);
  return RenderingModule;
}(), _class$35.additional = {
  shadow: function shadow(renderer) {
    renderer.shadowMap.enabled = true;
  }
}, _initialiseProps = function _initialiseProps() {
  var _this6 = this;

  this.enabled = true;
  this.defer = new Promise(function (resolve) {
    _this6.resolve = resolve;
  });
}, _temp$35);

var SceneModule = function () {
  function SceneModule() {
    var willSceneBeReplaced = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
    classCallCheck(this, SceneModule);

    this.scene = willSceneBeReplaced ? null : new Scene();
  }

  createClass(SceneModule, [{
    key: 'manager',
    value: function manager(_manager) {
      _manager.set('scene', this.scene);
    }
  }, {
    key: 'integrate',
    value: function integrate(self) {
      this.children = [];

      this.add = function (object) {
        var _this = this;

        object.parent = this;

        return new Promise(function (resolve, reject) {
          object.defer(function () {
            var native = object.native;

            if (!native) reject();

            var addPromise = _this.applyBridge({ onAdd: object }).onAdd;

            var resolver = function resolver() {
              self.scene.add(native);
              _this.children.push(object);

              resolve(object);
            };

            if (addPromise instanceof Promise) addPromise.then(resolver);else resolver();
          });
        });
      };

      this.remove = function (object) {
        object.parent = null;
        self.scene.remove(object.native);
      };

      this.setScene = function (scene) {
        self.scene = scene;
        this.manager.set('scene', scene);
      };
    }
  }]);
  return SceneModule;
}();

// import {addResizeListener} from 'detect-element-resize';

/**
 * @class ResizeModule
 * @category modules/app
 * @param {Object} [params={auto: true}] - If auto is set to true - resize will be triggered when container resizes
 * @memberof module:modules/app
 */
var ResizeModule = function () {
  function ResizeModule() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, ResizeModule);

    this.params = Object.assign({
      auto: true
    }, params);

    this.callbacks = [this.setSize.bind(this)];
  }

  /**
   * @function setSize
   * @instance
   * @description This function sets the provided width & height to the renderer object.
   * @param {Number} [width=1] - The promise that should be added to a queue.
   * @param {Number} [height=1] - that is resolved when all promises completed.
   * @memberof module:modules/app.ResizeModule
   */


  createClass(ResizeModule, [{
    key: 'setSize',
    value: function setSize() {
      var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
      var height = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;

      this.camera.native.aspect = width / height;
      this.camera.native.updateProjectionMatrix();

      if (this.rendering) this.rendering.setSize(width, height);
    }

    /**
     * @method trigger
     * @instance
     * @description Triggers resize when called. width & height are determined automatically
     * This invokes each callbacks with the new width and height as params
     * @memberof module:modules/app.ResizeModule
     */

  }, {
    key: 'trigger',
    value: function trigger() {
      var _container = this.container,
          offsetWidth = _container.offsetWidth,
          offsetHeight = _container.offsetHeight,
          resolution = this.resolution;


      var width = Number(offsetWidth * resolution.x).toFixed();
      var height = Number(offsetHeight * resolution.y).toFixed();

      this.callbacks.forEach(function (cb) {
        cb(width, height);
      });
    }

    /**
     * @method addAutoresize
     * @instance
     * @description Sets module to autoresize, this adds an event listene on window resize to trigger the resize
     * @memberof module:modules/app.ResizeModule
     */

  }, {
    key: 'addAutoresize',
    value: function addAutoresize() {
      this.container = this.getContainer();
      this.resolution = this.getResolution();

      if (this.params.auto) window.addEventListener('resize', this.trigger.bind(this));
    }

    /**
     * @method addCallback
     * @instance
     * @description Adds a call back function to the existing callbacks list.
     * @param {Function} func - The callback function to add
     * @memberof module:modules/app.ResizeModule
     */

  }, {
    key: 'addCallback',
    value: function addCallback(func) {
      this.callbacks.push(func);
    }
  }, {
    key: 'manager',
    value: function manager(_manager) {
      _manager.define('resize');

      this.rendering = _manager.get('renderer');
      this.camera = _manager.get('camera');

      this.getResolution = function () {
        return _manager.use('rendering').params.resolution;
      };
      this.getContainer = function () {
        return _manager.get('container');
      };

      this.addAutoresize();
    }
  }]);
  return ResizeModule;
}();

/**
 * The Kawase blur kernel presets.
 *
 * @type {Float32Array[]}
 * @private
 */

const fragment$5 = "uniform sampler2D tDiffuse;\r\nuniform float opacity;\r\n\r\nvarying vec2 vUv;\r\n\r\nvoid main() {\r\n\r\n\tvec4 texel = texture2D(tDiffuse, vUv);\r\n\tgl_FragColor = opacity * texel;\r\n\r\n}\r\n";
const vertex$5 = "varying vec2 vUv;\r\n\r\nvoid main() {\r\n\r\n\tvUv = uv;\r\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\r\n\r\n}\r\n";

/**
 * A simple copy shader material.
 */

class CopyMaterial extends ShaderMaterial {

	/**
	 * Constructs a new copy material.
	 */

	constructor() {

		super({

			type: "CopyMaterial",

			uniforms: {

				tDiffuse: new Uniform(null),
				opacity: new Uniform(1.0)

			},

			fragmentShader: fragment$5,
			vertexShader: vertex$5,

			depthWrite: false,
			depthTest: false

		});

	}

}

/**
 * A collection of shader materials that are used in the post processing passes.
 *
 * @module postprocessing/materials
 */

class Pass {

	/**
	 * Constructs a new pass.
	 *
	 * @param {Scene} [scene] - The scene to render.
	 * @param {Camera} [camera] - The camera.
	 * @param {Mesh} [quad] - A quad that fills the screen to render 2D filter effects. Set this to null, if you don't need it (see {@link RenderPass}).
	 */

	constructor(
		scene = new Scene(),
		camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1),
		quad = new Mesh(new PlaneBufferGeometry(2, 2), null)
	) {

		/**
		 * The name of this pass.
		 *
		 * @type {String}
		 */

		this.name = "Pass";

		/**
		 * The scene to render.
		 *
		 * @type {Scene}
		 * @protected
		 * @default new Scene()
		 */

		this.scene = scene;

		/**
		 * The camera.
		 *
		 * @type {Camera}
		 * @protected
		 * @default new OrthographicCamera(-1, 1, 1, -1, 0, 1)
		 */

		this.camera = camera;

		/**
		 * A quad mesh that fills the screen.
		 *
		 * Assign your shader material to this mesh!
		 *
		 * @type {Mesh}
		 * @protected
		 * @default new Mesh(new PlaneBufferGeometry(2, 2), null)
		 * @example this.quad.material = this.myMaterial;
		 */

		this.quad = quad;

		if(this.quad !== null) {

			this.quad.frustumCulled = false;

			if(this.scene !== null) {

				this.scene.add(this.quad);

			}

		}

		/**
		 * Indicates whether the read and write buffers should be swapped after this
		 * pass has finished rendering.
		 *
		 * Set this to true if this pass renders to the write buffer so that a
		 * following pass can find the result in the read buffer.
		 *
		 * @type {Boolean}
		 * @default false
		 */

		this.needsSwap = false;

		/**
		 * Enabled flag.
		 *
		 * @type {Boolean}
		 * @default true
		 */

		this.enabled = true;

		/**
		 * Render to screen flag.
		 *
		 * @type {Boolean}
		 * @default false
		 */

		this.renderToScreen = false;

	}

	/**
	 * Renders the effect.
	 *
	 * This is an abstract method that must be overridden.
	 *
	 * @abstract
	 * @throws {Error} An error is thrown if the method is not overridden.
	 * @param {WebGLRenderer} renderer - The renderer.
	 * @param {WebGLRenderTarget} readBuffer - A read buffer. Contains the result of the previous pass.
	 * @param {WebGLRenderTarget} writeBuffer - A write buffer. Normally used as the render target when the read buffer is used as input.
	 * @param {Number} [delta] - The delta time.
	 * @param {Boolean} [maskActive] - Indicates whether a stencil test mask is active or not.
	 */

	render(renderer, readBuffer, writeBuffer, delta, maskActive) {

		throw new Error("Render method not implemented!");

	}

	/**
	 * Updates this pass with the renderer's size.
	 *
	 * You may override this method in case you want to be informed about the main
	 * render size.
	 *
	 * The {@link EffectComposer} calls this method before this pass is
	 * initialised and every time its own size is updated.
	 *
	 * @param {Number} width - The renderer's width.
	 * @param {Number} height - The renderer's height.
	 * @example this.myRenderTarget.setSize(width, height);
	 */

	setSize(width, height) {}

	/**
	 * Performs initialisation tasks.
	 *
	 * By overriding this method you gain access to the renderer. You'll also be
	 * able to configure your custom render targets to use the appropriate format
	 * (RGB or RGBA).
	 *
	 * The provided renderer can be used to warm up special off-screen render
	 * targets by performing a preliminary render operation.
	 *
	 * The {@link EffectComposer} calls this method when this pass is added to its
	 * queue.
	 *
	 * @method initialise
	 * @param {WebGLRenderer} renderer - The renderer.
	 * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.
	 * @example if(!alpha) { this.myRenderTarget.texture.format = RGBFormat; }
	 */

	initialise(renderer, alpha) {}

	/**
	 * Performs a shallow search for properties that define a dispose method and
	 * deletes them. The pass will be inoperative after this method was called!
	 *
	 * Disposable objects:
	 *  - render targets
	 *  - materials
	 *  - textures
	 *
	 * The {@link EffectComposer} calls this method when it is being destroyed.
	 * You may, however, use it independently to free memory when you are certain
	 * that you don't need this pass anymore.
	 */

	dispose() {

		const keys = Object.keys(this);

		let key;

		for(key of keys) {

			if(this[key] !== null && typeof this[key].dispose === "function") {

				this[key].dispose();
				this[key] = null;

			}

		}

	}

}

const color = new Color();

/**
 * A clear pass.
 *
 * You can prevent specific buffers from being cleared by setting either the
 * autoClearColor, autoClearStencil or autoClearDepth properties of the renderer
 * to false.
 */

class ClearPass extends Pass {

	/**
	 * Constructs a new clear pass.
	 *
	 * @param {Object} [options] - Additional options.
	 * @param {Color} [options.clearColor=null] - An override clear color.
	 * @param {Number} [options.clearAlpha=0.0] - An override clear alpha.
	 */

	constructor(options = {}) {

		super(null, null, null);

		/**
		 * The name of this pass.
		 */

		this.name = "ClearPass";

		/**
		 * Clear color.
		 *
		 * @type {Color}
		 * @default null
		 */

		this.clearColor = (options.clearColor !== undefined) ? options.clearColor : null;

		/**
		 * Clear alpha.
		 *
		 * @type {Number}
		 * @default 0.0
		 */

		this.clearAlpha = (options.clearAlpha !== undefined) ? options.clearAlpha : 0.0;

	}

	/**
	 * Clears the read buffer or the screen.
	 *
	 * @param {WebGLRenderer} renderer - The renderer.
	 * @param {WebGLRenderTarget} readBuffer - The read buffer.
	 */

	render(renderer, readBuffer) {

		const clearColor = this.clearColor;

		let clearAlpha;

		if(clearColor !== null) {

			color.copy(renderer.getClearColor());
			clearAlpha = renderer.getClearAlpha();
			renderer.setClearColor(clearColor, this.clearAlpha);

		}

		renderer.setRenderTarget(this.renderToScreen ? null : readBuffer);
		renderer.clear();

		if(clearColor !== null) {

			renderer.setClearColor(color, clearAlpha);

		}

	}

}

class ClearMaskPass extends Pass {

	/**
	 * Constructs a new clear mask pass.
	 */

	constructor() {

		super(null, null, null);

		/**
		 * The name of this pass.
		 */

		this.name = "ClearMaskPass";

	}

	/**
	 * Disables the stencil test.
	 *
	 * @param {WebGLRenderer} renderer - The renderer.
	 */

	render(renderer) {

		renderer.state.buffers.stencil.setTest(false);

	}

}

function randomInt(low, high) {

	return low + Math.floor(Math.random() * (high - low + 1));

}

/**
 * Returns a random float in the specified range.
 *
 * @private
 * @static
 * @param {Number} low - The lowest possible value.
 * @param {Number} high - The highest possible value.
 * @return {Number} The random value.
 */

function randomFloat(low, high) {

	return low + Math.random() * (high - low);

}

/**
 * A glitch pass.
 */



/**
 * A glitch mode enumeration.
 *
 * @type {Object}
 * @property {Number} SPORADIC - Sporadic glitches.
 * @property {Number} CONSTANT_MILD - Constant mild glitches.
 * @property {Number} CONSTANT_WILD - Constant wild glitches.
 */

const GlitchMode = {

	SPORADIC: 0,
	CONSTANT_MILD: 1,
	CONSTANT_WILD: 2

};

class RenderPass extends Pass {

	/**
	 * Constructs a new render pass.
	 *
	 * @param {Scene} scene - The scene to render.
	 * @param {Camera} camera - The camera to use to render the scene.
	 * @param {Object} [options] - Additional options.
	 * @param {Material} [options.overrideMaterial=null] - An override material for the scene.
	 * @param {Color} [options.clearColor=null] - An override clear color.
	 * @param {Number} [options.clearAlpha=1.0] - An override clear alpha.
	 * @param {Boolean} [options.clearDepth=false] - Whether depth should be cleared explicitly.
	 * @param {Boolean} [options.clear=true] - Whether all buffers should be cleared.
	 */

	constructor(scene, camera, options = {}) {

		super(scene, camera, null);

		/**
		 * The name of this pass.
		 */

		this.name = "RenderPass";

		/**
		 * A clear pass.
		 *
		 * @type {ClearPass}
		 */

		this.clearPass = new ClearPass(options);

		/**
		 * An override material.
		 *
		 * @type {Material}
		 * @default null
		 */

		this.overrideMaterial = (options.overrideMaterial !== undefined) ? options.overrideMaterial : null;

		/**
		 * Indicates whether the depth buffer should be cleared explicitly.
		 *
		 * @type {Boolean}
		 * @default false
		 */

		this.clearDepth = (options.clearDepth !== undefined) ? options.clearDepth : false;

		/**
		 * Indicates whether the color, depth and stencil buffers should be cleared.
		 *
		 * Even with clear set to true you can prevent specific buffers from being
		 * cleared by setting either the autoClearColor, autoClearStencil or
		 * autoClearDepth properties of the renderer to false.
		 *
		 * @type {Boolean}
		 * @default true
		 */

		this.clear = (options.clear !== undefined) ? options.clear : true;

	}

	/**
	 * Renders the scene.
	 *
	 * @param {WebGLRenderer} renderer - The renderer.
	 * @param {WebGLRenderTarget} readBuffer - The read buffer.
	 */

	render(renderer, readBuffer) {

		const scene = this.scene;
		const target = this.renderToScreen ? null : readBuffer;

		if(this.clear) {

			this.clearPass.render(renderer, target);

		} else if(this.clearDepth) {

			renderer.setRenderTarget(target);
			renderer.clearDepth();

		}

		scene.overrideMaterial = this.overrideMaterial;
		renderer.render(scene, this.camera, target);
		scene.overrideMaterial = null;

	}

}

class MaskPass extends Pass {

	/**
	 * Constructs a new mask pass.
	 *
	 * @param {Scene} scene - The scene to render.
	 * @param {Camera} camera - The camera to use.
	 */

	constructor(scene, camera) {

		super(scene, camera, null);

		/**
		 * The name of this pass.
		 */

		this.name = "MaskPass";

		/**
		 * Inverse flag.
		 *
		 * @type {Boolean}
		 * @default false
		 */

		this.inverse = false;

		/**
		 * Stencil buffer clear flag.
		 *
		 * @type {Boolean}
		 * @default true
		 */

		this.clearStencil = true;

	}

	/**
	 * Creates a stencil bit mask.
	 *
	 * @param {WebGLRenderer} renderer - The renderer.
	 * @param {WebGLRenderTarget} readBuffer - The read buffer.
	 * @param {WebGLRenderTarget} writeBuffer - The write buffer.
	 */

	render(renderer, readBuffer, writeBuffer) {

		const context = renderer.context;
		const state = renderer.state;

		const scene = this.scene;
		const camera = this.camera;

		const writeValue = this.inverse ? 0 : 1;
		const clearValue = 1 - writeValue;

		// Don't update color or depth.
		state.buffers.color.setMask(false);
		state.buffers.depth.setMask(false);

		// Lock the buffers.
		state.buffers.color.setLocked(true);
		state.buffers.depth.setLocked(true);

		// Configure the stencil.
		state.buffers.stencil.setTest(true);
		state.buffers.stencil.setOp(context.REPLACE, context.REPLACE, context.REPLACE);
		state.buffers.stencil.setFunc(context.ALWAYS, writeValue, 0xffffffff);
		state.buffers.stencil.setClear(clearValue);

		// Clear the stencil.
		if(this.clearStencil) {

			renderer.setRenderTarget(readBuffer);
			renderer.clearStencil();

			renderer.setRenderTarget(writeBuffer);
			renderer.clearStencil();

		}

		// Draw the mask into both buffers.
		renderer.render(scene, camera, readBuffer);
		renderer.render(scene, camera, writeBuffer);

		// Unlock the buffers.
		state.buffers.color.setLocked(false);
		state.buffers.depth.setLocked(false);

		// Only render where the stencil is set to 1.
		state.buffers.stencil.setFunc(context.EQUAL, 1, 0xffffffff);
		state.buffers.stencil.setOp(context.KEEP, context.KEEP, context.KEEP);

	}

}

class ShaderPass extends Pass {

	/**
	 * Constructs a new shader pass.
	 *
	 * @param {ShaderMaterial} material - The shader material to use.
	 * @param {String} [textureID="tDiffuse"] - The texture uniform identifier.
	 */

	constructor(material, textureID = "tDiffuse") {

		super();

		/**
		 * The name of this pass.
		 */

		this.name = "ShaderPass";

		/**
		 * This pass renders to the write buffer.
		 */

		this.needsSwap = true;

		/**
		 * The shader material to use for rendering.
		 *
		 * @type {ShaderMaterial}
		 */

		this.material = material;

		this.quad.material = this.material;

		/**
		 * The name of the color sampler uniform of the given material.
		 *
		 * @type {String}
		 * @default "tDiffuse"
		 */

		this.textureID = textureID;

	}

	/**
	 * Renders the effect.
	 *
	 * @param {WebGLRenderer} renderer - The renderer.
	 * @param {WebGLRenderTarget} readBuffer - The read buffer.
	 * @param {WebGLRenderTarget} writeBuffer - The write buffer.
	 */

	render(renderer, readBuffer, writeBuffer) {

		if(this.material.uniforms[this.textureID] !== undefined) {

			this.material.uniforms[this.textureID].value = readBuffer.texture;

		}

		renderer.render(this.scene, this.camera, this.renderToScreen ? null : writeBuffer);

	}

}

const v = new Vector3();

/**
 * A vector.
 *
 * @type {Vector3}
 * @private
 * @static
 * @final
 */

const ab = new Vector3();

/**
 * A shock wave pass.
 */

/**
 * A compilation of the post processing passes.
 *
 * @module postprocessing/passes
 */

class EffectComposer {

	/**
	 * Constructs a new effect composer.
	 *
	 * @param {WebGLRenderer} [renderer] - The renderer that should be used.
	 * @param {Object} [options] - The options.
	 * @param {Boolean} [options.depthBuffer=true] - Whether the main render targets should have a depth buffer.
	 * @param {Boolean} [options.stencilBuffer=false] - Whether the main render targets should have a stencil buffer.
	 * @param {Boolean} [options.depthTexture=false] - Set to true if one of your passes relies on a depth texture.
	 */

	constructor(renderer = null, options = {}) {

		/**
		 * The renderer.
		 *
		 * You may replace the renderer at any time by using
		 * {@link EffectComposer#replaceRenderer}.
		 *
		 * @type {WebGLRenderer}
		 */

		this.renderer = renderer;

		/**
		 * The read buffer.
		 *
		 * Reading from and writing to the same render target should be avoided.
		 * Therefore, two seperate yet identical buffers are used.
		 *
		 * @type {WebGLRenderTarget}
		 * @private
		 */

		this.readBuffer = null;

		/**
		 * The write buffer.
		 *
		 * @type {WebGLRenderTarget}
		 * @private
		 */

		this.writeBuffer = null;

		if(this.renderer !== null) {

			this.renderer.autoClear = false;

			this.readBuffer = this.createBuffer(
				(options.depthBuffer !== undefined) ? options.depthBuffer : true,
				(options.stencilBuffer !== undefined) ? options.stencilBuffer : false,
				(options.depthTexture !== undefined) ? options.depthTexture : false
			);

			this.writeBuffer = this.readBuffer.clone();

		}

		/**
		 * A copy pass used for copying masked scenes.
		 *
		 * @type {ShaderPass}
		 * @private
		 */

		this.copyPass = new ShaderPass(new CopyMaterial());

		/**
		 * The passes.
		 *
		 * @type {Pass[]}
		 * @private
		 */

		this.passes = [];

	}

	/**
	 * The depth texture of the read and write buffers.
	 *
	 * @type {DepthTexture}
	 * @default null
	 */

	get depthTexture() { return this.readBuffer.depthTexture; }

	/**
	 * The read and write buffers share a single depth texture. Depth will be
	 * written to this texture when something is rendered into one of the buffers
	 * and the involved materials have depth write enabled.
	 *
	 * You may enable this mechanism during the instantiation of the composer or
	 * by assigning a DepthTexture instance later on. You may also disable it by
	 * assigning null.
	 *
	 * @type {DepthTexture}
	 */

	set depthTexture(x) {

		this.readBuffer.depthTexture = x;
		this.writeBuffer.depthTexture = x;

	}

	/**
	 * Replaces the current renderer with the given one. The DOM element of the
	 * current renderer will automatically be removed from its parent node and the
	 * DOM element of the new renderer will take its place.
	 *
	 * The auto clear mechanism of the provided renderer will be disabled.
	 *
	 * Switching between renderers allows you to dynamically enable or disable
	 * antialiasing.
	 *
	 * @param {WebGLRenderer} renderer - The new renderer.
	 * @return {WebGLRenderer} The old renderer.
	 */

	replaceRenderer(renderer) {

		const oldRenderer = this.renderer;

		let parent, oldSize, newSize;

		if(oldRenderer !== null && oldRenderer !== renderer) {

			this.renderer = renderer;
			this.renderer.autoClear = false;

			parent = oldRenderer.domElement.parentNode;
			oldSize = oldRenderer.getSize();
			newSize = renderer.getSize();

			if(parent !== null) {

				parent.removeChild(oldRenderer.domElement);
				parent.appendChild(renderer.domElement);

			}

			if(oldSize.width !== newSize.width || oldSize.height !== newSize.height) {

				this.setSize();

			}

		}

		return oldRenderer;

	}

	/**
	 * Creates a new render target by replicating the renderer's canvas.
	 *
	 * The created render target uses a linear filter for texel minification and
	 * magnification. Its render texture format depends on whether the renderer
	 * uses the alpha channel. Mipmaps are disabled.
	 *
	 * @param {Boolean} depthBuffer - Whether the render target should have a depth buffer.
	 * @param {Boolean} stencilBuffer - Whether the render target should have a stencil buffer.
	 * @param {Boolean} depthTexture - Whether the render target should have a depth texture.
	 * @return {WebGLRenderTarget} A new render target that equals the renderer's canvas.
	 */

	createBuffer(depthBuffer, stencilBuffer, depthTexture) {

		const size = this.renderer.getSize();
		const pixelRatio = this.renderer.getPixelRatio();
		const alpha = this.renderer.context.getContextAttributes().alpha;

		const renderTarget = new WebGLRenderTarget(size.width * pixelRatio, size.height * pixelRatio, {
			minFilter: LinearFilter,
			magFilter: LinearFilter,
			format: alpha ? RGBAFormat : RGBFormat,
			depthBuffer: depthBuffer,
			stencilBuffer: stencilBuffer,
			depthTexture: depthTexture ? new DepthTexture() : null
		});

		if(depthTexture && stencilBuffer) {

			renderTarget.depthTexture.format = DepthStencilFormat;
			renderTarget.depthTexture.type = UnsignedInt248Type;

		}

		renderTarget.texture.name = "EffectComposer.Buffer";
		renderTarget.texture.generateMipmaps = false;

		return renderTarget;

	}

	/**
	 * Adds a pass, optionally at a specific index.
	 *
	 * @param {Pass} pass - A new pass.
	 * @param {Number} [index] - An index at which the pass should be inserted.
	 */

	addPass(pass, index) {

		const renderer = this.renderer;
		const size = renderer.getSize();
		const pixelRatio = renderer.getPixelRatio();

		pass.setSize(size.width * pixelRatio, size.height * pixelRatio);
		pass.initialise(renderer, renderer.context.getContextAttributes().alpha);

		if(index !== undefined) {

			this.passes.splice(index, 0, pass);

		} else {

			this.passes.push(pass);

		}

	}

	/**
	 * Removes a pass.
	 *
	 * @param {Pass} pass - The pass.
	 */

	removePass(pass) {

		this.passes.splice(this.passes.indexOf(pass), 1);

	}

	/**
	 * Renders all enabled passes in the order in which they were added.
	 *
	 * @param {Number} delta - The time between the last frame and the current one in seconds.
	 */

	render(delta) {

		const passes = this.passes;
		const renderer = this.renderer;
		const copyPass = this.copyPass;

		let readBuffer = this.readBuffer;
		let writeBuffer = this.writeBuffer;

		let maskActive = false;
		let pass, context, buffer;
		let i, l;

		for(i = 0, l = passes.length; i < l; ++i) {

			pass = passes[i];

			if(pass.enabled) {

				pass.render(renderer, readBuffer, writeBuffer, delta, maskActive);

				if(pass.needsSwap) {

					if(maskActive) {

						context = renderer.context;
						context.stencilFunc(context.NOTEQUAL, 1, 0xffffffff);
						copyPass.render(renderer, readBuffer, writeBuffer);
						context.stencilFunc(context.EQUAL, 1, 0xffffffff);

					}

					buffer = readBuffer;
					readBuffer = writeBuffer;
					writeBuffer = buffer;

				}

				if(pass instanceof MaskPass) {

					maskActive = true;

				} else if(pass instanceof ClearMaskPass) {

					maskActive = false;

				}

			}

		}

	}

	/**
	 * Sets the size of the buffers and the renderer's output canvas.
	 *
	 * Every pass will be informed of the new size. It's up to each pass how that
	 * information is used.
	 *
	 * If no width or height is specified, the render targets and passes will be
	 * updated with the current size of the renderer.
	 *
	 * @param {Number} [width] - The width.
	 * @param {Number} [height] - The height.
	 */

	setSize(width, height) {

		const passes = this.passes;
		const size = this.renderer.getSize();
		const pixelRatio = this.renderer.getPixelRatio();

		let i, l;

		if(width === undefined || height === undefined) {

			width = size.width;
			height = size.height;

		}

		this.renderer.setSize(width, height);

		width *= pixelRatio;
		height *= pixelRatio;

		this.readBuffer.setSize(width, height);
		this.writeBuffer.setSize(width, height);

		for(i = 0, l = passes.length; i < l; ++i) {

			passes[i].setSize(width, height);

		}

	}

	/**
	 * Resets this composer by deleting all passes and creating new buffers.
	 *
	 * @param {WebGLRenderTarget} [renderTarget] - A new render target. If none is provided, the settings of the renderer will be used.
	 */

	reset(renderTarget) {

		const depthBuffer = this.readBuffer.depthBuffer;
		const stencilBuffer = this.readBuffer.stencilBuffer;
		const depthTexture = (this.readBuffer.depthTexture !== null);

		this.dispose((renderTarget === undefined) ?
			this.createBuffer(depthBuffer, stencilBuffer, depthTexture) :
			renderTarget
		);

	}

	/**
	 * Destroys all passes and render targets.
	 *
	 * This method deallocates all render targets, textures and materials created
	 * by the passes. It also deletes this composer's frame buffers.
	 *
	 * @param {WebGLRenderTarget} [renderTarget] - A new render target. If none is provided, the composer will become inoperative.
	 */

	dispose(renderTarget) {

		const passes = this.passes;

		if(this.readBuffer !== null && this.writeBuffer !== null) {

			this.readBuffer.dispose();
			this.writeBuffer.dispose();

			this.readBuffer = null;
			this.writeBuffer = null;

		}

		while(passes.length > 0) {

			passes.pop().dispose();

		}

		if(renderTarget !== undefined) {

			// Reanimate.
			this.readBuffer = renderTarget;
			this.writeBuffer = this.readBuffer.clone();

		} else {

			this.copyPass.dispose();

		}

	}

}

/**
 * Core components.
 *
 * @module postprocessing/core
 */

/**
 * Exposure of the library components.
 *
 * @module postprocessing
 */

var polyfill = function polyfill(object, method) {
  var showWarn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;

  if (object[method]) return;
  if (showWarn) console.warn('@PostProcessorModule: pass.' + method + '() was not found.', object);
  object[method] = function () {};
};

var PostProcessorModule = function () {
  function PostProcessorModule() {
    var _this = this;

    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { debug: true },
        debug = _ref.debug;

    classCallCheck(this, PostProcessorModule);
    this.currentPass = null;
    this.defer = new Promise(function (resolve) {
      _this.resolve = resolve;
    });

    this.debug = debug;
  }

  createClass(PostProcessorModule, [{
    key: 'manager',
    value: function manager(_manager) {
      var _this2 = this;

      _manager.define('postprocessor');

      this.effects = _manager.use('rendering').effects;
      this.renderer = _manager.get('renderer');
      this.scene = _manager.get('scene');
      this.camera = _manager.get('camera');

      this.composer = new EffectComposer(this.renderer);

      _manager.use('rendering').stop();

      var composer = this.composer;
      this.renderLoop = new Loop(function (clock) {
        return composer.render(clock.getDelta());
      }).start(_manager.handler);

      _manager.update({
        renderer: function renderer(_renderer) {
          _this2.composer.replaceRenderer(_renderer);
        },

        scene: function scene(_scene) {
          _this2.scene = _scene;
        },

        camera: function camera(_camera) {
          _this2.camera = _camera;
        }
      });

      this.resolve();
    }
  }, {
    key: 'render',
    value: function render() {
      var _this3 = this;

      this.defer.then(function () {
        var pass = new RenderPass(_this3.scene, _this3.camera.native);

        // TODO: Support for effects.

        _this3.composer.addPass(pass);
        _this3.currentPass = pass;
      });

      return this;
    }

    // API

  }, {
    key: 'pass',
    value: function pass(_pass) {
      var _this4 = this;

      this.defer.then(function () {
        polyfill(_pass, 'setSize', _this4.debug);
        polyfill(_pass, 'initialise', _this4.debug);

        _this4.composer.addPass(_pass);
        _this4.currentPass = _pass;
      });

      return this;
    }
  }, {
    key: 'shader',
    value: function shader(material) {
      var _this5 = this;

      var textureID = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'readBuffer';

      this.defer.then(function () {
        if (!material.uniforms[textureID]) material.uniforms[textureID] = { value: null };

        var pass = new ShaderPass(material, textureID);
        _this5.composer.addPass(pass);
        _this5.currentPass = pass;
      });

      return this;
    }

    // Pass API

  }, {
    key: 'get',
    value: function get$$1(name) {
      return name ? this.composer.passes.filter(function (pass) {
        return pass.name === name;
      })[0] : this.currentPass;
    }
  }, {
    key: 'to',
    value: function to(name) {
      this.currentPass = name;
    }
  }, {
    key: 'renderToScreen',
    value: function renderToScreen() {
      var _this6 = this;

      var bool = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

      this.defer.then(function () {
        _this6.currentPass.renderToScreen = bool;
      });

      return this;
    }
  }, {
    key: 'name',
    value: function name(_name) {
      var _this7 = this;

      this.defer.then(function () {
        _this7.currentPass.name = _name;
      });

      return this;
    }
  }]);
  return PostProcessorModule;
}();

var EventsPatchModule = function () {
  function EventsPatchModule() {
    classCallCheck(this, EventsPatchModule);
  }

  createClass(EventsPatchModule, [{
    key: 'manager',
    value: function manager(_manager) {
      _manager.define('events');
      this.element = _manager.get('renderer').domElement;
    }
  }, {
    key: 'patchEvents',
    value: function patchEvents(originObject, destObject) {
      var events = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];

      events.forEach(function (event) {
        return originObject.addEventListener(event, function (e) {
          return destObject.emit(event, e);
        });
      });
    }
  }, {
    key: 'integrate',
    value: function integrate(self) {
      var element = self.element,
          patchEvents = self.patchEvents;


      patchEvents(element, this, ['mousemove', 'mouseup', 'contextmenu', 'mousedown', 'click', 'wheel', 'touchstart', 'touchend', 'touchmove', 'keydown']);

      patchEvents(element, this, ['keydown', 'keyup', 'keypress']);
    }
  }]);
  return EventsPatchModule;
}();

var VirtualMouseModule = function (_Events) {
  inherits(VirtualMouseModule, _Events);

  function VirtualMouseModule() {
    var globalMovement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
    classCallCheck(this, VirtualMouseModule);

    var _this = possibleConstructorReturn(this, (VirtualMouseModule.__proto__ || Object.getPrototypeOf(VirtualMouseModule)).call(this));

    _this.mouse = new Vector2();
    _this.raycaster = new Raycaster();
    _this.world = null;
    _this.canvas = null;
    _this.projectionPlane = new Plane(new Vector3(0, 0, 1), 0);

    _this.globalMovement = globalMovement;
    return _this;
  }

  createClass(VirtualMouseModule, [{
    key: 'update',
    value: function update(e, customX, customY) {
      var rect = this.canvas.getBoundingClientRect();

      var x = customX || e.clientX;
      var y = customY || e.clientY;

      this.mouse.x = (x - rect.left) / (rect.right - rect.left) * 2 - 1;
      this.mouse.y = -((y - rect.top) / (rect.bottom - rect.top)) * 2 + 1;

      this.projectionPlane.normal.copy(this.camera.getWorldDirection());

      this.raycaster.setFromCamera(this.mouse, this.camera);
      this.emit('move');
    }
  }, {
    key: 'manager',
    value: function manager(_manager) {
      _manager.define('mouse');
      _manager.require('events', function () {
        return new EventsPatchModule();
      });

      this.canvas = _manager.get('renderer').domElement;
      this.camera = _manager.get('camera').native;
    }
  }, {
    key: 'integrate',
    value: function integrate(self) {
      var _this2 = this;

      ['click', 'mousedown', 'mouseup', 'mousemove'].forEach(function (ev) {
        return _this2.on(ev, function (e) {
          return self.emit(ev, e);
        });
      });

      self.globalX = 0;
      self.globalY = 0;

      this.on('mousemove', function (e) {
        if (document.pointerLockElement !== null) {
          self.globalX += e.movementX;
          self.globalY += e.movementY;

          self.update(e, self.globalX, self.globalY);
        } else self.update(e);
      });
    }
  }, {
    key: 'track',
    value: function track(component) {
      var _this3 = this;

      var nested = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      var isHovered = false;

      this.on('move', function () {
        if (_this3.hovers(component, nested)) {
          if (isHovered) component.emit('mousemove');else {
            component.emit('mouseover');
            isHovered = true;
          }
        } else if (isHovered) {
          component.emit('mouseout');
          isHovered = false;
        }
      });

      this.on('click', function () {
        if (isHovered) component.emit('click');else component.emit('offClick');
      });

      this.on('mousedown', function () {
        if (isHovered) component.emit('mousedown');
      });

      this.on('mouseup', function () {
        if (isHovered) component.emit('mouseup');
      });
    }
  }, {
    key: 'intersection',
    value: function intersection(_ref) {
      var native = _ref.native;
      var nested = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      if (native.children.length > 0 && nested) {
        var objects = [];
        native.traverse(function (child) {
          return objects.push(child);
        });

        return this.raycaster.intersectObjects(objects);
      }

      return this.raycaster.intersectObject(native);
    }
  }, {
    key: 'project',
    value: function project() {
      var plane = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.projectionPlane;

      return this.raycaster.ray.intersectPlane(plane);
    }
  }, {
    key: 'hovers',
    value: function hovers(component) {
      var nested = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      return this.intersection(component, nested).length > 0;
    }
  }, {
    key: 'ray',
    get: function get$$1() {
      return this.raycaster.ray;
    }
  }, {
    key: 'x',
    get: function get$$1() {
      return this.mouse.x;
    }
  }, {
    key: 'y',
    get: function get$$1() {
      return this.mouse.y;
    }
  }]);
  return VirtualMouseModule;
}(minivents_commonjs);

var ControlsModule = function () {
  createClass(ControlsModule, null, [{
    key: 'from',
    value: function from(controls) {
      return new ControlsModule({ controls: controls });
    }
  }]);

  function ControlsModule() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, ControlsModule);

    this.params = Object.assign({
      controls: false,
      fix: function fix(controls) {
        return controls;
      },

      update: function update(c) {
        this.controls.update(c.getDelta());
      }
    }, params);

    this.controls = this.params.controls;
    this.update = this.params.update;
  }

  createClass(ControlsModule, [{
    key: 'manager',
    value: function manager(_manager) {
      _manager.require('events', function () {
        return new EventsPatchModule();
      });
    }
  }, {
    key: 'setControls',
    value: function setControls(controls) {
      this.controls = controls;
      return this;
    }
  }, {
    key: 'setUpdate',
    value: function setUpdate(update) {
      this.update = update;
      return this;
    }
  }, {
    key: 'integrate',
    value: function integrate(self) {
      self.updateLoop = new Loop(self.update.bind(self));
      self.updateLoop.start(this);
    }
  }]);
  return ControlsModule;
}();

var FogModule = function () {
  function FogModule() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var type = arguments[1];
    classCallCheck(this, FogModule);

    this.params = Object.assign({
      color: 0xefd1b5,
      density: 0.020,
      near: 10,
      far: 1000
    }, params);
    if (!type || type === 'exp2') this.fog = new FogExp2(this.params.color, this.params.density);else if (type === 'linear') this.fog = new Fog(this.params.color, this.params.near, this.params.far);
  }

  createClass(FogModule, [{
    key: 'manager',
    value: function manager(_manager) {
      _manager.set('fog', this.fog);
      _manager.get('scene').fog = this.fog;
    }
  }]);
  return FogModule;
}();

var isEqualDefault = function isEqualDefault(a, b) {
  if (a === b) return true;else if (a && a.equals && a.equals(b)) return true;

  return false;
};

/**
 * @class StateModule
 * @description `StateModule` is useful for apps, where you need state manipulation.
 * This can be: _transitions between screens, games, development moments_.
 * You can check [basic/state](https://whs-dev.surge.sh/examples/?basic/state) example.
 * @category modules/app
 * @param {Object} [params]
 * @memberof module:modules/app
 * @example <caption> Creating a state module</caption>
 * new App([
 *   // ...
 *   new StateModule().default({
 *     sphereColor: 0xff0000
 *   })
 * ]);
 */

var StateModule = function () {
  createClass(StateModule, null, [{
    key: 'actionGenerate',
    value: function actionGenerate(isEqual) {
      return function () {
        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [{}, ''];
        var _ref = arguments[1];
        var key = _ref.key,
            data = _ref.data;

        if (isEqual(state[0][key], data)) return state;

        state[0][key] = data;
        state[1] = key;

        return state;
      };
    }
  }]);

  function StateModule() {
    var equalCheck = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : isEqualDefault;
    classCallCheck(this, StateModule);

    this.store = createStore(StateModule.actionGenerate(equalCheck));

    this.configuration = {};
    this.currentConfig = 'default';
    this.prevConfig = 'default';
  }

  /**
   * @method default
   * @description Add default configuration.
   * @param {Object} data Configuration setup
   * @memberof module:modules/app.StateModule
   * @example
   * new WHS.StateModule().default({
   *   sphereColor: UTILS.$colors.mesh,
   *   planeColor: 0x447F8B
   * })
   */


  createClass(StateModule, [{
    key: 'default',
    value: function _default(data) {
      this.config({ default: data });
      return this;
    }

    /**
     * @method setEqualCheck
     * @description Sets an equalCheck function
     * @param {Object} data Configuration setup
     * @memberof module:modules/app.StateModule
     */

  }, {
    key: 'setEqualCheck',
    value: function setEqualCheck(func) {
      this.store.replaceReducer(StateModule.actionGenerate(func));
    }
  }, {
    key: 'manager',
    value: function manager(_manager) {
      _manager.define('state');
    }

    /**
     * @method config
     * @description Load configurations from object.
     * @param {Object} configs Configuration data
     * @memberof module:modules/app.StateModule
     * @example <caption> Adding `green` configuration</caption>
     * state.config({
     *   green: {
     *     sphereColor: 0x00ff00,
     *     planeColor: 0x00ff00
     *   }
     * });
     */

  }, {
    key: 'config',
    value: function config(configs) {
      for (var key in configs) {
        if (key) {
          this.configuration[key] = key === 'default' ? configs[key] : Object.assign({}, this.configuration.default, configs[key]);
        }
      }
    }

    /**
     * @method update
     * @description Load updates from object.
     * @param {Object} updates Updates data
     * @memberof module:modules/app.StateModule
     * @example <caption> Update callback for `sphereColor`</caption>
     * state.update({
     *   sphereColor: color => sphere.material.color.setHex(color)
     * });
     */

  }, {
    key: 'update',
    value: function update() {
      var _this = this;

      var updates = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      this.store.subscribe(function () {
        var _store$getState = _this.store.getState(),
            _store$getState2 = slicedToArray(_store$getState, 2),
            data = _store$getState2[0],
            changedKey = _store$getState2[1];

        var callback = updates[changedKey];

        if (callback) callback(data[changedKey]);
      });
    }

    /**
     * @method to
     * @description Switch to configuration.
     * @param {String} configName Configuration name.
     * @memberof module:modules/app.StateModule
     * @example <caption> Changes configuration to `green`</caption>
     * state.to('green');
     */

  }, {
    key: 'to',
    value: function to(configName) {
      this.prevConfig = this.currentConfig;
      this.currentConfig = configName;

      var config = this.configuration[configName] ? this.configuration[configName] : this.configuration.default;

      this.set(config);
    }

    /**
     * @method set
     * @description Set current parameters.
     * @param {Object} data Configuration parameters.
     * @memberof module:modules/app.StateModule
     * @example
     * state.set({
     *   sphereColor: 0x00ff00
     * });
     */

  }, {
    key: 'set',
    value: function set$$1(data) {
      for (var key in data) {
        if (key) this.store.dispatch({ type: 'ADD', key: key, data: data[key] });
      }
    }

    /**
     * @method get
     * @description Return data of parameter.
     * @param {String} key Parameter name.
     * @memberof module:modules/app.StateModule
     * @example
     * state.get('sphereColor'); // 0x00ff00
     */

  }, {
    key: 'get',
    value: function get$$1(key) {
      return this.store.getState()[0][key];
    }

    /**
     * @method prev
     * @description Return `trueVal` if `config` match previous configuration, in other case - return `falseVal`.
     * @param {String} config Configuration name.
     * @param {Any} trueVal Value returned if condition is truthy.
     * @param {Any} falseVal CValue returned if condition is falsy.
     * @memberof module:modules/app.StateModule
     */

  }, {
    key: 'prev',
    value: function prev(config, trueVal, falseVal) {
      return this.prevConfig === config ? trueVal : falseVal;
    }

    /**
     * @method current
     * @description Return `trueVal` if `config` match current configuration, in other case - return `falseVal`.
     * @param {String} config Configuration name.
     * @param {Any} trueVal Value returned if condition is truthy.
     * @param {Any} falseVal CValue returned if condition is falsy.
     * @memberof module:modules/app.StateModule
     */

  }, {
    key: 'current',
    value: function current(config, trueVal, falseVal) {
      return this.currentConfig === config ? trueVal : falseVal;
    }
  }]);
  return StateModule;
}();

var ThreeOrbitControls = function (_EventDispatcher) {
  inherits(ThreeOrbitControls, _EventDispatcher);

  function ThreeOrbitControls(object, domElement, eventHandler) {
    classCallCheck(this, ThreeOrbitControls);

    var _this = possibleConstructorReturn(this, (ThreeOrbitControls.__proto__ || Object.getPrototypeOf(ThreeOrbitControls)).call(this));

    _this.object = object;

    _this.domElement = domElement === undefined ? document : domElement;
    _this.eventHandler = eventHandler;

    // Set to false to disable this control
    _this.enabled = true;

    // "target" sets the location of focus, where the object orbits around
    _this.target = new Vector3();

    // How far you can dolly in and out ( PerspectiveCamera only )
    _this.minDistance = 0;
    _this.maxDistance = Infinity;

    // How far you can zoom in and out ( OrthographicCamera only )
    _this.minZoom = 0;
    _this.maxZoom = Infinity;

    // How far you can orbit vertically, upper and lower limits.
    // Range is 0 to Math.PI radians.
    _this.minPolarAngle = 0; // radians
    _this.maxPolarAngle = Math.PI; // radians

    // How far you can orbit horizontally, upper and lower limits.
    // If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ].
    _this.minAzimuthAngle = -Infinity; // radians
    _this.maxAzimuthAngle = Infinity; // radians

    // Set to true to enable damping (inertia)
    // If damping is enabled, you must call controls.update() in your animation loop
    _this.enableDamping = false;
    _this.dampingFactor = 0.25;

    // This option actually enables dollying in and out; left as "zoom" for backwards compatibility.
    // Set to false to disable zooming
    _this.enableZoom = true;
    _this.zoomSpeed = 1.0;

    // Set to false to disable rotating
    _this.enableRotate = true;
    _this.rotateSpeed = 1.0;

    // Set to false to disable panning
    _this.enablePan = true;
    _this.keyPanSpeed = 7.0; // pixels moved per arrow key push

    // Set to true to automatically rotate around the target
    // If auto-rotate is enabled, you must call controls.update() in your animation loop
    _this.autoRotate = false;
    _this.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60

    // Set to false to disable use of the keys
    _this.enableKeys = true;

    // The four arrow keys
    _this.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 };

    // Mouse buttons
    _this.mouseButtons = { ORBIT: MOUSE.LEFT, ZOOM: MOUSE.MIDDLE, PAN: MOUSE.RIGHT };

    // for reset
    _this.target0 = _this.target.clone();
    _this.position0 = _this.object.position.clone();
    _this.zoom0 = _this.object.zoom;

    //
    // public methods
    //

    _this.getPolarAngle = function () {
      return spherical.phi;
    };

    _this.getAzimuthalAngle = function () {
      return spherical.theta;
    };

    _this.reset = function () {
      _this.target.copy(_this.target0);
      _this.object.position.copy(_this.position0);
      _this.object.zoom = _this.zoom0;

      _this.object.updateProjectionMatrix();
      _this.dispatchEvent(changeEvent);

      _this.update();

      state = STATE.NONE;
    };

    // this method is exposed, but perhaps it would be better if we can make it private...
    _this.update = function () {
      var offset = new Vector3();

      // so camera.up is the orbit axis
      var quat = new Quaternion().setFromUnitVectors(object.up, new Vector3(0, 1, 0));
      var quatInverse = quat.clone().inverse();

      var lastPosition = new Vector3();
      var lastQuaternion = new Quaternion();

      return function () {
        var position = _this.object.position;

        offset.copy(position).sub(_this.target);

        // rotate offset to "y-axis-is-up" space
        offset.applyQuaternion(quat);

        // angle from z-axis around y-axis
        spherical.setFromVector3(offset);

        if (_this.autoRotate && state === STATE.NONE) rotateLeft(getAutoRotationAngle());

        spherical.theta += sphericalDelta.theta;
        spherical.phi += sphericalDelta.phi;

        // restrict theta to be between desired limits
        spherical.theta = Math.max(_this.minAzimuthAngle, Math.min(_this.maxAzimuthAngle, spherical.theta));

        // restrict phi to be between desired limits
        spherical.phi = Math.max(_this.minPolarAngle, Math.min(_this.maxPolarAngle, spherical.phi));

        spherical.makeSafe();

        spherical.radius *= scale;

        // restrict radius to be between desired limits
        spherical.radius = Math.max(_this.minDistance, Math.min(_this.maxDistance, spherical.radius));

        // move target to panned location
        _this.target.add(panOffset);

        offset.setFromSpherical(spherical);

        // rotate offset back to "camera-up-vector-is-up" space
        offset.applyQuaternion(quatInverse);

        position.copy(_this.target).add(offset);

        _this.object.lookAt(_this.target);

        if (_this.enableDamping === true) {
          sphericalDelta.theta *= 1 - _this.dampingFactor;
          sphericalDelta.phi *= 1 - _this.dampingFactor;
        } else sphericalDelta.set(0, 0, 0);

        scale = 1;
        panOffset.set(0, 0, 0);

        // update condition is:
        // min(camera displacement, camera rotation in radians)^2 > EPS
        // using small-angle approximation cos(x/2) = 1 - x^2 / 8

        if (zoomChanged || lastPosition.distanceToSquared(_this.object.position) > EPS || 8 * (1 - lastQuaternion.dot(_this.object.quaternion)) > EPS) {
          _this.dispatchEvent(changeEvent);

          lastPosition.copy(_this.object.position);
          lastQuaternion.copy(_this.object.quaternion);
          zoomChanged = false;

          return true;
        }

        return false;
      }();
    };

    _this.dispose = function () {
      _this.domElement.removeEventListener('contextmenu', onContextMenu, false);
      _this.domElement.removeEventListener('mousedown', onMouseDown, false);
      _this.domElement.removeEventListener('wheel', onMouseWheel, false);

      _this.domElement.removeEventListener('touchstart', onTouchStart, false);
      _this.domElement.removeEventListener('touchend', onTouchEnd, false);
      _this.domElement.removeEventListener('touchmove', onTouchMove, false);

      document.removeEventListener('mousemove', onMouseMove, false);
      document.removeEventListener('mouseup', onMouseUp, false);

      window.removeEventListener('keydown', onKeyDown, false);

      // this.dispatchEvent( { type: 'dispose' } ); // should this be added here?
    };

    //
    // internals
    //

    var changeEvent = { type: 'change' };
    var startEvent = { type: 'start' };
    var endEvent = { type: 'end' };

    var STATE = { NONE: -1, ROTATE: 0, DOLLY: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_DOLLY: 4, TOUCH_PAN: 5 };

    var state = STATE.NONE;

    var EPS = 0.000001;

    // current position in spherical coordinates
    var spherical = new Spherical();
    var sphericalDelta = new Spherical();

    var scale = 1;
    var panOffset = new Vector3();
    var zoomChanged = false;

    var rotateStart = new Vector2();
    var rotateEnd = new Vector2();
    var rotateDelta = new Vector2();

    var panStart = new Vector2();
    var panEnd = new Vector2();
    var panDelta = new Vector2();

    var dollyStart = new Vector2();
    var dollyEnd = new Vector2();
    var dollyDelta = new Vector2();

    var getAutoRotationAngle = function getAutoRotationAngle() {
      return 2 * Math.PI / 60 / 60 * _this.autoRotateSpeed;
    };

    var getZoomScale = function getZoomScale() {
      return Math.pow(0.95, _this.zoomSpeed);
    };

    var rotateLeft = function rotateLeft(angle) {
      sphericalDelta.theta -= angle;
    };

    var rotateUp = function rotateUp(angle) {
      sphericalDelta.phi -= angle;
    };

    var panLeft = function () {
      var v = new Vector3();

      return function (distance, objectMatrix) {
        v.setFromMatrixColumn(objectMatrix, 0); // get X column of objectMatrix
        v.multiplyScalar(-distance);
        panOffset.add(v);
      };
    }();

    var panUp = function () {
      var v = new Vector3();

      return function (distance, objectMatrix) {
        v.setFromMatrixColumn(objectMatrix, 1); // get Y column of objectMatrix
        v.multiplyScalar(distance);
        panOffset.add(v);
      };
    }();

    // deltaX and deltaY are in pixels; right and down are positive
    var pan = function () {
      var offset = new Vector3();

      return function (deltaX, deltaY) {
        var element = _this.domElement === document ? _this.domElement.body : _this.domElement;

        if (_this.object instanceof PerspectiveCamera) {
          // perspective
          var position = _this.object.position;
          offset.copy(position).sub(_this.target);
          var targetDistance = offset.length();

          // half of the fov is center to top of screen
          targetDistance *= Math.tan(_this.object.fov / 2 * Math.PI / 180.0);

          // we actually don't use screenWidth, since perspective camera is fixed to screen height
          panLeft(2 * deltaX * targetDistance / element.clientHeight, _this.object.matrix);
          panUp(2 * deltaY * targetDistance / element.clientHeight, _this.object.matrix);
        } else if (_this.object instanceof OrthographicCamera) {
          // orthographic
          panLeft(deltaX * (_this.object.right - _this.object.left) / _this.object.zoom / element.clientWidth, _this.object.matrix);
          panUp(deltaY * (_this.object.top - _this.object.bottom) / _this.object.zoom / element.clientHeight, _this.object.matrix);
        } else {
          // camera neither orthographic nor perspective
          console.warn('WARNING: OrbitControlsModule.js encountered an unknown camera type - pan disabled.');
          _this.enablePan = false;
        }
      };
    }();

    var dollyIn = function dollyIn(dollyScale) {
      if (_this.object instanceof PerspectiveCamera) scale /= dollyScale;else if (_this.object instanceof OrthographicCamera) {
        _this.object.zoom = Math.max(_this.minZoom, Math.min(_this.maxZoom, _this.object.zoom * dollyScale));
        _this.object.updateProjectionMatrix();
        zoomChanged = true;
      } else {
        console.warn('WARNING: OrbitControlsModule.js encountered an unknown camera type - dolly/zoom disabled.');
        _this.enableZoom = false;
      }
    };

    var dollyOut = function dollyOut(dollyScale) {
      if (_this.object instanceof PerspectiveCamera) scale *= dollyScale;else if (_this.object instanceof OrthographicCamera) {
        _this.object.zoom = Math.max(_this.minZoom, Math.min(_this.maxZoom, _this.object.zoom / dollyScale));
        _this.object.updateProjectionMatrix();
        zoomChanged = true;
      } else {
        console.warn('WARNING: OrbitControlsModule.js encountered an unknown camera type - dolly/zoom disabled.');
        _this.enableZoom = false;
      }
    };

    //
    // event callbacks - update the object state
    //

    var handleMouseDownRotate = function handleMouseDownRotate(event) {
      // console.log( 'handleMouseDownRotate' );

      rotateStart.set(event.clientX, event.clientY);
    };

    var handleMouseDownDolly = function handleMouseDownDolly(event) {
      // console.log( 'handleMouseDownDolly' );

      dollyStart.set(event.clientX, event.clientY);
    };

    var handleMouseDownPan = function handleMouseDownPan(event) {
      // console.log( 'handleMouseDownPan' );

      panStart.set(event.clientX, event.clientY);
    };

    var handleMouseMoveRotate = function handleMouseMoveRotate(event) {
      // console.log( 'handleMouseMoveRotate' );

      rotateEnd.set(event.clientX, event.clientY);
      rotateDelta.subVectors(rotateEnd, rotateStart);

      var element = _this.domElement === document ? _this.domElement.body : _this.domElement;

      // rotating across whole screen goes 360 degrees around
      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientWidth * _this.rotateSpeed);

      // rotating up and down along whole screen attempts to go 360, but limited to 180
      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight * _this.rotateSpeed);

      rotateStart.copy(rotateEnd);

      _this.update();
    };

    var handleMouseMoveDolly = function handleMouseMoveDolly(event) {
      // console.log( 'handleMouseMoveDolly' );

      dollyEnd.set(event.clientX, event.clientY);

      dollyDelta.subVectors(dollyEnd, dollyStart);

      if (dollyDelta.y > 0) dollyIn(getZoomScale());else if (dollyDelta.y < 0) dollyOut(getZoomScale());

      dollyStart.copy(dollyEnd);

      _this.update();
    };

    var handleMouseMovePan = function handleMouseMovePan(event) {
      // console.log( 'handleMouseMovePan' );

      panEnd.set(event.clientX, event.clientY);

      panDelta.subVectors(panEnd, panStart);

      pan(panDelta.x, panDelta.y);

      panStart.copy(panEnd);

      _this.update();
    };

    var handleMouseUp = function handleMouseUp(event) {
      // console.log( 'handleMouseUp' );
    };

    var handleMouseWheel = function handleMouseWheel(event) {
      // console.log( 'handleMouseWheel' );

      if (event.deltaY < 0) dollyOut(getZoomScale());else if (event.deltaY > 0) dollyIn(getZoomScale());

      _this.update();
    };

    var handleKeyDown = function handleKeyDown(event) {
      // console.log( 'handleKeyDown' );

      switch (event.keyCode) {
        case _this.keys.UP:
          pan(0, _this.keyPanSpeed);
          _this.update();
          break;

        case _this.keys.BOTTOM:
          pan(0, -_this.keyPanSpeed);
          _this.update();
          break;

        case _this.keys.LEFT:
          pan(_this.keyPanSpeed, 0);
          _this.update();
          break;

        case _this.keys.RIGHT:
          pan(-_this.keyPanSpeed, 0);
          _this.update();
          break;

      }
    };

    var handleTouchStartRotate = function handleTouchStartRotate(event) {
      // console.log( 'handleTouchStartRotate' );

      rotateStart.set(event.touches[0].pageX, event.touches[0].pageY);
    };

    var handleTouchStartDolly = function handleTouchStartDolly(event) {
      // console.log( 'handleTouchStartDolly' );

      var dx = event.touches[0].pageX - event.touches[1].pageX;
      var dy = event.touches[0].pageY - event.touches[1].pageY;

      var distance = Math.sqrt(dx * dx + dy * dy);

      dollyStart.set(0, distance);
    };

    var handleTouchStartPan = function handleTouchStartPan(event) {
      // console.log( 'handleTouchStartPan' );

      panStart.set(event.touches[0].pageX, event.touches[0].pageY);
    };

    var handleTouchMoveRotate = function handleTouchMoveRotate(event) {
      // console.log( 'handleTouchMoveRotate' );

      rotateEnd.set(event.touches[0].pageX, event.touches[0].pageY);
      rotateDelta.subVectors(rotateEnd, rotateStart);

      var element = _this.domElement === document ? _this.domElement.body : _this.domElement;

      // rotating across whole screen goes 360 degrees around
      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientWidth * _this.rotateSpeed);

      // rotating up and down along whole screen attempts to go 360, but limited to 180
      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight * _this.rotateSpeed);

      rotateStart.copy(rotateEnd);

      _this.update();
    };

    var handleTouchMoveDolly = function handleTouchMoveDolly(event) {
      // console.log( 'handleTouchMoveDolly' );

      var dx = event.touches[0].pageX - event.touches[1].pageX;
      var dy = event.touches[0].pageY - event.touches[1].pageY;

      var distance = Math.sqrt(dx * dx + dy * dy);

      dollyEnd.set(0, distance);

      dollyDelta.subVectors(dollyEnd, dollyStart);

      if (dollyDelta.y > 0) dollyOut(getZoomScale());else if (dollyDelta.y < 0) dollyIn(getZoomScale());

      dollyStart.copy(dollyEnd);

      _this.update();
    };

    var handleTouchMovePan = function handleTouchMovePan(event) {
      // console.log( 'handleTouchMovePan' );

      panEnd.set(event.touches[0].pageX, event.touches[0].pageY);

      panDelta.subVectors(panEnd, panStart);

      pan(panDelta.x, panDelta.y);

      panStart.copy(panEnd);

      _this.update();
    };

    var handleTouchEnd = function handleTouchEnd() {
      // console.log( 'handleTouchEnd' );
    };

    //
    // event handlers - FSM: listen for events and reset state
    //

    var onMouseDown = function onMouseDown(event) {
      if (_this.enabled === false) return;

      event.preventDefault();

      if (event.button === _this.mouseButtons.ORBIT) {
        if (_this.enableRotate === false) return;

        handleMouseDownRotate(event);

        state = STATE.ROTATE;
      } else if (event.button === _this.mouseButtons.ZOOM) {
        if (_this.enableZoom === false) return;

        handleMouseDownDolly(event);

        state = STATE.DOLLY;
      } else if (event.button === _this.mouseButtons.PAN) {
        if (_this.enablePan === false) return;

        handleMouseDownPan(event);

        state = STATE.PAN;
      }

      if (state !== STATE.NONE) {
        _this.eventHandler.on('mousemove', onMouseMove, false);
        _this.eventHandler.on('mouseup', onMouseUp, false);

        _this.dispatchEvent(startEvent);
      }
    };

    var onMouseMove = function onMouseMove(event) {
      if (_this.enabled === false) return;

      event.preventDefault();

      if (state === STATE.ROTATE) {
        if (_this.enableRotate === false) return;

        handleMouseMoveRotate(event);
      } else if (state === STATE.DOLLY) {
        if (_this.enableZoom === false) return;

        handleMouseMoveDolly(event);
      } else if (state === STATE.PAN) {
        if (_this.enablePan === false) return;

        handleMouseMovePan(event);
      }
    };

    var onMouseUp = function onMouseUp(event) {
      if (_this.enabled === false) return;

      handleMouseUp(event);

      document.removeEventListener('mousemove', onMouseMove, false);
      document.removeEventListener('mouseup', onMouseUp, false);

      _this.dispatchEvent(endEvent);

      state = STATE.NONE;
    };

    var onMouseWheel = function onMouseWheel(event) {
      if (_this.enabled === false || _this.enableZoom === false || state !== STATE.NONE && state !== STATE.ROTATE) return;

      event.preventDefault();
      event.stopPropagation();

      handleMouseWheel(event);

      _this.dispatchEvent(startEvent); // not sure why these are here...
      _this.dispatchEvent(endEvent);
    };

    var onKeyDown = function onKeyDown(event) {
      if (_this.enabled === false || _this.enableKeys === false || _this.enablePan === false) return;

      handleKeyDown(event);
    };

    var onTouchStart = function onTouchStart(event) {
      if (_this.enabled === false) return;

      switch (event.touches.length) {
        case 1:
          // one-fingered touch: rotate

          if (_this.enableRotate === false) return;

          handleTouchStartRotate(event);

          state = STATE.TOUCH_ROTATE;

          break;

        case 2:
          // two-fingered touch: dolly

          if (_this.enableZoom === false) return;

          handleTouchStartDolly(event);

          state = STATE.TOUCH_DOLLY;

          break;

        case 3:
          // three-fingered touch: pan

          if (_this.enablePan === false) return;

          handleTouchStartPan(event);

          state = STATE.TOUCH_PAN;

          break;

        default:

          state = STATE.NONE;

      }

      if (state !== STATE.NONE) _this.dispatchEvent(startEvent);
    };

    var onTouchMove = function onTouchMove(event) {
      if (_this.enabled === false) return;

      event.preventDefault();
      event.stopPropagation();

      switch (event.touches.length) {
        case 1:
          // one-fingered touch: rotate

          if (_this.enableRotate === false) return;
          if (state !== STATE.TOUCH_ROTATE) return; // is this needed?...

          handleTouchMoveRotate(event);

          break;

        case 2:
          // two-fingered touch: dolly

          if (_this.enableZoom === false) return;
          if (state !== STATE.TOUCH_DOLLY) return; // is this needed?...

          handleTouchMoveDolly(event);

          break;

        case 3:
          // three-fingered touch: pan

          if (_this.enablePan === false) return;
          if (state !== STATE.TOUCH_PAN) return; // is this needed?...

          handleTouchMovePan(event);

          break;

        default:

          state = STATE.NONE;

      }
    };

    var onTouchEnd = function onTouchEnd(event) {
      if (_this.enabled === false) return;

      handleTouchEnd(event);

      _this.dispatchEvent(endEvent);

      state = STATE.NONE;
    };

    var onContextMenu = function onContextMenu(event) {
      event.preventDefault();
    };

    //

    _this.eventHandler.on('contextmenu', onContextMenu, false);

    _this.eventHandler.on('mousedown', onMouseDown, false);
    _this.eventHandler.on('wheel', onMouseWheel, false);

    _this.eventHandler.on('touchstart', onTouchStart, false);
    _this.eventHandler.on('touchend', onTouchEnd, false);
    _this.eventHandler.on('touchmove', onTouchMove, false);

    _this.eventHandler.on('keydown', onKeyDown, false);

    // force an update at start

    _this.update();
    return _this;
  }

  createClass(ThreeOrbitControls, [{
    key: 'center',
    get: function get$$1() {
      console.warn('OrbitControls: .center has been renamed to .target');
      return this.target;
    }
  }, {
    key: 'noZoom',
    get: function get$$1() {
      console.warn('OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.');
      return !this.enableZoom;
    },
    set: function set$$1(value) {
      console.warn('OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.');
      this.enableZoom = !value;
    }
  }, {
    key: 'noRotate',
    get: function get$$1() {
      console.warn('OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.');
      return !this.enableRotate;
    },
    set: function set$$1(value) {
      console.warn('OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.');
      this.enableRotate = !value;
    }
  }, {
    key: 'noPan',
    get: function get$$1() {
      console.warn('OrbitControls: .noPan has been deprecated. Use .enablePan instead.');
      return !this.enablePan;
    },
    set: function set$$1(value) {
      console.warn('OrbitControls: .noPan has been deprecated. Use .enablePan instead.');
      this.enablePan = !value;
    }
  }, {
    key: 'noKeys',
    get: function get$$1() {
      console.warn('OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.');
      return !this.enableKeys;
    },
    set: function set$$1(value) {
      console.warn('OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.');
      this.enableKeys = !value;
    }
  }, {
    key: 'staticMoving',
    get: function get$$1() {
      console.warn('OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.');
      return !this.enableDamping;
    },
    set: function set$$1(value) {
      console.warn('OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.');
      this.enableDamping = !value;
    }
  }, {
    key: 'dynamicDampingFactor',
    get: function get$$1() {
      console.warn('OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.');
      return this.dampingFactor;
    },
    set: function set$$1(value) {
      console.warn('OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.');
      this.dampingFactor = value;
    }
  }]);
  return ThreeOrbitControls;
}(EventDispatcher);

var OrbitControlsModule = function (_ControlsModule) {
  inherits(OrbitControlsModule, _ControlsModule);

  function OrbitControlsModule() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, OrbitControlsModule);

    var _this = possibleConstructorReturn(this, (OrbitControlsModule.__proto__ || Object.getPrototypeOf(OrbitControlsModule)).call(this, params));

    _this.params = Object.assign({
      follow: false,
      object: null,
      target: new Vector3(0, 0, 0)
    }, params);
    return _this;
  }

  createClass(OrbitControlsModule, [{
    key: 'manager',
    value: function manager(_manager) {
      get(OrbitControlsModule.prototype.__proto__ || Object.getPrototypeOf(OrbitControlsModule.prototype), 'manager', this).call(this, _manager);

      var _params = this.params,
          obj = _params.object,
          follow = _params.follow,
          target = _params.target;

      var object = obj ? obj.native : _manager.get('camera').native;

      var controls = new ThreeOrbitControls(object, _manager.get('element'), _manager.handler);

      var updateProcessor = follow ? function (c) {
        controls.update(c.getDelta());
        controls.target.copy(target);
      } : function (c) {
        controls.update(c.getDelta());
      };

      this.setControls(controls);
      this.setUpdate(updateProcessor);

      _manager.update({
        camera: function camera(_camera) {
          if (obj) return;
          controls.object = _camera.native;
        }
      });

      controls.target.copy(target);
    }
  }]);
  return OrbitControlsModule;
}(ControlsModule);

/** @module modules/app/controls */

/** @module modules/app */

/**
 * @class DynamicGeometryModule
 * @category modules/mesh
 * @param {Object} [params={attributes: false}] - params
 * @param {Boolean} [patchEvents=true]
 * @memberof module:modules/mesh
 */
var DynamicGeometryModule = function () {
  function DynamicGeometryModule() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, DynamicGeometryModule);

    this.params = Object.assign({
      attributes: false
    }, params);
  }

  createClass(DynamicGeometryModule, [{
    key: "integrate",
    value: function integrate(self) {
      var _this = this;

      var params = self.params;

      this.g_ = function () {
        var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        if (this.buildGeometry) {
          this.native.geometry = this.buildGeometry(this.updateParams({ geometry: params }));
        }
      };

      if (params.attributes) {
        var _loop = function _loop(key) {
          if (key) {
            Object.defineProperty(_this, "g_" + key, {
              get: function get$$1() {
                return this.native.geometry.parameters[key];
              },
              set: function set$$1(value) {
                this.native.geometry = this.buildGeometry(this.updateParams({ geometry: defineProperty({}, key, value) }));
              },

              configurable: true,
              enumerable: true
            });
          }
        };

        for (var key in this.params.geometry) {
          _loop(key);
        }
      }
    }
  }]);
  return DynamicGeometryModule;
}();

var loader = new TextureLoader();

/**
 * @class TextureModule
 * @category modules/mesh
 * @description A TextureModule can be applied to any Mesh or Model.
 * @param {Array} [textures] - array of texture objects
 * @memberof module:modules/mesh
 * @example <caption>Creating an instance. url takes a path, or a data object.</caption>
 * var woodTexture = new TextureModule({
 *   url: `${process.assetsPath}/textures/wood.jpg`
 * });
 * @example <caption>More comprehensive example, wood texture applied to a Box.</caption>
 * new Box({
 *   geometry: {
 *     width: 2,
 *     height: 2,
 *     depth: 2
 *   },
 *   modules: [
 *     new TextureModule({
 *       url: `path/to/texture.jpg`,
 *       repeat: new THREE.Vector2(1, 1) // optional
 *     })
 *   ],
 *   material: new THREE.MeshBasicMaterial({
 *     color: 0xffffff
 *   }),
 *   position: [50, 60, 70]
 * }).addTo(app);
 */
var TextureModule = function () {
  createClass(TextureModule, null, [{
    key: 'load',
    value: function load(url) {
      return new TextureModule({ url: url }).textures[0][1];
    }
  }]);

  function TextureModule() {
    var _this = this;

    classCallCheck(this, TextureModule);
    this.textures = [];
    this.bridge = {
      material: function material(_material, self) {
        self.textures.forEach(function (texture) {
          _material[texture[0]] = texture[1];
        });

        return _material;
      }
    };

    for (var _len = arguments.length, textures = Array(_len), _key = 0; _key < _len; _key++) {
      textures[_key] = arguments[_key];
    }

    textures.forEach(function (_ref) {
      var url = _ref.url,
          _ref$type = _ref.type,
          type = _ref$type === undefined ? 'map' : _ref$type,
          _ref$offset = _ref.offset,
          offset = _ref$offset === undefined ? new Vector2(0, 0) : _ref$offset,
          _ref$repeat = _ref.repeat,
          repeat = _ref$repeat === undefined ? new Vector2(1, 1) : _ref$repeat,
          _ref$wrap = _ref.wrap,
          wrap = _ref$wrap === undefined ? RepeatWrapping : _ref$wrap,
          _ref$mapping = _ref.mapping,
          mapping = _ref$mapping === undefined ? UVMapping : _ref$mapping,
          _ref$fix = _ref.fix,
          fix = _ref$fix === undefined ? function (tex) {
        return tex;
      } : _ref$fix;

      var texture = loader.load(url);

      if (wrap.length > 0) {
        texture.wrapS = wrap[0];
        texture.wrapT = wrap[1];
      } else texture.wrapS = texture.wrapT = wrap;

      texture.mapping = mapping;

      texture.offset.copy(offset);
      texture.repeat.copy(repeat);

      texture.magFilter = NearestFilter;
      texture.minFilter = LinearMipMapLinearFilter;

      _this.textures.push([type, fix(texture)]);
    });
  }

  return TextureModule;
}();

var AnimationModule = function () {
  function AnimationModule(app, isDeferred) {
    var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
    classCallCheck(this, AnimationModule);
    this.bridge = {
      mesh: function mesh(_mesh, self) {
        _mesh.geometry.skeleton = _mesh.skeleton;

        self.mixer = new AnimationMixer(_mesh.geometry);
        self.clips = _mesh.geometry.animations;

        return _mesh;
      }
    };

    this.params = Object.assign({
      speed: 1
    }, params);
    this.clock = new Clock();

    this.app = app;
    this.isDeferred = isDeferred;
  }

  /**
   * @method play
   * @instance
   * @description Plays the given clip name
   * @param {String} clipName - the clip to play
   * @memberof module:modules/mesh.AnimationModule
   */


  createClass(AnimationModule, [{
    key: 'play',
    value: function play(clipName) {
      var clip = AnimationClip.findByName(this.clips, clipName);
      var action = this.mixer.clipAction(clip);

      action.play();
    }

    /**
     * @method update
     * @instance
     * @description Update the mixer (being called on frame animation loop)
     * @memberof module:modules/mesh.AnimationModule
     */

  }, {
    key: 'update',
    value: function update() {
      if (this.mixer) this.mixer.update(this.clock.getDelta() * this.params.speed);
    }
  }, {
    key: 'integrate',
    value: function integrate(self) {
      self.loop = new Loop(function () {
        self.update();
      });

      if (!self.isDeferred) self.loop.start(self.app);
    }
  }, {
    key: 'manager',
    value: function manager(_manager) {
      _manager.define('animation');
    }
  }]);
  return AnimationModule;
}();

/** @module modules/mesh */

/**
 * @class DefineModule
 * @category modules
 * @param {String} name
 * @param {Object} data
 * @memberof module:modules
 * @example <caption> Creating a DefineModule with PerspectiveCamera as camera module and passing it to App's modules</caption>
 * new App([
 *   // ...
 *   new DefineModule('camera', new PerspectiveCamera())
 * ]);
 */
var DefineModule = function () {
  function DefineModule(name, data) {
    classCallCheck(this, DefineModule);

    this.name = name;
    this.data = data;
  }

  createClass(DefineModule, [{
    key: "manager",
    value: function manager(_manager) {
      _manager.set(this.name, this.data);
    }
  }]);
  return DefineModule;
}();

/** @module modules */

var Model = function (_Importer) {
  inherits(Model, _Importer);

  function Model(params) {
    var _ref;

    classCallCheck(this, Model);

    console.warn('Model is deprecated. Use Importer instead.');

    if (params.geometry) {
      params.url = params.geometry.path;
      params.loader = params.geometry.loader;
    }

    for (var _len = arguments.length, additional = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      additional[_key - 1] = arguments[_key];
    }

    return possibleConstructorReturn(this, (_ref = Model.__proto__ || Object.getPrototypeOf(Model)).call.apply(_ref, [this, params].concat(additional)));
  }

  return Model;
}(Importer);

var CameraModule = function () {
  function CameraModule() {
    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    classCallCheck(this, CameraModule);

    console.warn('CameraModule is deprecated. Use DefineModule instead.');
    this.camera = new PerspectiveCamera$1(params);
  }

  createClass(CameraModule, [{
    key: 'integrate',
    value: function integrate(self) {
      this.add(self.camera);
    }
  }, {
    key: 'manager',
    value: function manager(_manager) {
      _manager.set('camera', this.camera);
    }
  }]);
  return CameraModule;
}();

/**
 * Namespace containing all classes from all modules. Used as global in UMD pattern.
 * @namespace WHS
 * @example <caption>The use of WHS namespace.</caption>
 * new WHS.App() // core
 * new WHS.PerspectiveCamera() // components
 * new WHS.ResizeModule() // modules
 * WHS.extend() // utils
 */

export { Component, MeshComponent, LightComponent, CameraComponent, App, Loop, ModuleManager, AmbientLight$1 as AmbientLight, DirectionalLight$1 as DirectionalLight, HemisphereLight$1 as HemisphereLight, PointLight$1 as PointLight, SpotLight$1 as SpotLight, AreaLight, CubeCamera$1 as CubeCamera, OrthographicCamera$1 as OrthographicCamera, PerspectiveCamera$1 as PerspectiveCamera, Box, Circle, Cone, Cylinder, Dodecahedron, Extrude, Icosahedron, Lathe, Line$1 as Line, Importer, Octahedron, Parametric, Plane$1 as Plane, Polyhedron, Ring, Shape, Sphere, Tetrahedron, Text, Torus, Torusknot, Tube, Group, extend, instruct, transformData, toArray, ElementModule, RenderingModule, SceneModule, ResizeModule, PostProcessorModule, VirtualMouseModule, EventsPatchModule, ControlsModule, FogModule, StateModule, OrbitControlsModule, DynamicGeometryModule, TextureModule, AnimationModule, DefineModule, Model, CameraModule };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"whs.module.js","sources":["../src/utils/extend.js","../src/utils/transformData.js","../node_modules/minivents/dist/minivents.commonjs.js","../src/core/errors.js","../src/core/ModuleSystem.js","../node_modules/lodash-es/_freeGlobal.js","../node_modules/lodash-es/_root.js","../node_modules/lodash-es/_Symbol.js","../node_modules/lodash-es/_getRawTag.js","../node_modules/lodash-es/_objectToString.js","../node_modules/lodash-es/_baseGetTag.js","../node_modules/lodash-es/_overArg.js","../node_modules/lodash-es/_getPrototype.js","../node_modules/lodash-es/isObjectLike.js","../node_modules/lodash-es/isPlainObject.js","../node_modules/symbol-observable/es/ponyfill.js","../node_modules/symbol-observable/es/index.js","../node_modules/redux/es/createStore.js","../node_modules/redux/es/utils/warning.js","../node_modules/redux/es/compose.js","../node_modules/redux/es/index.js","../src/core/ModuleManager.js","../src/core/Component.js","../src/core/prototype/attributes.js","../src/core/MeshComponent.js","../src/core/LightComponent.js","../src/core/CameraComponent.js","../node_modules/present/lib/present-node.js","../src/polyfill.js","../src/core/App.js","../src/core/Loop.js","../src/core/index.js","../src/components/lights/AmbientLight.js","../src/components/lights/DirectionalLight.js","../src/components/lights/HemisphereLight.js","../src/components/lights/PointLight.js","../src/components/lights/SpotLight.js","../src/components/lights/AreaLight.js","../src/components/lights/index.js","../src/components/cameras/CubeCamera.js","../src/components/cameras/OrthographicCamera.js","../src/components/cameras/PerspectiveCamera.js","../src/components/cameras/index.js","../src/components/meshes/Box.js","../src/components/meshes/Circle.js","../src/components/meshes/Cone.js","../src/components/meshes/Cylinder.js","../src/components/meshes/Dodecahedron.js","../src/components/meshes/Extrude.js","../src/components/meshes/Icosahedron.js","../src/components/meshes/Lathe.js","../src/components/meshes/Line.js","../src/components/meshes/Importer.js","../src/components/meshes/Octahedron.js","../src/components/meshes/Parametric.js","../src/components/meshes/Plane.js","../src/components/meshes/Polyhedron.js","../src/components/meshes/Ring.js","../src/components/meshes/Shape.js","../src/components/meshes/Sphere.js","../src/components/meshes/Tetrahedron.js","../src/components/meshes/Text.js","../src/components/meshes/Torus.js","../src/components/meshes/Torusknot.js","../src/components/meshes/Tube.js","../src/components/meshes/Group.js","../src/components/meshes/index.js","../src/modules/app/ElementModule.js","../src/modules/app/RenderingModule.js","../src/modules/app/SceneModule.js","../src/modules/app/ResizeModule.js","../node_modules/postprocessing/src/materials/convolution.js","../node_modules/postprocessing/src/materials/copy.js","../node_modules/postprocessing/src/materials/index.js","../node_modules/postprocessing/src/passes/pass.js","../node_modules/postprocessing/src/passes/clear.js","../node_modules/postprocessing/src/passes/clear-mask.js","../node_modules/postprocessing/src/passes/glitch.js","../node_modules/postprocessing/src/passes/render.js","../node_modules/postprocessing/src/passes/mask.js","../node_modules/postprocessing/src/passes/shader.js","../node_modules/postprocessing/src/passes/shock-wave.js","../node_modules/postprocessing/src/passes/index.js","../node_modules/postprocessing/src/core/effect-composer.js","../node_modules/postprocessing/src/core/index.js","../node_modules/postprocessing/src/index.js","../src/modules/app/PostProcessorModule.js","../src/modules/app/EventsPatchModule.js","../src/modules/app/VirtualMouseModule.js","../src/modules/app/ControlsModule.js","../src/modules/app/FogModule.js","../src/modules/app/StateModule.js","../src/modules/app/controls/lib/ThreeOrbitControls.js","../src/modules/app/controls/OrbitControlsModule.js","../src/modules/app/controls/index.js","../src/modules/app/index.js","../src/modules/mesh/DynamicGeometryModule.js","../src/modules/mesh/TextureModule.js","../src/modules/mesh/AnimationModule.js","../src/modules/mesh/index.js","../src/modules/DefineModule.js","../src/modules/index.js","../src/deprecation.js","../src/index.js"],"sourcesContent":["export const extend = (object, ...extensions) => { // $.extend alternative, ... is the spread operator.\n  for (const extension of extensions) {\n    // console.log(extension);\n    // console.log(typeof extension);\n\n    if (!extension)\n      continue; // Ignore null and undefined objects and parameters.\n\n    for (const prop of Object.getOwnPropertyNames(extension)) { // Do not traverse the prototype chain.\n      if (object[prop] !== undefined && extension[prop]\n        && object[prop].toString() === '[object Object]'\n        && extension[prop].toString() === '[object Object]') {\n        // Goes deep only if object[prop] and extension[prop] are both objects !\n        if (extension[prop].constructor === Object) extend(object[prop], extension[prop]);\n        else object[prop] = extension[prop];\n      } else\n        object[prop] = typeof object[prop] === 'undefined' ? extension[prop] : object[prop];\n\n      if (typeof object[prop] === 'undefined' && Array.isArray(extension[prop])) object[prop] = extension[prop].slice(); // Add values that do not already exist.\n      else if (typeof object[prop] === 'undefined' && Array.isArray(extension[prop])) object[prop] = extension[prop];\n    }\n  }\n\n  return object;\n};\n","export const instruct = (array, instArray) => {\n  const tempObject = {};\n\n  for (let i = 0, max = instArray.length; i < max; i++) {\n    const guide = instArray[i];\n\n    tempObject[guide] = array[i];\n  }\n\n  return tempObject;\n};\n\nexport const transformData = (object, instructions) => {\n  for (const key in instructions) {\n    if (Array.isArray(object[key]))\n      object[key] = instruct(object[key], instructions[key]);\n    else if (object[key] instanceof Object && !(Array.isArray(instructions[key])))\n      object[key] = transformData(object[key], instructions[key]);\n  }\n\n  return object;\n};\n\nexport const toArray = (object, instruction) => {\n  const tempArray = [];\n\n  for (let i = 0, max = instruction.length; i < max; i++) {\n    const guide = instruction[i];\n\n    tempArray[i] = object[guide];\n  }\n\n  return tempArray;\n};\n","module.exports = function Events(target){\n  var events = {}, empty = [];\n  target = target || this\n  /**\n   *  On: listen to events\n   */\n  target.on = function(type, func, ctx){\n    (events[type] = events[type] || []).push([func, ctx])\n  }\n  /**\n   *  Off: stop listening to event / specific callback\n   */\n  target.off = function(type, func){\n    type || (events = {})\n    var list = events[type] || empty,\n        i = list.length = func ? list.length : 0;\n    while(i--) func == list[i][0] && list.splice(i,1)\n  }\n  /** \n   * Emit: send event, callbacks will be triggered\n   */\n  target.emit = function(type){\n    var e = events[type] || empty, list = e.length > 0 ? e.slice(0, e.length) : e, i=0, j;\n    while(j=list[i++]) j[0].apply(j[1], empty.slice.call(arguments, 1))\n  };\n};","export class CompositionError extends Error {\n  constructor(classInstance, message, component) {\n    super(`@${classInstance}: ${message}`);\n\n    const stackArray = this.stack.split('\\n');\n    stackArray.splice(1, 2);\n\n    this.stack = stackArray.join('\\n');\n\n    if (console) console.error('Component:', component);\n\n    this.name = 'CompositionError';\n  }\n}\n\nexport class DependencyError extends Error {\n  constructor(classInstance, message, activeModule, dependencyModule = false) {\n    super(`@${classInstance}: ${message}`);\n\n    const stackArray = this.stack.split('\\n');\n    stackArray.splice(1, 2);\n\n    this.stack = stackArray.join('\\n');\n\n    if (console) console.error('Active module:', activeModule);\n    if (console && dependencyModule) console.error('Dependency published by module:', dependencyModule);\n\n    this.name = 'DependencyError';\n  }\n}\n\nexport class ManagerError extends Error {\n  constructor(classInstance, message, component, activeModule = false) {\n    super(`@${classInstance}: ${message}`);\n\n    const stackArray = this.stack.split('\\n');\n    stackArray.splice(1, 2);\n\n    this.stack = stackArray.join('\\n');\n\n    if (console) console.error('Component:', dependencyModule);\n    if (console && activeModule) console.error('Active module:', activeModule);\n\n    this.name = 'ManagerError';\n  }\n}\n","import {REVISION} from 'three';\nimport Events from 'minivents';\nimport {ManagerError} from './errors';\n\n// Check for Three.js\nconst warnDeps = () => {\n  throw new Error('WhitestormJS Framework requires Three.js r84. https://threejs.org/');\n};\n\ntry {\n  if (!REVISION) warnDeps();\n} catch (err) {\n  warnDeps();\n}\n\n/**\n * @class ModuleSystem\n * @category core\n * @description  Provides API for classes that will use Modules.<br/>\n * This class includes basic event system with those supported methods:\n * <pre>.on()</pre><pre>.off()</pre><pre>.emit()</pre>\n * @extends Events\n * @memberof module:core\n */\nexport class ModuleSystem extends Events {\n  // INTEGRATING\n\n  /**\n   * @method integrateModules\n   * @instance\n   * @description This method applies all modules from .modules collection.\n   * @param {Object} [source] If source (should be a component) is provided, will replace .modules with source's one before executing modules.\n   * @memberof module:core.ModuleSystem\n   */\n  integrateModules(source) {\n    if (!this.modules) return;\n    if (source) this.modules = source.modules.slice(0);\n\n    for (let i = 0, max = this.modules.length; i < max; i++)\n      this.applyModule(this.modules[i], false);\n\n    if (source) this.applyBridge({onCopy: source});\n  }\n\n  // APPLYING MODULE (...and a \"bridge\" for module)\n\n  /**\n   * @method applyBridge\n   * @instance\n   * @description Makes component-specific API to work with modules.\n   * @param {Object} bridgeMap\n   * @return {Object} Returns object with modified values.\n   * @memberof module:core.ModuleSystem\n   */\n  applyBridge(bridgeMap = {}) {\n    const modules = this.modules;\n    if (!modules) return bridgeMap;\n\n    for (let i = 0, max = modules.length; i < max; i++) {\n      for (const key in bridgeMap) {\n        if (bridgeMap[key]) {\n          const module = modules[i];\n\n          if (module && module.bridge && module.bridge[key])\n            bridgeMap[key] = module.bridge[key].apply(this, [bridgeMap[key], module]);\n        }\n      }\n    }\n\n    return bridgeMap;\n  }\n\n  /**\n   * @method applyCommand\n   * @instance\n   * @description .applyCommand runs a method called `name` on all modules.\n   * @param {String} name the method name.\n   * @param {Function} [cb=(func, moduleScope) => func.apply(this, [moduleScope])] How the function is wrapped/\n   * @memberof module:core.ModuleSystem\n   */\n  applyCommand(name, cb = (func, moduleScope) => func.apply(this, [moduleScope])) {\n    const modules = this.modules;\n    if (!modules) return;\n\n    for (let i = 0, max = modules.length; i < max; i++) {\n      const module = modules[i];\n      if (name in module) cb(module[name], module);\n    }\n  }\n\n  /**\n   * @method applyModule\n   * @instance\n   * @description .applyModule is also used in .integrateModules() function.\n   * It does exactly what its name says (applies module to component or app).\n   * @param {Object} module the module to apply\n   * @param {Boolean} [push=true]\n   * @return {Object} Returns module that was applied.\n   * @throws {ManagerError}\n   * @memberof module:core.ModuleSystem\n   */\n  applyModule(module, push = true) {\n    if (!module) return;\n    if (push && this.modules) this.modules.push(module);\n    else if (push) this.modules = [module];\n\n    if (this.manager) this.manager.active(module);\n\n    if (module.manager && this.manager) module.manager(this.manager);\n    else if (module.manager) {\n      throw new ManagerError(\n        'Component',\n        `Module requires ModuleManager that is turned off for this component`,\n        this, module\n      );\n    }\n\n    if (module.integrate) module.integrate.bind(this)(module);\n\n    return module;\n  }\n\n  /**\n   * @method disposeModules\n   * @instance\n   * @description Disposes of all modules\n   * @memberof module:core.ModuleSystem\n   */\n  disposeModules() {\n    while (this.modules.length)\n      this.disposeModule(this.modules[0]);\n  }\n\n  /**\n   * @method disposeModule\n   * @instance\n   * @description Disposes of the given module\n   * @param {Object} module the module to dispose\n   * @return {Module} Returns module that was removed.\n   * @memberof module:core.ModuleSystem\n   */\n  disposeModule(module) {\n    if (!module) return;\n\n    this.modules.splice(this.modules.indexOf(module), 1);\n\n    if (module.dispose) module.dispose.bind(this)(module);\n\n    return module;\n  }\n\n  // PIPED METHOD\n\n  /**\n   * @method module\n   * @instance\n   * @description piped version of .applyModule().\n   * @param {Object} module the module to apply\n   * @return {this} returns this - app/component\n   * @throws {ManagerError}\n   * @memberof module:core.ModuleSystem\n   * @example <caption>Piped modules</caption>\n   * component\n   *   .module(new Module1())\n   *   .module(new Module2())\n   *   .module(new Module3())\n   */\n  module(module) {\n    this.applyModule(module);\n    return this;\n  }\n}\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nexport default baseGetTag;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nexport default overArg;\n","import overArg from './_overArg.js';\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nexport default getPrototype;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n","import baseGetTag from './_baseGetTag.js';\nimport getPrototype from './_getPrototype.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\nexport default isPlainObject;\n","export default function symbolObservablePonyfill(root) {\n\tvar result;\n\tvar Symbol = root.Symbol;\n\n\tif (typeof Symbol === 'function') {\n\t\tif (Symbol.observable) {\n\t\t\tresult = Symbol.observable;\n\t\t} else {\n\t\t\tresult = Symbol('observable');\n\t\t\tSymbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n","/* global window */\nimport ponyfill from './ponyfill';\n\nvar root;\n\nif (typeof self !== 'undefined') {\n  root = self;\n} else if (typeof window !== 'undefined') {\n  root = window;\n} else if (typeof global !== 'undefined') {\n  root = global;\n} else if (typeof module !== 'undefined') {\n  root = module;\n} else {\n  root = Function('return this')();\n}\n\nvar result = ponyfill(root);\nexport default result;\n","import isPlainObject from 'lodash-es/isPlainObject';\nimport $$observable from 'symbol-observable';\n\n/**\n * These are private action types reserved by Redux.\n * For any unknown actions, you must return the current state.\n * If the current state is undefined, you must return the initial state.\n * Do not reference these action types directly in your code.\n */\nexport var ActionTypes = {\n  INIT: '@@redux/INIT'\n\n  /**\n   * Creates a Redux store that holds the state tree.\n   * The only way to change the data in the store is to call `dispatch()` on it.\n   *\n   * There should only be a single store in your app. To specify how different\n   * parts of the state tree respond to actions, you may combine several reducers\n   * into a single reducer function by using `combineReducers`.\n   *\n   * @param {Function} reducer A function that returns the next state tree, given\n   * the current state tree and the action to handle.\n   *\n   * @param {any} [preloadedState] The initial state. You may optionally specify it\n   * to hydrate the state from the server in universal apps, or to restore a\n   * previously serialized user session.\n   * If you use `combineReducers` to produce the root reducer function, this must be\n   * an object with the same shape as `combineReducers` keys.\n   *\n   * @param {Function} [enhancer] The store enhancer. You may optionally specify it\n   * to enhance the store with third-party capabilities such as middleware,\n   * time travel, persistence, etc. The only store enhancer that ships with Redux\n   * is `applyMiddleware()`.\n   *\n   * @returns {Store} A Redux store that lets you read the state, dispatch actions\n   * and subscribe to changes.\n   */\n};export default function createStore(reducer, preloadedState, enhancer) {\n  var _ref2;\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {\n    enhancer = preloadedState;\n    preloadedState = undefined;\n  }\n\n  if (typeof enhancer !== 'undefined') {\n    if (typeof enhancer !== 'function') {\n      throw new Error('Expected the enhancer to be a function.');\n    }\n\n    return enhancer(createStore)(reducer, preloadedState);\n  }\n\n  if (typeof reducer !== 'function') {\n    throw new Error('Expected the reducer to be a function.');\n  }\n\n  var currentReducer = reducer;\n  var currentState = preloadedState;\n  var currentListeners = [];\n  var nextListeners = currentListeners;\n  var isDispatching = false;\n\n  function ensureCanMutateNextListeners() {\n    if (nextListeners === currentListeners) {\n      nextListeners = currentListeners.slice();\n    }\n  }\n\n  /**\n   * Reads the state tree managed by the store.\n   *\n   * @returns {any} The current state tree of your application.\n   */\n  function getState() {\n    return currentState;\n  }\n\n  /**\n   * Adds a change listener. It will be called any time an action is dispatched,\n   * and some part of the state tree may potentially have changed. You may then\n   * call `getState()` to read the current state tree inside the callback.\n   *\n   * You may call `dispatch()` from a change listener, with the following\n   * caveats:\n   *\n   * 1. The subscriptions are snapshotted just before every `dispatch()` call.\n   * If you subscribe or unsubscribe while the listeners are being invoked, this\n   * will not have any effect on the `dispatch()` that is currently in progress.\n   * However, the next `dispatch()` call, whether nested or not, will use a more\n   * recent snapshot of the subscription list.\n   *\n   * 2. The listener should not expect to see all state changes, as the state\n   * might have been updated multiple times during a nested `dispatch()` before\n   * the listener is called. It is, however, guaranteed that all subscribers\n   * registered before the `dispatch()` started will be called with the latest\n   * state by the time it exits.\n   *\n   * @param {Function} listener A callback to be invoked on every dispatch.\n   * @returns {Function} A function to remove this change listener.\n   */\n  function subscribe(listener) {\n    if (typeof listener !== 'function') {\n      throw new Error('Expected listener to be a function.');\n    }\n\n    var isSubscribed = true;\n\n    ensureCanMutateNextListeners();\n    nextListeners.push(listener);\n\n    return function unsubscribe() {\n      if (!isSubscribed) {\n        return;\n      }\n\n      isSubscribed = false;\n\n      ensureCanMutateNextListeners();\n      var index = nextListeners.indexOf(listener);\n      nextListeners.splice(index, 1);\n    };\n  }\n\n  /**\n   * Dispatches an action. It is the only way to trigger a state change.\n   *\n   * The `reducer` function, used to create the store, will be called with the\n   * current state tree and the given `action`. Its return value will\n   * be considered the **next** state of the tree, and the change listeners\n   * will be notified.\n   *\n   * The base implementation only supports plain object actions. If you want to\n   * dispatch a Promise, an Observable, a thunk, or something else, you need to\n   * wrap your store creating function into the corresponding middleware. For\n   * example, see the documentation for the `redux-thunk` package. Even the\n   * middleware will eventually dispatch plain object actions using this method.\n   *\n   * @param {Object} action A plain object representing “what changed”. It is\n   * a good idea to keep actions serializable so you can record and replay user\n   * sessions, or use the time travelling `redux-devtools`. An action must have\n   * a `type` property which may not be `undefined`. It is a good idea to use\n   * string constants for action types.\n   *\n   * @returns {Object} For convenience, the same action object you dispatched.\n   *\n   * Note that, if you use a custom middleware, it may wrap `dispatch()` to\n   * return something else (for example, a Promise you can await).\n   */\n  function dispatch(action) {\n    if (!isPlainObject(action)) {\n      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');\n    }\n\n    if (typeof action.type === 'undefined') {\n      throw new Error('Actions may not have an undefined \"type\" property. ' + 'Have you misspelled a constant?');\n    }\n\n    if (isDispatching) {\n      throw new Error('Reducers may not dispatch actions.');\n    }\n\n    try {\n      isDispatching = true;\n      currentState = currentReducer(currentState, action);\n    } finally {\n      isDispatching = false;\n    }\n\n    var listeners = currentListeners = nextListeners;\n    for (var i = 0; i < listeners.length; i++) {\n      var listener = listeners[i];\n      listener();\n    }\n\n    return action;\n  }\n\n  /**\n   * Replaces the reducer currently used by the store to calculate the state.\n   *\n   * You might need this if your app implements code splitting and you want to\n   * load some of the reducers dynamically. You might also need this if you\n   * implement a hot reloading mechanism for Redux.\n   *\n   * @param {Function} nextReducer The reducer for the store to use instead.\n   * @returns {void}\n   */\n  function replaceReducer(nextReducer) {\n    if (typeof nextReducer !== 'function') {\n      throw new Error('Expected the nextReducer to be a function.');\n    }\n\n    currentReducer = nextReducer;\n    dispatch({ type: ActionTypes.INIT });\n  }\n\n  /**\n   * Interoperability point for observable/reactive libraries.\n   * @returns {observable} A minimal observable of state changes.\n   * For more information, see the observable proposal:\n   * https://github.com/tc39/proposal-observable\n   */\n  function observable() {\n    var _ref;\n\n    var outerSubscribe = subscribe;\n    return _ref = {\n      /**\n       * The minimal observable subscription method.\n       * @param {Object} observer Any object that can be used as an observer.\n       * The observer object should have a `next` method.\n       * @returns {subscription} An object with an `unsubscribe` method that can\n       * be used to unsubscribe the observable from the store, and prevent further\n       * emission of values from the observable.\n       */\n      subscribe: function subscribe(observer) {\n        if (typeof observer !== 'object') {\n          throw new TypeError('Expected the observer to be an object.');\n        }\n\n        function observeState() {\n          if (observer.next) {\n            observer.next(getState());\n          }\n        }\n\n        observeState();\n        var unsubscribe = outerSubscribe(observeState);\n        return { unsubscribe: unsubscribe };\n      }\n    }, _ref[$$observable] = function () {\n      return this;\n    }, _ref;\n  }\n\n  // When a store is created, an \"INIT\" action is dispatched so that every\n  // reducer returns their initial state. This effectively populates\n  // the initial state tree.\n  dispatch({ type: ActionTypes.INIT });\n\n  return _ref2 = {\n    dispatch: dispatch,\n    subscribe: subscribe,\n    getState: getState,\n    replaceReducer: replaceReducer\n  }, _ref2[$$observable] = observable, _ref2;\n}","/**\n * Prints a warning in the console if it exists.\n *\n * @param {String} message The warning message.\n * @returns {void}\n */\nexport default function warning(message) {\n  /* eslint-disable no-console */\n  if (typeof console !== 'undefined' && typeof console.error === 'function') {\n    console.error(message);\n  }\n  /* eslint-enable no-console */\n  try {\n    // This error was thrown as a convenience so that if you enable\n    // \"break on all exceptions\" in your console,\n    // it would pause the execution at this line.\n    throw new Error(message);\n    /* eslint-disable no-empty */\n  } catch (e) {}\n  /* eslint-enable no-empty */\n}","/**\n * Composes single-argument functions from right to left. The rightmost\n * function can take multiple arguments as it provides the signature for\n * the resulting composite function.\n *\n * @param {...Function} funcs The functions to compose.\n * @returns {Function} A function obtained by composing the argument functions\n * from right to left. For example, compose(f, g, h) is identical to doing\n * (...args) => f(g(h(...args))).\n */\n\nexport default function compose() {\n  for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {\n    funcs[_key] = arguments[_key];\n  }\n\n  if (funcs.length === 0) {\n    return function (arg) {\n      return arg;\n    };\n  }\n\n  if (funcs.length === 1) {\n    return funcs[0];\n  }\n\n  return funcs.reduce(function (a, b) {\n    return function () {\n      return a(b.apply(undefined, arguments));\n    };\n  });\n}","import createStore from './createStore';\nimport combineReducers from './combineReducers';\nimport bindActionCreators from './bindActionCreators';\nimport applyMiddleware from './applyMiddleware';\nimport compose from './compose';\nimport warning from './utils/warning';\n\n/*\n* This is a dummy function to check if the function name has been altered by minification.\n* If the function has been minified and NODE_ENV !== 'production', warn the user.\n*/\nfunction isCrushed() {}\n\nif (process.env.NODE_ENV !== 'production' && typeof isCrushed.name === 'string' && isCrushed.name !== 'isCrushed') {\n  warning('You are currently using minified code outside of NODE_ENV === \\'production\\'. ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or DefinePlugin for webpack (http://stackoverflow.com/questions/30030031) ' + 'to ensure you have the correct code for your production build.');\n}\n\nexport { createStore, combineReducers, bindActionCreators, applyMiddleware, compose };","import {createStore} from 'redux';\nimport {DependencyError} from './errors';\n\n/**\n * @class ModuleManager\n * @category core\n * @param {Object} object handler\n * @description  Solves modules dependencies\n * @memberof module:core\n */\nexport class ModuleManager {\n  constructor(object) {\n    this.handler = object;\n    this.currentModule = null;\n\n    this.store = createStore((state = [{}, ''], action) => {\n      state[0][action.key] = action.data;\n      state[1] = action.key;\n\n      return state;\n    });\n\n    this.modules = {};\n  }\n\n  /**\n   * @method active\n   * @instance\n   * @description Sets .currentModule to provided module.\n   * @param {Object} module the module to make current\n   * @memberof module:core.ModuleManager\n   */\n  active(module) {\n    this.currentModule = module;\n  }\n\n  /**\n   * @method reset\n   * @instance\n   * @description Set's .currentModule to null.\n   * @memberof module:core.ModuleManager\n   */\n  reset() {\n    this.currentModule = null;\n  }\n\n  /**\n   * @method define\n   * @instance\n   * @description Define the module in manager\n   * @param name The module name\n   * @memberof module:core.ModuleManager\n   */\n  define(name) {\n    this.modules[name] = this.currentModule;\n  }\n\n  /**\n   * @method use\n   * @instance\n   * @description Get the defined module from manager\n   * @param name The module name\n   * @memberof module:core.ModuleManager\n   */\n  use(name) {\n    return this.modules[name];\n  }\n\n  /**\n   * @method set\n   * @instance\n   * @description An alias for .add() <br/><br/>\n   * Use this method if you know that you will overwrite existing dependency.<br/>\n   * Use it in your app, but not in module that you provide to other people.\n   * @param {String} key the key of the dependency\n   * @param {Object} data the value of the dependency\n   * @memberof module:core.ModuleManager\n   */\n  set(key, data) {\n    this.store.dispatch({\n      type: 'ADD',\n      key,\n      data\n    });\n  }\n\n  /**\n   * @method get\n   * @instance\n   * @description Returns dependency in store object, by key.\n   * @param {String} key the key of the dependency\n   * @memberof module:core.ModuleManager\n   * @return {Object|Module}\n   * @throws {DependencyError} if dependency is not in the store\n   * @example <caption>Get the 'hello' dependency</caption>\n   * manager.get('hello'); // -> {world: true}\n   */\n  get(key) {\n    if (!this.store.getState()[0][key]) {\n      throw new DependencyError(\n        'ModuleManager',\n        `Module requires '${key}' dependency`,\n        this.currentModule\n      );\n    }\n\n    return this.store.getState()[0][key];\n  }\n\n  /**\n   * @method has\n   * @instance\n   * @description Returns whether manager has a dependency with the given key\n   * @param {String} key the key of the dependency\n   * @memberof module:core.ModuleManager\n   * @return {Boolean} Promise that is resolved when all promises completed.\n   * @example <caption>Check whether the store has the 'hello' dependency</caption>\n   * manager.has('hello'); // -> true\n   */\n  has(key) {\n    return Boolean(this.store.getState()[0][key]);\n  }\n\n  /**\n   * @method update\n   * @instance\n   * @description Updates deps\n   * @param {Object} [depsMap={}]\n   * @memberof module:core.ModuleManager\n   */\n  update(depsMap = {}) {\n    this.store.subscribe(() => {\n      const [data, changedKey] = this.store.getState();\n      const callback = depsMap[changedKey];\n\n      if (callback) callback(data[changedKey]);\n    });\n  }\n\n  /**\n   * @method add\n   * @alias module:core.ModuleManager#set\n   * @memberof module:core.ModuleManager\n   */\n  add(...data) {\n    console.warn('.add() method is deprecated. Use .set() instead');\n    return this.set(...data);\n  }\n\n  /**\n   * @method require\n   * @instance\n   * @description Require module\n   * @param {String} name Defined name\n   * @param {Function} moduleExecutor Function that returns applied module\n   * @memberof module:core.ModuleManager\n   */\n  require(name, moduleExecutor) {\n    if (this.use(name) === undefined) this.handler.applyModule(moduleExecutor());\n  }\n}\n","import {extend, transformData} from '../utils/index';\nimport {ModuleSystem} from './ModuleSystem';\nimport {ModuleManager} from './ModuleManager';\nimport {ManagerError} from './errors';\n\n/**\n * @class Component\n * @category core\n * @param {Object} [params] - The parameters object.\n * @param {Object} [instructions] - The instructions object.\n * @extends ModuleSystem\n * @memberof module:core\n */\nclass Component extends ModuleSystem {\n  /**\n   * Default values for parameters\n   * @member {Object} module:core.Component#defaults\n   * @static\n   * @default {\n   *   modules: [],\n   *   manager: true\n   * }\n   */\n  static defaults = {\n    modules: null,\n    manager: true\n  };\n\n  /**\n   * Static instructions\n   * @member {Object} module:core.Component#instructions\n   * @static\n   * @default {}\n   */\n  static instructions = {};\n\n  /**\n   * Array of promises that should be resolved before Component is ready.\n   * @member {Array} module:core.Component#_wait\n   * @private\n   */\n  _wait = []; // Collection of promises;\n\n  /**\n   * Collection of `modules`.\n   * @member {Array} module:core.Component#modules\n   * @public\n   */\n  modules = []; // Collection of modules;\n\n  /**\n   * Collection of `child` Components.\n   * @member {Array} module:core.Component#children\n   * @public\n   */\n  children = []; // For keeping children components;\n\n  constructor(params = {}, defaults = Component.defaults, instructions = Component.instructions) {\n    super();\n\n    // Apply polyfilled parameters to .params;\n    this.params = extend(transformData(params, instructions), defaults);\n    if (this.params.manager) this.manager = new ModuleManager();\n\n    this.modules = this.params.modules;\n\n    this.integrateModules();\n  }\n\n  /**\n   * @method wait\n   * @instance\n   * @description Wait for a promise.\n   * @param {Promise} [promise] - The promise that should be added to a queue.\n   * @return {Promise} Promise that is resolved when all promises completed.\n   * @memberof module:core.Component\n   */\n  wait(promise) {\n    if (promise) this._wait.push(promise);\n    return Promise.all(this._wait);\n  }\n\n  /**\n   * @method defer\n   * @instance\n   * @description Execute `func` (Callback) when Component is ready.\n   * @param {Function} func - Callback.\n   * @memberof module:core.Component\n   */\n  defer(func) {\n    if (this.isDeffered) this.wait().then(() => func(this));\n    else func(this);\n  }\n\n  // PARAMETERS\n\n  /**\n   * @method updateParams\n   * @instance\n   * @description Updates parameters of the Component.\n   * @return {Object} Params of this Component\n   * @memberof module:core.Component\n   */\n  updateParams(params = {}) {\n    this.params = extend(params, this.params);\n    return this.params;\n  }\n\n  // COPYING & CLONING\n\n  /**\n   * @method clone\n   * @instance\n   * @description Clone this component\n   * @return {object} a cloned component with all its source component' params copied.\n   * @memberof module:core.Component\n   */\n  clone() {\n    return new this.constructor(this.params).copy(this);\n  }\n\n  /**\n   * @method copy\n   * @instance\n   * @description Copy source native and integrate `modules` to it.\n   * @param {Component} source - Source component that is used for `copy()` action.\n   * @param {Function} [customize] - Callback executed before modules integration process.\n   * @return {this} Component\n   * @memberof module:core.Component\n   */\n  copy(source, customize) {\n    this.params = {...source.params};\n\n    if (source.native) this.native = source.native.clone(source.params);\n    if (customize) customize();\n    this.integrateModules(source);\n\n    return this;\n  }\n\n  /**\n   * @method add\n   * @instance\n   * @description Add a child `Component`.\n   * @param {Component} object - Component that should be added as a `child`.\n   * @return {Promise} Resolved when action is done.\n   * @memberof module:core.Component\n   */\n  add(object) {\n    object.parent = this;\n\n    return new Promise((resolve, reject) => {\n      this.defer(() => {\n        const {native} = object;\n        if (!native) reject();\n\n        const addPromise = this.applyBridge({onAdd: object}).onAdd;\n\n        const resolver = () => {\n          this.native.add(native);\n          this.children.push(object);\n\n          resolve(object);\n        };\n\n        if (addPromise instanceof Promise) addPromise.then(resolver);\n        else resolver();\n      });\n    });\n  }\n\n  /**\n   * @method remove\n   * @instance\n   * @description Remove a child `Component`.\n   * @param {Component} object - Component that should be a **child** of this Component.\n   * @memberof module:core.Component\n   */\n  remove(object) {\n    object.parent = null;\n    this.native.remove(object.native);\n  }\n\n  /**\n   * @method addTo\n   * @instance\n   * @description Adds `this` Component to specified `App`/`Component`.\n   * @param {Component} object - Component that will be a parent of `this`.\n   * @memberof module:core.Component\n   */\n  addTo(object) {\n    return object.add(this);\n  }\n\n  /**\n   * Returns whether the object is `async` (`wait` promises are more than `0`).\n   * @member {Boolean} module:core.Component#isDeffered\n   */\n  get isDeffered() {\n    return this._wait.length > 0;\n  }\n\n  /**\n   * Returns the `ModuleManager` used for this component.\n   * @member {ModuleManager} module:core.Component#manager\n   * @throws {ManagerError}\n   */\n  get manager() {\n    if (this._manager) return this._manager;\n\n    throw new ManagerError(\n      'Component',\n      `ModuleManager is not used in this component. 'manager' parameter should be set as 'true'`,\n      this\n    );\n  }\n\n  set manager(manager) {\n    this._manager = manager;\n  }\n\n  /**\n   * Returns the `native` object used for this component.\n   * @member {Object} module:core.Component#native\n   */\n  get native() {\n    return this._native;\n  }\n\n  set native(mesh) {\n    this._native = mesh;\n    this._native.component = this;\n    return this._native;\n  }\n}\n\nexport {\n  Component\n};\n","export function attributes(...mappers) {\n  return function (target) {\n    for (let i = 0; i < mappers.length; i++) {\n      const mapper = mappers[i];\n\n      for (let k = 0; k < mapper.map.length; k++) {\n        const attribute = mapper.map[k];\n\n        Object.defineProperty(target.prototype, attribute, {\n          get: mapper.getter(attribute),\n          set: mapper.setter(attribute),\n          configurable: mapper.configurable,\n          enumerable: mapper.enumerable\n        });\n      }\n    }\n  };\n}\n\nexport function copy(...map) {\n  return {\n    map,\n    getter(name) {\n      return function () {\n        return this.native[name];\n      };\n    },\n    setter(name) {\n      return function (value) {\n        this.native[name].copy(value);\n      };\n    },\n    configurable: true,\n    enumerable: true\n  };\n}\n\nexport function mirror(...map) {\n  return {\n    map,\n    getter(name) {\n      return function () {\n        return this.native[name];\n      };\n    },\n    setter(name) {\n      return function (value) {\n        this.native[name] = value;\n      };\n    },\n    configurable: true,\n    enumerable: true\n  };\n}\n","import {Mesh} from 'three';\nimport {Component} from './Component';\n\nimport {attributes, copy, mirror} from './prototype/attributes';\nimport {CompositionError} from './errors';\n\n@attributes(\n  copy('position', 'rotation', 'quaternion', 'scale'),\n  mirror('material', 'geometry')\n)\n/**\n * @class MeshComponent\n * @category core\n * @param {Object} [params] - The parameters object.\n * @param {Object} [instructions] - The instructions object.\n * @extends module:core.Component\n * @memberof module:core\n */\nclass MeshComponent extends Component {\n  /**\n   * Default values for parameters\n   * @member {Object} module:core.MeshComponent#defaults\n   * @static\n   * @default\n   * {\n   *   build: true,\n   *   geometry: {},\n   *   material: false,\n   *\n   *   shadow: {\n   *     cast: true,\n   *     receive: true\n   *   },\n   *\n   *   position: {x: 0, y: 0, z: 0},\n   *   rotation: {x: 0, y: 0, z: 0},\n   *   scale: {x: 1, y: 1, z: 1}\n   * }\n   */\n  static defaults = {\n    ...Component.defaults,\n\n    build: true,\n    geometry: {},\n    material: false,\n\n    shadow: {\n      cast: true,\n      receive: true\n    },\n\n    position: {x: 0, y: 0, z: 0},\n    rotation: {x: 0, y: 0, z: 0},\n    scale: {x: 1, y: 1, z: 1}\n  };\n\n  /**\n   * Static instructions\n   * @member {Object} module:core.MeshComponent#instructions\n   * @static\n   * @default\n   * {\n   *   position: ['x', 'y', 'z'],\n   *   rotation: ['x', 'y', 'z'],\n   *   scale: ['x', 'y', 'z']\n   * }\n   */\n  static instructions = {\n    position: ['x', 'y', 'z'],\n    rotation: ['x', 'y', 'z'],\n    scale: ['x', 'y', 'z']\n  };\n\n  // CUSTOM GEOMETRY HANDLING\n\n  static custom(geom, constructor = Mesh) {\n    return class extends MeshComponent {\n      build(params = this.params) {\n        const {geometry, material} = this.applyBridge({\n          geometry: geom,\n          material: params.material\n        });\n\n        return this.applyBridge({mesh: new constructor(geometry, material)}).mesh;\n      }\n    };\n  }\n\n  static create(geom, params, constructor) {\n    return new (MeshComponent.custom(geom, constructor))(params);\n  }\n\n  constructor(params, defaults = MeshComponent.defaults, instructions = MeshComponent.instructions) {\n    super(params, defaults, instructions);\n\n    if (this.params.build) {\n      const build = this.build(this.params);\n\n      if (!build) {\n        throw new CompositionError(\n          'MeshComponent',\n          '.build() method should return a THREE.Object3D or a Promise resolved with THREE.Object3D.',\n          this\n        );\n      }\n\n      if (build instanceof Promise) {\n        this.wait(build);\n\n        this.wait(new Promise(resolve => {\n          build.then(native => {\n            this.native = native;\n            this.wrap().then(resolve);\n          });\n        }));\n      } else {\n        this.native = build;\n        this.wait(this.wrap());\n      }\n    }\n\n    this.applyCommand('postIntegrate');\n  }\n\n  // BUILDING & WRAPPING\n\n  /**\n   * @method build\n   * @description Build livecycle should return a native object.\n   * @throws {CompositionError}\n   * @memberof module:core.MeshComponent\n   */\n  build() {\n    throw new CompositionError(\n      'MeshComponent',\n      'Instance should have it\\'s own .build().',\n      this\n    );\n  }\n\n  /**\n   * @method wrap\n   * @instance\n   * @description Wraps transforms (`position` & `rotation`)\n   * @return {Promise} Resolved when action is completed\n   * @memberof module:core.MeshComponent\n   */\n  wrap() {\n    return new Promise(resolve => {\n      // TODO: Fix defer with physics\n      // this.defer(() => {\n      const {position, rotation, scale, shadow} = this.params;\n\n      this.position.set(position.x, position.y, position.z);\n      this.rotation.set(rotation.x, rotation.y, rotation.z);\n      this.scale.set(scale.x, scale.y, scale.z);\n\n      this.native.castShadow = shadow.cast;\n      this.native.receiveShadow = shadow.receive;\n\n      this.applyBridge({onWrap: 1});\n\n      resolve(this);\n      // });\n    });\n  }\n\n  // COPYING & CLONING\n\n  /**\n   * @method copy\n   * @instance\n   * @description Copy source transforms & execute `Component.copy()`\n   * @return {this} MeshComponent\n   * @memberof module:core.MeshComponent\n   */\n  copy(source) {\n    return super.copy(source, () => {\n      this.position.copy(source.position);\n      this.rotation.copy(source.rotation);\n      this.quaternion.copy(source.quaternion);\n    });\n  }\n\n  /**\n   * @method clone\n   * @instance\n   * @description Make a clone of this MeshComponent using `.copy()`\n   * @return {MeshComponent} clone of this object\n   * @memberof module:core.MeshComponent\n   */\n  clone(geometry, material) {\n    const dest = new this.constructor({build: false}).copy(this);\n\n    if (geometry) dest.geometry = dest.geometry.clone();\n    if (material) dest.material = dest.material.clone();\n\n    return dest;\n  }\n}\n\nexport {\n  MeshComponent\n};\n","import {Component} from './Component';\n\nimport {attributes, copy} from './prototype/attributes';\nimport {CompositionError} from './errors';\n\n@attributes(\n  copy('position', 'rotation', 'quaternion', 'target')\n)\n/**\n * @class LightComponent\n * @category core\n * @param {Object} [params] - The parameters object.\n * @param {Object} [instructions] - The instructions object.\n * @extends module:core.Component\n * @memberof module:core\n */\nclass LightComponent extends Component {\n  /**\n   * Default values for parameters\n   * @member {Object} module:core.LightComponent#defaults\n   * @static\n   * @default\n   * {\n   *   build: true,\n   *\n   *   shadow: {\n   *     cast: true,\n   *\n   *     bias: 0,\n   *     radius: 1,\n   *\n   *     mapSize: {\n   *       width: 1024,\n   *       height: 1024\n   *     },\n   *\n   *     camera: {\n   *       near: true,\n   *       far: 400,\n   *       fov: 90,\n   *\n   *       top: 200,\n   *       bottom: -200,\n   *       left: -200,\n   *       right: 200\n   *     }\n   *   },\n   *\n   *   position: {x: 0, y: 0, z: 0},\n   *   rotation: {x: 0, y: 0, z: 0}\n   * }\n   */\n  static defaults = {\n    ...Component.defaults,\n\n    build: true,\n\n    shadow: {\n      cast: true,\n\n      bias: 0,\n      radius: 1,\n\n      mapSize: {\n        width: 1024,\n        height: 1024\n      },\n\n      camera: {\n        near: true,\n        far: 400,\n        fov: 90,\n\n        top: 200,\n        bottom: -200,\n        left: -200,\n        right: 200\n      }\n    },\n\n    position: {x: 0, y: 0, z: 0},\n    rotation: {x: 0, y: 0, z: 0}\n  };\n\n  /**\n   * Static instructions\n   * @member {Object} module:core.LightComponent#instructions\n   * @static\n   * @default\n   * {\n   *   position: ['x', 'y', 'z'],\n   *   rotation: ['x', 'y', 'z']\n   * }\n   */\n  static instructions = {\n    position: ['x', 'y', 'z'],\n    rotation: ['x', 'y', 'z']\n  };\n\n  constructor(params, defaults = LightComponent.defaults, instructions = LightComponent.instructions) {\n    super(params, defaults, instructions);\n\n    if (this.params.build) {\n      const build = this.build(this.params);\n\n      if (!build) {\n        throw new CompositionError(\n          'LightComponent',\n          '.build() method should return a THREE.Object3D or a Promise resolved with THREE.Object3D.',\n          this\n        );\n      }\n\n      if (build instanceof Promise) {\n        build.then(native => {\n          this.native = native;\n        });\n      } else this.native = build;\n\n      this.wait(this.wrap());\n    }\n\n    this.applyCommand('postIntegrate');\n  }\n\n  // BUILDING & WRAPPING\n\n  /**\n   * @method build\n   * @instance\n   * @description Build livecycle should return a native object.\n   * @throws {CompositionError}\n   * @memberof module:core.LightComponent\n   */\n  build() {\n    throw new CompositionError(\n      'MeshComponent',\n      'Instance should have it\\'s own .build().',\n      this\n    );\n  }\n\n  /**\n   * @method wrap\n   * @instance\n   * @description Wraps transforms (`position` & `rotation`)\n   * @return {Promise} Resolved when action is completed\n   * @memberof module:core.LightComponent\n   */\n  wrap() {\n    return new Promise(resolve => {\n      this.defer(() => {\n        const {position, rotation} = this.params;\n\n        this.position.set(position.x, position.y, position.z);\n        this.rotation.set(rotation.x, rotation.y, rotation.z);\n\n        this.applyBridge({onWrap: 1});\n\n        resolve(this);\n      });\n    });\n  }\n\n  /**\n   * @method wrapShadow\n   * @instance\n   * @description Wraps shadow properties\n   * @memberof module:core.LightComponent\n   */\n  wrapShadow() {\n    const {native, params: {shadow}} = this;\n\n    native.castShadow = shadow.cast;\n    native.shadow.mapSize.width = shadow.mapSize.width;\n    native.shadow.mapSize.height = shadow.mapSize.height;\n    native.shadow.bias = shadow.bias;\n    native.shadow.radius = shadow.radius;\n\n    const shadowCamera = native.shadow.camera;\n    const camera = shadow.camera;\n\n    shadowCamera.near = camera.near;\n    shadowCamera.far = camera.far;\n    shadowCamera.fov = camera.fov;\n\n    shadowCamera.left = camera.left;\n    shadowCamera.right = camera.right;\n    shadowCamera.top = camera.top;\n    shadowCamera.bottom = camera.bottom;\n  }\n\n  // COPYING & CLONING\n\n  /**\n   * @method copy\n   * @instance\n   * @description Copy source transforms & execute `Component.copy()`\n   * @return {this} LightComponent\n   * @memberof module:core.LightComponent\n   */\n  copy(source) {\n    return super.copy(source, () => {\n      if (this.target) this.target.copy(source.target());\n\n      this.position.copy(source.position);\n      this.rotation.copy(source.rotation);\n      this.quaternion.copy(source.quaternion);\n    });\n  }\n\n  /**\n   * @method clone\n   * @instance\n   * @description Make a clone of this LightComponent using `.copy()`\n   * @return {LightComponent} clone of this object\n   * @memberof module:core.LightComponent\n   */\n  clone() {\n    return new this.constructor({build: false}).copy(this);\n  }\n}\n\nexport {\n  LightComponent\n};\n","import {Component} from './Component';\n\nimport {attributes, copy} from './prototype/attributes';\nimport {CompositionError} from './errors';\n\n@attributes(\n  copy('position', 'rotation', 'quaternion', 'target')\n)\n/**\n * @class CameraComponent\n * @category core\n * @param {Object} [params] - The parameters object.\n * @param {Object} [instructions] - The instructions object.\n * @extends module:core.Component\n * @memberof module:core\n */\nclass CameraComponent extends Component {\n  /**\n   * Default values for parameters\n   * @member {Object} module:core.CameraComponent#defaults\n   * @static\n   * @default\n   * {\n   *   build: true,\n   *\n   *   position: {x: 0, y: 0, z: 0},\n   *   rotation: {x: 0, y: 0, z: 0}\n   * }\n   */\n  static defaults = {\n    ...Component.defaults,\n\n    build: true,\n\n    position: {x: 0, y: 0, z: 0},\n    rotation: {x: 0, y: 0, z: 0}\n  };\n\n  /**\n   * Static instructions\n   * @member {Object} module:core.CameraComponent#instructions\n   * @static\n   * @default\n   * {\n   *   position: ['x', 'y', 'z'],\n   *   rotation: ['x', 'y', 'z'],\n   *   scale: ['x', 'y', 'z']\n   * }\n   */\n  static instructions = {\n    position: ['x', 'y', 'z'],\n    rotation: ['x', 'y', 'z'],\n    scale: ['x', 'y', 'z']\n  };\n\n  constructor(params, defaults = CameraComponent.defaults, instructions = CameraComponent.instructions) {\n    super(params, defaults, instructions);\n\n    if (this.params.build) {\n      const build = this.build(this.params);\n\n      if (!build) {\n        throw new CompositionError(\n          'CameraComponent',\n          '.build() method should return a THREE.Object3D or a Promise resolved with THREE.Object3D.',\n          this\n        );\n      }\n\n      if (build instanceof Promise) {\n        build.then(native => {\n          this.native = native;\n        });\n      } else this.native = build;\n\n      this.wait(this.wrap());\n    }\n\n    this.applyCommand('postIntegrate');\n  }\n\n  // BUILDING & WRAPPING\n\n  /**\n   * @method build\n   * @instance\n   * @description Build livecycle should return a native object.\n   * @throws {CompositionError}\n   * @memberof module:core.CameraComponent\n   */\n  build() {\n    throw new CompositionError(\n      'CameraComponent',\n      'Instance should have it\\'s own .build().',\n      this\n    );\n  }\n\n  /**\n   * @method wrap\n   * @instance\n   * @description Wraps transforms (`position` & `rotation`)\n   * @return {Promise} Resolved when action is completed\n   * @memberof module:core.CameraComponent\n   */\n  wrap() {\n    return new Promise(resolve => {\n      this.defer(() => {\n        this.position.set(this.params.position.x, this.params.position.y, this.params.position.z);\n        this.rotation.set(this.params.rotation.x, this.params.rotation.y, this.params.rotation.z);\n\n        this.applyBridge({onWrap: 1});\n\n        resolve(this);\n      });\n    });\n  }\n\n  /**\n   * @method copy\n   * @instance\n   * @description Copy source transforms & execute `Component.copy()`\n   * @return {this} CameraComponent\n   * @memberof module:core.CameraComponent\n   */\n  copy(source) {\n    return super.copy(source, () => {\n      if (this.target) this.target.copy(source.target());\n\n      this.position.copy(source.position);\n      this.rotation.copy(source.rotation);\n      this.quaternion.copy(source.quaternion);\n    });\n  }\n\n  /**\n   * @method clone\n   * @instance\n   * @description Make a clone of this CameraComponent using `.copy()`\n   * @return {CameraComponent} clone of this object\n   * @memberof module:core.CameraComponent\n   */\n  clone() {\n    return new this.constructor({build: false}).copy(this);\n  }\n}\n\nexport {\n  CameraComponent\n};\n","module.exports = function () {\n  var time = process.hrtime();\n  return time[0] * 1e3 + time[1] / 1e6;\n};\n","import present from 'present';\n\nexport const system = {\n  window: typeof window === 'undefined' ? global : window\n};\n\nif (typeof global !== 'undefined') {\n  global.performance = {\n    now: present\n  };\n}\n","import {version} from '../../package.json';\nimport {system} from '../polyfill';\nimport {ModuleSystem} from './ModuleSystem';\nimport {ModuleManager} from './ModuleManager';\n\n/**\n * @class App\n * @category core\n * @description This component is used to prepare a world scene, setup physics, camera, renderer and all other things that you usually do before making meshes.\n * @param {Array} [modules=[]] - Array of Modules\n * @extends ModuleSystem\n * @memberof module:core\n */\nclass App extends ModuleSystem {\n  /**\n   * Simulate flag\n   * @description Same as .updateEnabled, but for physics. Defines if physics is simulated each frame.\n   * @member {Boolean} module:core.App#simulate\n   * @public\n   */\n  simulate = false;\n\n  /**\n   * @description Defines whether the scene should render or not\n   * @member {Boolean} module:core.App#updateEnabled\n   * @public\n   */\n  updateEnabled = true;\n  /**\n   * Loops in this app\n   * @description Array of loops that are executed by this app.\n   * @member {Array} module:core.App#loops\n   * @public\n   */\n  loops = [];\n\n  constructor(modules = []) {\n    console.log(`WHS.App ${version}`);\n\n    super();\n    this.manager = new ModuleManager(this);\n    this.modules = modules;\n\n    this.integrateModules();\n  }\n\n  // CONTROLS & UPDATING\n\n  /**\n   * @method start\n   * @description Start rendering loop and physics simulation (if you use version with physics).\n   * @memberof module:core.App\n   */\n  start() {\n    const requestAnimFrame = (() => {\n      return system.window.requestAnimationFrame\n        || system.window.webkitRequestAnimationFrame\n        || system.window.mozRequestAnimationFrame\n        || function (callback) {\n          system.window.setTimeout(callback, 1000 / 60);\n        };\n    })();\n\n    const {loops, updateEnabled} = this;\n\n    function process() {\n      requestAnimFrame(process);\n      if (!updateEnabled) return;\n\n      for (let i = 0, ll = loops.length; i < ll; i++) {\n        const e = loops[i];\n        if (e.enabled) e.execute(e.clock);\n      }\n    }\n\n    this.updateEnabled = true;\n    process();\n  }\n\n  /**\n   * @method stop\n   * @description Stops rendering loops\n   * @memberof module:core.App\n   */\n  stop() {\n    this.updateEnabled = false;\n  }\n\n  /**\n   * @method addLoop\n   * @description Adds loop to this app.\n   * @param {Object} loop - the loop to add\n   * @return {Promise} Promise that is resolved when promises completed.\n   * @memberof module:core.App\n   * @example <caption>Adding a loop to an app</caption>\n   * const loop = new Loop(() => {\n   *  // ...\n   * });\n   *\n   * const app = new App();\n   *\n   * app.addLoop(loop);\n   * loop.start();\n   */\n  addLoop(loop) {\n    return new Promise(resolve => {\n      this.loops.push(loop);\n      resolve(loop);\n    });\n  }\n\n  /**\n   * @method removeLoop\n   * @description Removes loop from this app.\n   * @param {Object} loop - the loop to remove\n   * @return {Promise} Promise that is resolved when promises completed.\n   * @memberof module:core.App\n   */\n  removeLoop(loop) {\n    return new Promise(resolve => {\n      const index = this.loops.indexOf(loop);\n      if (index !== -1) this.loops.splice(index, 1);\n\n      resolve(loop);\n    });\n  }\n\n  get(key) {\n    return this.manager.get(key);\n  }\n\n  use(key) {\n    return this.manager.use(key);\n  }\n}\n\nexport {\n  App\n};\n","import {Clock} from 'three';\n\n/**\n * @class Loop\n * @category core\n * @param {Function} func function to execute on each animation frame\n * @param {Boolean} [useClock=true] passes a Clock to the function when called, if true\n * @memberof module:core\n */\nclass Loop {\n  constructor(func, useClock = true) {\n    this.func = func;\n    this.clock = useClock ? new Clock() : null;\n    this.enabled = false;\n  }\n\n  // CONTROLS\n\n  /**\n   * @method start\n   * @instance\n   * @description Starts this loop, clock if it has one. Won't do anything if loop enabled already.\n   * @param {Component} [world] app to add this loop to, if provided.\n   * @memberof module:core.Loop\n   */\n  start(world) {\n    if (this.enabled) return;\n\n    if (world) world.addLoop(this);\n\n    if (this.clock) this.clock.start();\n    this.enabled = true;\n  }\n\n  /**\n   * @method stop\n   * @instance\n   * @description Stops this loop and its clock if it has one, won't do anything if this loop is not enabled)\n   * @param {Component} [world] app to remove this loop from, if provided.\n   * @memberof module:core.Loop\n   */\n  stop(world) {\n    if (!this.enabled) return;\n\n    if (this.clock) this.clock.stop();\n    this.enabled = false;\n\n    if (world) world.removeLoop(this);\n  }\n\n  // EXECUTION\n\n  /**\n   * @method execute\n   * @instance\n   * @description Executes the function of this loop\n   * @memberof module:core.Loop\n   * @returns {*} whatever the function of this loop returns\n   */\n  execute() {\n    return this.func(this.clock);\n  }\n}\n\nexport {\n  Loop\n};\n","/** @module core */\nexport * from './Component';\nexport * from './MeshComponent';\nexport * from './LightComponent';\nexport * from './CameraComponent';\nexport * from './App';\nexport * from './Loop';\nexport * from './ModuleManager';\n","import {AmbientLight as AmbientLightNative} from 'three';\nimport {LightComponent} from '../../core/LightComponent';\n\n/**\n * @class AmbientLight\n * @category components/lights\n * @description AmbientLight is a simple class, it extends Light and inherits all its methods.\n * AmbientLight creates basic light around all scene, so it doesn't need properties like pos or target.\n * It supports only color and intensity as parameters, which defines the color of the surrounded light and intensity of light.\n * @param {Object} [params={light: {color: 0xffffff, intensity: 1}}] - The params.\n * @extends module:core.LightComponent\n * @memberof module:components/lights\n * @example <caption>Creating an AmbientLight </caption>\n * new AmbientLight({\n *   color: 0xffffff,\n *   intensity: 0.2\n * }).addTo(world);\n */\nclass AmbientLight extends LightComponent {\n  static defaults = {\n    ...LightComponent.defaults,\n\n    color: 0xffffff,\n    intensity: 1\n  };\n\n  constructor(params = {}) {\n    super(params, AmbientLight.defaults);\n  }\n\n  build(params = {}) {\n    return this.applyBridge({light: new AmbientLightNative(\n      params.color,\n      params.intensity\n    )}).light;\n  }\n}\n\nexport {\n  AmbientLight\n};\n","import {DirectionalLight as DirectionalLightNative, DirectionalLightHelper} from 'three';\nimport {LightComponent} from '../../core/LightComponent';\n\n/**\n * @class DirectionalLight\n * @category components/lights\n * @description DirectinalLight creates a light that shines from a specific direction not from a specific position.<br/><br/>\n * This light will behave as though it is infinitely far away and the rays produced from it are all parallel. <br/><br/>\n * The best analogy would be a light source that acts like the sun: the sun is so far away that all sunlight hitting objects comes from the same angle.<br/><br/>\n * It has the same options as AmbientLight in light paramater, but it also supports pos and target paramaters.\n * @param {Object} [params={light: {color: 0xffffff, intensity: 1}}] - The params.\n * @extends module:core.LightComponent\n * @memberof module:components/lights\n * @example <caption>Creating a DirectionalLight to fall down from vec3(10, 20, 10) to vec3(0, 0, 0)</caption>\n * new DirectionalLight({\n *   color: 0xffffff,\n *   intensity: 0.2,\n *\n *   position: [10, 20, 10]\n * }).addTo(app);\n */\nclass DirectionalLight extends LightComponent {\n  static defaults = {\n    ...LightComponent.defaults,\n\n    color: 0xffffff,\n    intensity: 1\n  };\n\n  constructor(params = {}) {\n    super(params, DirectionalLight.defaults);\n    this.wrapShadow();\n  }\n\n  build(params = {}) {\n    return this.applyBridge({light: new DirectionalLightNative(\n      params.color,\n      params.intensity\n    )}).light;\n  }\n}\n\nexport {\n  DirectionalLight\n};\n","import {HemisphereLight as HemisphereLightNative, HemisphereLightHelper} from 'three';\nimport {LightComponent} from '../../core/LightComponent';\n\n/**\n * @class HemisphereLight\n * @category components/lights\n * @description HemisphereLight is a light source positioned directly above the scene.<br/>\n * It also doesn't need position and target properties.\n * @classDesc\n * <iframe src=\"https://threejs.org/examples/webgl_lights_hemisphere.html\"></iframe>\n * @param {Object} [params={light: {skyColor: 0xffffff, groundColor: 0xffffff, intensity: 1}}] - The params.\n * @extends module:core.LightComponent\n * @memberof module:components/lights\n * @example <caption>Creating a HemisphereLight</caption>\n * new HemisphereLight({\n *   skyColor: 0xff0000,\n *   groundColor: 0x0000ff,\n *   intensity: 0.2\n * }).addTo(app);\n */\nclass HemisphereLight extends LightComponent {\n  static defaults = {\n    ...LightComponent.defaults,\n\n    skyColor: 0xffffff,\n    groundColor: 0xffffff,\n    intensity: 1\n  }\n\n  constructor(params = {}) {\n    super(params, HemisphereLight.defaults);\n  }\n\n  build(params = {}) {\n    return this.applyBridge({light: new HemisphereLightNative(\n      params.skyColor,\n      params.groundColor,\n      params.intensity\n    )}).light;\n  }\n}\n\nexport {\n  HemisphereLight\n};\n","import {PointLight as PointLightNative, PointLightHelper} from 'three';\nimport {LightComponent} from '../../core/LightComponent';\n\n/**\n * @class PointLight\n * @category components/lights\n * @description PointLight creates a light at a specific position in the scene. The light shines in all directions (roughly similar to a light bulb.)<br/><br/>\n * It has the same options as AmbientLight in light paramater, but it also supports position, distance and decay.<br/>\n * @param {Object} [params={light: {color: 0xffffff, intensity: 1, distance: 100, decay: 1}}] - The params.\n * @extends LightComponent\n * @memberof module:components/lights\n * @example <caption>Creating a PointLight</caption>\n * new PointLight( {\n *   color: 0xff0000,\n *   intensity: 2,\n *   distance: 300\n *\n *   position: [10, 20, 10]\n * }).addTo(app);\n */\nclass PointLight extends LightComponent {\n  static defaults= {\n    ...LightComponent.defaults,\n\n    color: 0xffffff,\n    intensity: 1,\n    distance: 100,\n    decay: 1\n  }\n\n  constructor(params = {}) {\n    super(params, PointLight.defaults);\n    this.wrapShadow();\n  }\n\n  build(params = {}) {\n    return this.applyBridge({light: new PointLightNative(\n      params.color,\n      params.intensity,\n      params.distance,\n      params.decay\n    )}).light;\n  }\n}\n\nexport {\n  PointLight\n};\n","import {SpotLight as SpotLightNative} from 'three';\nimport {LightComponent} from '../../core/LightComponent';\n\n/**\n * @class SpotLight\n * @category components/lights\n * @description SpotLight creates spot light that can cast shadow in one direction. <br/><br/>\n * It has the same parameters as AmbientLight in light, but it also supports pos and target. <br/><br/>\n * SpotLight affects meshes with lambert and phong material.\n * @classDesc\n * <iframe src=\"https://threejs.org/examples/webgl_lights_spotlight.html\"></iframe>\n * @param {Object} [params={light: {color: 0xffffff, intensity: 1, distance: 100, angle: Math.PI / 3, exponent: 0, decay: 1}}] - The params.\n * @extends module:core.LightComponent\n * @memberof module:components/lights\n * @example <caption>Creating a SpotLight that falls down from vec3(10, 20, 10) to vec3(0, 0, 0)</caption>\n * new SpotLight({\n *   color: 0x00ff00,\n *   intensity: 3,\n *   distance: 1000\n *\n *   position: [10, 20, 10]\n * }).addTo(app);\n */\nclass SpotLight extends LightComponent {\n  static defaults = {\n    ...LightComponent.defaults,\n\n    color: 0xffffff,\n    intensity: 1,\n    distance: 100,\n    angle: Math.PI / 3,\n    exponent: 0,\n    decay: 1\n  };\n\n  constructor(params = {}) {\n    super(params, SpotLight.defaults);\n    this.wrapShadow();\n  }\n\n  build(params = {}) {\n    return this.applyBridge({light: new SpotLightNative(\n      params.color,\n      params.intensity,\n      params.distance,\n      params.angle,\n      params.exponent,\n      params.decay\n    )}).light;\n  }\n}\n\nexport {\n  SpotLight\n};\n","import {RectAreaLight as RectAreaLightNative} from 'three';\nimport {LightComponent} from '../../core/LightComponent';\n\nclass AreaLight extends LightComponent {\n  static defaults = {\n    ...LightComponent.defaults,\n\n    color: 0xffffff,\n    intensity: 1,\n    width: 10,\n    height: 10\n  };\n\n  constructor(params = {}) {\n    super(params, AreaLight.defaults);\n  }\n\n  build(params = {}) {\n    return this.applyBridge({light: new RectAreaLightNative(\n      params.color,\n      params.intensity,\n      params.width,\n      params.height\n    )}).light;\n  }\n}\n\nexport {\n  AreaLight\n};\n","/** @module components/lights */\nexport * from './AmbientLight';\nexport * from './DirectionalLight';\nexport * from './HemisphereLight';\nexport * from './PointLight';\nexport * from './SpotLight';\nexport * from './AreaLight';\n","import {CubeCamera as CubeCameraNative} from 'three';\nimport {CameraComponent} from '../../core/CameraComponent';\n\n/**\n * @class CubeCamera\n * @category components/cameras\n * @description Creates 6 cameras that render to a WebGLRenderTargetCube\n * @param {Object} [params] - The parameters object.\n * @memberof module:components/cameras\n * @extends module:core.CameraComponent\n * @example <caption>Creates a CubeCamera and set it as app's camera</caption>\n * const camera = new CubeCamera({\n *   camera: {\n *     cubeResolution: 256\n *   },\n *\n *   position: {\n *     x: 0,\n *     y: 100,\n *     z: 0\n *   }\n * });\n *\n * app.camera = camera;\n */\nclass CubeCamera extends CameraComponent {\n\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/cameras.CubeCamera#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   camera: {\n   *     near: 1,\n   *     far: 1000,\n   *     cubeResolution: 128\n   *   }\n   * }</pre>\n   */\n  static defaults = {\n    ...CameraComponent.defaults,\n\n    near: 1,\n    far: 1000,\n    cubeResolution: 128\n  };\n\n  constructor(params = {}) {\n    super(params, CubeCamera.defaults);\n  }\n\n  build(params = {}) {\n    return this.applyBridge({camera: new CubeCameraNative(\n      params.near,\n      params.far,\n      params.cubeResolution\n    )}).camera;\n  }\n}\n\nexport {\n  CubeCamera\n};\n","import {OrthographicCamera as OrthographicCameraNative} from 'three';\nimport {CameraComponent} from '../../core/CameraComponent';\nimport {system} from '../../polyfill';\n\n/**\n * @class OrthographicCamera\n * @category components/cameras\n * @description Camera with orthographic projection.\n * @param {Object} [params] - The parameters object.\n * @memberof module:components/cameras\n * @extends module:core.CameraComponent\n * @example <caption>Create an OrthographicCamera and set it as app's camera</caption>\n * const camera = new OrthographicCamera({\n *   camera: {\n *     far: 10000\n *   },\n *\n *   position: {\n *     y: 50\n *   }\n * });\n *\n * app.camera = camera;\n */\nclass OrthographicCamera extends CameraComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/cameras.OrthographicCamera#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   near: 1,\n   *   far: 1000,\n   *   left: system.window.innerWidth / -2,\n   *   right: system.window.innerWidth / 2,\n   *   top: system.window.innerHeight / 2,\n   *   bottom: system.window.innerHeight / -2\n   * }</pre>\n   */\n  static defaults = {\n    ...CameraComponent.defaults,\n\n    near: 1,\n    far: 1000,\n    left: system.window.innerWidth / -2,\n    right: system.window.innerWidth / 2,\n    top: system.window.innerHeight / 2,\n    bottom: system.window.innerHeight / -2\n  };\n\n  constructor(params = {}) {\n    super(params, OrthographicCamera.defaults);\n  }\n\n  build(params = {}) {\n    return this.applyBridge({camera: new OrthographicCameraNative(\n      params.left,\n      params.right,\n      params.top,\n      params.bottom,\n      params.near,\n      params.far\n    )}).camera;\n  }\n}\n\nexport {\n  OrthographicCamera\n};\n","import {PerspectiveCamera as PerspectiveCameraNative} from 'three';\nimport {CameraComponent} from '../../core/CameraComponent';\nimport {system} from '../../polyfill';\n\n/**\n * @class PerspectiveCamera\n * @description Camera with perspective projection.\n * @category components/cameras\n * @param {Object} [params] - The parameters object.\n * @memberof module:components/cameras\n * @extends module:core.CameraComponent\n * @example <caption>Create an PerspectiveCamera and set it as app's camera</caption>\n * const camera = new PerspectiveCamera({\n *   fov: 75,\n *   aspect: window.innerWidth / window.innerHeight,\n *\n *   position: {\n *     x: 0,\n *     y: 100,\n *     z: 0\n *   }\n * });\n *\n * app.camera = camera;\n */\nclass PerspectiveCamera extends CameraComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/cameras.PerspectiveCamera#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   near: 1,\n   *   far: 1000,\n   *   fov: 75,\n   *   aspect: system.window.innerWidth / system.window.innerHeight\n   * }</pre>\n   */\n  static defaults = {\n    ...CameraComponent.defaults,\n\n    near: 1,\n    far: 1000,\n    fov: 75,\n    aspect: system.window.innerWidth / system.window.innerHeight\n  };\n\n  constructor(params = {}) {\n    super(params, PerspectiveCamera.defaults);\n  }\n\n  build(params = {}) {\n    return this.applyBridge({camera: new PerspectiveCameraNative(\n      params.fov,\n      params.aspect,\n      params.near,\n      params.far\n    )}).camera;\n  }\n}\n\nexport {\n  PerspectiveCamera\n};\n","/** @module components/cameras */\nexport * from './CubeCamera';\nexport * from './OrthographicCamera';\nexport * from './PerspectiveCamera';\n","import {\n  Mesh,\n  BoxBufferGeometry,\n  BoxGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Box\n * @category components/meshes\n * @description As told on Component definition, while you can pass any of the inherited params for this component construction, you will need to\n * pass specific parameters to build this mesh as a geometry object.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#BoxGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Box, and adding to app</caption>\n *  new Box({\n *    geometry: {\n *      width: 2,\n *      height: 2,\n *      depth: 2\n *    },\n *\n *    material: new THREE.MeshBasicMaterial({\n *      color: 0xffffff\n *    }),\n *\n *    position: [50, 60, 70]\n * }).addTo(app);\n */\nclass Box extends MeshComponent {\n\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Box#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     width: 1,\n   *     height: 1,\n   *     depth: 1,\n   *     widthSegments: 1,\n   *     heightSegments: 1,\n   *     depthSegments: 1\n   *   }\n   * }</pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      width: 1,\n      height: 1,\n      depth: 1,\n      widthSegments: 1,\n      heightSegments: 1,\n      depthSegments: 1\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Box#instructions\n   * @static\n   * @default geometry: ['width', 'height', 'depth', 'widthSegments', 'heightSegments', 'depthSegements']\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['width', 'height', 'depth', 'widthSegments', 'heightSegments', 'depthSegements']\n  };\n\n  constructor(params = {}) {\n    super(params, Box.defaults, Box.instructions);\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Box\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const geometry = new (params.buffer ? BoxBufferGeometry : BoxGeometry)(\n      params.geometry.width,\n      params.geometry.height,\n      params.geometry.depth,\n      params.geometry.widthSegments,\n      params.geometry.heightSegments,\n      params.geometry.depthSegments\n    );\n\n    return geometry;\n  }\n}\n\nexport {\n  Box\n};\n","import {\n  Mesh,\n  CircleBufferGeometry,\n  CircleGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Circle\n * @category components/meshes\n * @description As told on Component definition, while you can pass any of the inherited params for this component construction, you will need to\n * pass specific parameters to build this mesh as a geometry object.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#CircleGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Circle, and adding to app</caption>\n *  new Circle({\n *    geometry: {\n *      radius: 4,\n *      segments: 16\n *    },\n *\n *    material: new THREE.MeshBasicMaterial({\n *      color: 0xffffff\n *    }),\n *\n *    position: [50, 60, 70]\n * }).addTo(app);\n */\nclass Circle extends MeshComponent {\n\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Circle#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     radius: 50,\n   *     segments: 8,\n   *     thetaStart: 0,\n   *     thetaLength: Math.PI * 2\n   *   }\n   * }</pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n\n    geometry: {\n      radius: 50,\n      segments: 8,\n      thetaStart: 0,\n      thetaLength: Math.PI * 2\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Circle#instructions\n   * @static\n   * @default geometry: ['radius', 'segments', 'thetaStart', 'thetaLength']\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['radius', 'segments', 'thetaStart', 'thetaLength']\n  };\n\n  constructor(params = {}) {\n    super(params, Circle.defaults, Circle.instructions);\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Circle\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const geometry = new (params.buffer ? CircleBufferGeometry : CircleGeometry)(\n      params.geometry.radius,\n      params.geometry.segments,\n      params.geometry.thetaStart,\n      params.geometry.thetaLength\n    );\n\n    return geometry;\n  }\n}\n\nexport {\n  Circle\n};\n","import {\n  Mesh,\n  ConeBufferGeometry,\n  ConeGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Cone\n * @category components/meshes\n * @description A cylinder is one of the most basic curvilinear geometric shapes, the surface formed by the points at a fixed distance from a given straight line, the axis of the cylinder. <br/><br/>\n * The solid enclosed by this surface and by two planes perpendicular to the axis is also called a cylinder.<br/>\n * The surface area and the volume of a cylinder have been known since deep antiquity.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#ConeGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Cone, and adding to app</caption>\n * new Cone({\n *   geometry: {\n *     radiusTop: 2,\n *     radiusBottom: 4,\n *     height: 5\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   pos: [0, 100, 0]\n * }).addTo(app);\n */\nclass Cone extends MeshComponent {\n\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Cone#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     radius: 20,\n   *     height: 100,\n   *     radiusSegments: 32,\n   *     heightSegments: 1,\n   *     openEnded: false,\n   *     thetaStart: 0,\n   *     thetaLength: Math.PI * 2\n   *   }\n   * }</pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n\n    geometry: {\n      radius: 20,\n      height: 100,\n      radiusSegments: 32,\n      heightSegments: 1,\n      openEnded: false,\n      thetaStart: 0,\n      thetaLength: Math.PI * 2\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Cone#instructions\n   * @static\n   * @default <pre>\n   * geometry: [\n   *   'radius',\n   *   'height',\n   *   'radiusSegments',\n   *   'heightSegments',\n   *   'openEnded',\n   *   'thetaStart',\n   *   'thetaLength'\n   * ]\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: [\n      'radius',\n      'height',\n      'radiusSegments',\n      'heightSegments',\n      'openEnded',\n      'thetaStart',\n      'thetaLength'\n    ]\n  };\n\n  constructor(params = {}) {\n    super(params, Cone.defaults, Cone.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Cone\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const geometry = new (params.buffer ? ConeBufferGeometry : ConeGeometry)(\n      params.geometry.radius,\n      params.geometry.height,\n      params.geometry.radiusSegments,\n      params.geometry.heightSegments,\n      params.geometry.openEnded,\n      params.geometry.thetaStart,\n      params.geometry.thetaLength\n    );\n\n    return geometry;\n  }\n}\n\nexport {\n  Cone\n};\n","import {\n  Mesh,\n  CylinderBufferGeometry,\n  CylinderGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Cylinder\n * @category components/meshes\n * @description A cylinder is one of the most basic curvilinear geometric shapes, the surface formed by the points at a fixed distance from a given straight line, the axis of the cylinder. <br/><br/>\n * The solid enclosed by this surface and by two planes perpendicular to the axis is also called a cylinder.<br/>\n * The surface area and the volume of a cylinder have been known since deep antiquity.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#CylinderGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Cylinder, and adding to app</caption>\n * new Cylinder({\n *   geometry: {\n *     radiusTop: 2,\n *     radiusBottom: 4,\n *     height: 5\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   pos: [0, 100, 0]\n * }).addTo(app);\n */\nclass Cylinder extends MeshComponent {\n\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Cylinder#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     radiusTop: 20,\n   *     radiusBottom: 20,\n   *     height: 100,\n   *     radiusSegments: 32,\n   *     heightSegments: 1,\n   *     openEnded: false,\n   *     thetaStart: 0,\n   *     thetaLength: Math.PI * 2\n   *   }\n   * }</pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      radiusTop: 0,\n      radiusBottom: 1,\n      height: 1,\n      radiusSegments: 32,\n      heightSegments: 1,\n      openEnded: false,\n      thetaStart: 0,\n      thetaLength: Math.PI * 2\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Cylinder#instructions\n   * @static\n   * @default <pre>\n   * geometry: [\n   *   'radiusTop',\n   *   'radiusBottom',\n   *   'height',\n   *   'radiusSegments',\n   *   'heightSegments',\n   *   'openEnded',\n   *   'thetaStart',\n   *   'thetaLength'\n   * ]\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: [\n      'radiusTop',\n      'radiusBottom',\n      'height',\n      'radiusSegments',\n      'heightSegments',\n      'openEnded',\n      'thetaStart',\n      'thetaLength'\n    ]\n  };\n\n  constructor(params = {}) {\n    super(params, Cylinder.defaults, Cylinder.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Cylinder\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const geometry = new (params.buffer ? CylinderBufferGeometry : CylinderGeometry)(\n      params.geometry.radiusTop,\n      params.geometry.radiusBottom,\n      params.geometry.height,\n      params.geometry.radiusSegments,\n      params.geometry.heightSegments,\n      params.geometry.openEnded,\n      params.geometry.thetaStart,\n      params.geometry.thetaLength\n    );\n\n    return geometry;\n  }\n}\n\nexport {\n  Cylinder\n};\n","import {\n  Mesh,\n  DodecahedronBufferGeometry,\n  DodecahedronGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Dodecahedron\n * @category components/meshes\n * @description In geometry, a dodecahedron is any polyhedron with twelve flat faces. <br/><br/>\n * The most familiar dodecahedron is the regular dodecahedron, which is a Platonic solid. <br/>\n * There are also three regular star dodecahedra, which are constructed as stellations of the convex form. <br/>\n * All of these have icosahedral symmetry, order 120.\n * Dodecahedron creates Dodecahedron object by it's radius and detail.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#DodecahedronGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Dodecahedron, and adding to app</caption>\n * new Dodecahedron({\n *   geometry: {\n *     radius: 2\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: {\n *     y: 10\n *   }\n  * }).addTo(app);\n */\nclass Dodecahedron extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Dodecahedron#defaults\n   * @static\n   * @default <pre>\n   * geometry: {\n   *   radius: 1,\n   *   detail: 0\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      radius: 1,\n      detail: 0\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Dodecahedron#instructions\n   * @static\n   * @default <pre>\n   * geometry: ['radius', 'detail']\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['radius', 'detail']\n  };\n\n  constructor(params = {}) {\n    super(params, Dodecahedron.defaults, Dodecahedron.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Dodecahedron\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new (params.buffer ? DodecahedronBufferGeometry : DodecahedronGeometry)(\n      params.geometry.radius,\n      params.geometry.detail\n    );\n  }\n}\n\nexport {\n  Dodecahedron\n};\n","import {\n  Mesh,\n  BufferGeometry,\n  ExtrudeGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Extrude\n * @category components/meshes\n * @description Extrude geometry means that you can create a 3D mesh from any 2D shape using three.js geometry based on <a href='https://threejs.org/docs/#api/math/Vector2'>THREE.Vector2.</a> <br/>\n * Such implementation will help you to make volumed shapes that have their own depth and can be seen from all angels.<br/><br/>\n * You can also find some interesting examples made using <a href='threejs.org'>three.js</a> which is a core of whs.js, such as:\n * - <a href='http://threejs.org/examples/webgl_geometry_extrude_shapes.html'>Webgl geometry extrude</a>\n * - <a href='http://threejs.org/examples/webgl_geometry_extrude_shapes2.html'>Extrude shapes from geodata</a>\n * - <a href='http://threejs.org/examples/webgl_geometry_extrude_splines.html'>Extrude splines</a>\n *\n * Such examples can be easily implemented using whitestorm.js or it's plugins. Use `Extrude` class with <a href='https://threejs.org/docs/#api/extras/core/Shape'>THREE.Shape</a> to get extrude effect of shape defined by 2D vectors.\n * This class is similar to <a href='https://threejs.org/docs/#api/geometries/ExtrudeGeometry'>THREE.ExtrudeGeometry</a>,\n * but it also contains all properties, applied by `Shape`, such as material, mass and vectors like position (pos) and rotation (rot).\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#ExtrudeGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a shape, then an Extrude from it</caption>\n * const shape = new THREE.Shape([\n *   new THREE.Vector2(-4,-4),\n *   new THREE.Vector2(-2,0),\n *   new THREE.Vector2(-4,4),\n *   new THREE.Vector2(0,2),\n *   new THREE.Vector2(4,4),\n *   new THREE.Vector2(2,0),\n *   new THREE.Vector2(4,-4),\n *   new THREE.Vector2(0,-2)\n * ]);\n *\n * const extrude = new Extrude({\n *   geometry: {\n *     shapes: shape,\n *     options: {\n *       bevelEnabled: false,\n *       bevelSize: 0,\n *       amount: 2\n *     }\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: [0, 100, 0]\n * });\n *\n * extrude.addTo(app);\n */\nclass Extrude extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Extrude#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     shapes: [],\n   *     options: {}\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      shapes: [],\n      options: {}\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Extrude#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: ['shapes', 'options']\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['shapes', 'options']\n  };\n\n  constructor(params = {}) {\n    super(params, Extrude.defaults, Extrude.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Extrude\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const geometry = new ExtrudeGeometry(\n      params.geometry.shapes,\n      params.geometry.options\n    );\n\n    return params.buffer ? new BufferGeometry().fromGeometry(geometry) : geometry;\n  }\n}\n\nexport {\n  Extrude\n};\n","import {\n  Mesh,\n  IcosahedronBufferGeometry,\n  IcosahedronGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Icosahedron\n * @category components/meshes\n * @description In geometry, an icosahedron is a polyhedron with 20 faces.<br/>\n * There are many kinds of icosahedra, with some being more symmetrical than others. The most well known is the Platonic, convex regular icosahedron.<br/>\n * `Icosahedron` creates an Icosahedron object by its radius and detail.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#IcosahedronGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Icosahedron, and adding to app</caption>\n * new Icosahedron({\n *   geometry: {\n *     radius: 2,\n *     detail: 1\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: [0, 100, 0]\n * }).addTo(app);\n */\nclass Icosahedron extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Icosahedron#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     radius: 1,\n   *     detail: 0\n   *   }\n   * }</pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      radius: 1,\n      detail: 0\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Icosahedron#instructions\n   * @static\n   * @default {geometry: ['radius', 'detail']}\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['radius', 'detail']\n  };\n\n  constructor(params = {}) {\n    super(params, Icosahedron.defaults, Icosahedron.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Icosahedron\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new (params.buffer ? IcosahedronBufferGeometry : IcosahedronGeometry)(\n      params.geometry.radius,\n      params.geometry.detail\n    );\n  }\n}\n\nexport {\n  Icosahedron\n};\n","import {\n  Mesh,\n  LatheBufferGeometry,\n  LatheGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Lathe\n * @category components/meshes\n * @description A `LatheGeometry` allows you to create shapes from a smooth curve.\n * This curve is defined by a number of points (also called knots) and is most often called a spline. This spline is rotated around a fixed point and results in vase- and bell-like shapes.<br/><br/>\n * In 3D computer graphics, a lathed object is a 3D model whose vertex geometry is produced by rotating the points of a spline or other point set around a fixed axis.\n * The lathing may be partial; the amount of rotation is not necessarily a full 360 degrees.\n * The point set providing the initial source data can be thought of as a cross section through the object along a plane containing its axis of radial symmetry. <br/><br/>\n * The <a href='http://threejs.org/docs/scenes/geometry-browser.html#LatheGeometry'>following example</a> shows a geometry which can be generated using `Lathe` class.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#LatheGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Lath, and adding to app</caption>\n * const points = [];\n *\n * for (let i = 0; i < 10; i++) {\n *   points.push(\n *     new THREE.Vector2(\n *       (Math.sin(i * 0.7) * 15 + 50) / 10,\n *       (i - 5) * 0.2\n *     )\n *   );\n * }\n *\n * const lathe = new Lathe({\n *   geometry: {\n *     points: points\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: [0, 50, 10]\n * }).addTo(app);\n */\nclass Lathe extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Lathe#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     points: []\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      points: []\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Lathe#instructions\n   * @static\n   * @default <pre>{\n   *   geometry: ['points']\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['points']\n  };\n\n  constructor(params = {}) {\n    super(params, Lathe.defaults, Lathe.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Lathe\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new (params.buffer ? LatheBufferGeometry : LatheGeometry)(\n      params.geometry.points\n    );\n  }\n}\n\nexport {\n  Lathe\n};\n","import {\n  Line as LineNative,\n  BufferGeometry,\n  Geometry,\n  BufferAttribute,\n  LineCurve3,\n  Vector3\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Line\n * @category components/meshes\n * @description Line component is generated from a curve/line and amount of vectors that should be used (points).\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Line, and adding to app</caption>\n * new Line({\n *   geometry: {\n *     curve: new THREE.LineCurve3(new THREE.Vector3(10, 10, 0), new THREE.Vector3(10, 30, 0))\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   })\n * }).addTo(app);\n */\nclass Line extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Line#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     curve: new LineCurve3(new Vector3(0, 0, 0), new Vector3(10, 0, 0)),\n   *     points: 50\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      curve: new LineCurve3(new Vector3(0, 0, 0), new Vector3(10, 0, 0)),\n      points: 50\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Line#instructions\n   * @static\n   * @default <pre>{\n   *   geometry: ['curve', 'points']\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['curve', 'points']\n  };\n\n  constructor(params) {\n    super(params, Line.defaults, Line.instructions);\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Line\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new LineNative(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const geometry = params.buffer ? new BufferGeometry() : new Geometry();\n\n    if (params.buffer) {\n      const pp = params.geometry.curve.getPoints(params.geometry.points);\n      const verts = new Float32Array(pp.length * 3);\n\n      for (let i = 0, max = pp.length; i < max; i++) {\n        const i3 = i * 3;\n\n        verts[i3] = pp[i].x;\n        verts[i3 + 1] = pp[i].y;\n        verts[i3 + 2] = pp[i].z;\n      }\n\n      geometry.addAttribute('position', new BufferAttribute(verts, 3));\n    } else geometry.vertices = params.geometry.curve.getPoints(params.geometry.points);\n\n    return geometry;\n  }\n}\n\nexport {\n  Line\n};\n","import {\n  Mesh,\n  JSONLoader\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Importer\n * @category components/meshes\n * @description Importer is a loader for meshes and any other data to your scene\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Importer, and adding to app</caption>\n * new Importer({\n *   loader: new THREE.OBJLoader(),\n *\n *   parser(geometry, material) { // data from loader\n *     return new THREE.Mesh(geometry, material); // should return your .native (mesh in this case)\n *   },\n *\n *   position: [0, 100, 0]\n * }).addTo(app);\n */\nclass Importer extends MeshComponent {\n\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Importer#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   url: '',\n   *   loader: new JSONLoader(),\n   *\n   *   onLoad() {},\n   *   onProgress() {},\n   *   onError() {},\n   *\n   *   texturePath: null,\n   *   useCustomMaterial: false,\n   *\n   *   parser(geometry, materials) {\n   *     return new Mesh(geometry, materials);\n   *   }\n   * }</pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n\n    url: '',\n    loader: new JSONLoader(),\n\n    onLoad() {},\n    onProgress() {},\n    onError() {},\n\n    texturePath: null,\n    useCustomMaterial: false,\n\n    parser(geometry, materials) {\n      return new Mesh(geometry, materials);\n    }\n  };\n\n  static instructions = {\n    ...MeshComponent.instructions\n  };\n\n  /**\n   * @method filter\n   * @description Default values for parameters\n   * @static\n   * @param {THREE.Mesh} object Instance for iterating through it's children.\n   * @param {Function} filter Function with child as argument, should return a boolean whether include the child or not.\n   * @return {THREE.Mesh} object with children\n   * @memberof module:components/meshes.Importer\n   * @example <caption>Removing unnecessary lights from children</caption>\n   * new Icosahedron({\n   *   loader: new THREE.OBJLoader(),\n   *\n   *   parse(group) { // data from loader\n   *     return Importer.filter(group, child => !child.isLight); // remove lights\n   *   },\n   *\n   *   position: [0, 100, 0]\n   * }).addTo(app);\n   */\n  static filter(object, filter) {\n    const processFilter = object => {\n      object.children.forEach((el, index) => {\n        if (el.children) processFilter(el);\n        if (!filter(el)) object.children.splice(index, 1);\n      });\n\n      return object;\n    };\n\n    return processFilter(object);\n  }\n\n  constructor(params = {}) {\n    super(params, Importer.defaults, Importer.instructions, false);\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Importer\n   */\n  build(params = {}) {\n    return new Promise(resolve => {\n      if (params.texturePath) params.laoder.setTexturePath(params.texturePath);\n\n      params.loader.load(params.url, (...data) => { // geometry, materials\n        params.onLoad(...data);\n\n        const object = this.applyBridge({mesh: params.parser(...data)}).mesh;\n\n        const {geometry: geom, material: mat} = this.applyBridge({\n          geometry: object.geometry,\n          material: params.useCustomMaterial ? params.material : object.material\n        });\n\n        if (object.geometry) object.geometry = geom;\n        if (object.material) object.material = mat;\n\n        resolve(object);\n      }, params.onProgress, params.onError);\n    });\n  }\n}\n\nexport {\n  Importer\n};\n","import {\n  Mesh,\n  OctahedronBufferGeometry,\n  OctahedronGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Octahedron\n * @category components/meshes\n * @description In geometry, an octahedron is a polyhedron with eight faces.\n * A regular octahedron is a Platonic solid composed of eight equilateral triangles, four of which meet at each vertex.\n * <br/><br/>\n * `Octahedron` creates an Octahedron object by its `radius` and `detail`.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#OctahedronGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating an Octahedron, and adding to app</caption>\n * new Octahedron({\n *   geometry: {\n *     radius: 2,\n *     detail: 1\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: [0, 100, 0]\n * }).addTo(app);\n */\nclass Octahedron extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Octahedron#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     radius: 1,\n   *     detail: 0\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      radius: 1,\n      detail: 0\n    }\n  }\n\n  constructor(params = {}) {\n    super(params, Octahedron.defaults, Octahedron.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Octahedron\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new (params.buffer ? OctahedronBufferGeometry : OctahedronGeometry)(\n      params.geometry.radius,\n      params.geometry.detail\n    );\n  }\n}\n\nexport {\n  Octahedron\n};\n","import {\n  Mesh,\n  ParametricBufferGeometry,\n  ParametricGeometry,\n  Vector3\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Parametric\n * @category components/meshes\n * @description `Parametric` generates a geometry representing a <a href='https://en.wikipedia.org/wiki/Parametric_surface'>Parametric surface</a>\n * <br/><br/>\n * It is usually used to develop different kinds of highfields or visualize a <a href='https://stemkoski.github.io/Three.js/Graphulus-Function.html'>math function</a>.\n * <br/>\n * - <a href='http://math.hws.edu/graphicsbook/source/threejs/curves-and-surfaces.html'>Parametric surface</a>\n * - <a href='https://stemkoski.github.io/Three.js/Graphulus-Surface.html'>\"Graphulus\"</a>\n * <br/><br/>\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#ParametricGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Example creating an heightfield-like geometry. `u` and `v` are like `x` and `y` in shape, but their values are always from `0` to `1`.\n * We use them in `THREE.Vector3` like `x` and `z` and `Math.random() * 5` for `y`.</caption>\n * const createParametric = (u, v) => {\n *   return new THREE.Vector3(u * 30, Math.random() * 5, v * 30);\n * }\n *\n * new Parametric({\n *   geometry: {\n *     func: createParametric\n *   },\n *\n *   material: new THREE.MeshLambertMaterial({\n *     color: 0xffffff,\n *     side: THREE.DoubleSide\n *   }),\n *\n *   position: [0, 100, -100]\n * }).addTo(app);\n */\nclass Parametric extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Parametric#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     func: (u, v) => new Vector3(u, v, 0),\n   *     slices: 10,\n   *     tacks: 10\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      func: (u, v) => new Vector3(u, v, 0),\n      slices: 10,\n      stacks: 10\n    }\n  }\n\n  constructor(params = {}) {\n    super(params, Parametric.defaults, Parametric.instructions);\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Parametric\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new (params.buffer ? ParametricBufferGeometry : ParametricGeometry)(\n      params.geometry.func,\n      params.geometry.slices,\n      params.geometry.stacks\n    );\n  }\n}\n\nexport {\n  Parametric\n};\n","import {\n  Mesh,\n  PlaneBufferGeometry,\n  PlaneGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Plane\n * @category components/meshes\n * @description `Plane` is used for creating planes given some `width` and `height`.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#PlaneGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Plane, and adding to app</caption>\n * new Plane({\n *   geometry: {\n *     width: 20,\n *     height: 30\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   })\n * }).addTo(app);\n */\nclass Plane extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Plane#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     width: 10,\n   *     height: 10,\n   *     wSegments: 1,\n   *     hSegments: 1\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      width: 10,\n      height: 10,\n      wSegments: 1,\n      hSegments: 1\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Plane#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: ['width', 'height', 'wSegments', 'hSegments']\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['width', 'height', 'wSegments', 'hSegments']\n  };\n\n  constructor(params = {}) {\n    super(params, Plane.defaults, Plane.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Plane\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const geometry = new (params.buffer ? PlaneBufferGeometry : PlaneGeometry)(\n      params.geometry.width,\n      params.geometry.height,\n      params.geometry.wSegments,\n      params.geometry.hSegments\n    );\n\n    return geometry;\n  }\n}\n\nexport {\n  Plane\n};\n","import {\n  Mesh,\n  PolyhedronBufferGeometry,\n  PolyhedronGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\nconst [verticesOfCube, indicesOfFaces] = [\n  [\n    -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1,\n    -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1\n  ],\n  [\n    2, 1, 0, 0, 3, 2,\n    0, 4, 7, 7, 3, 0,\n    0, 1, 5, 5, 4, 0,\n    1, 2, 6, 6, 5, 1,\n    2, 3, 7, 7, 6, 2,\n    4, 5, 6, 6, 7, 4\n  ]\n];\n\n/**\n * @class Polyhedron\n * @category components/meshes\n * @description In elementary geometry, a polyhedron is a solid in three dimensions with flat polygonal faces, straight edges and sharp corners or vertices.\n * <br/><br/>\n * `Polyhedron` creates a Polyhedron by its `radius` and `detail`.\n * <br/><br/>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating an Polyhedron, and adding to app</caption>\n * new Polyhedron({\n *   geometry: {\n *     radius: 2,\n *     detail: 1\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: [0, 100, 0]\n * }).addTo(app);\n */\nclass Polyhedron extends MeshComponent {\n  static verticesOfCube = verticesOfCube;\n  static indicesOfFaces = indicesOfFaces;\n\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Polyhedron#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     verticesOfCube: [\n   *       -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1,\n   *       -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1\n   *     ],\n   *\n   *     indicesOfFaces: [\n   *       2, 1, 0, 0, 3, 2,\n   *       0, 4, 7, 7, 3, 0,\n   *       0, 1, 5, 5, 4, 0,\n   *       1, 2, 6, 6, 5, 1,\n   *       2, 3, 7, 7, 6, 2,\n   *       4, 5, 6, 6, 7, 4\n   *     ],\n   *\n   *     radius: 6,\n   *     detail: 2\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      verticesOfCube,\n      indicesOfFaces,\n      radius: 6,\n      detail: 2\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Polyhedron#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: ['verticesOfCube', 'indicesOfFaces', 'radius', 'detail']\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['verticesOfCube', 'indicesOfFaces', 'radius', 'detail']\n  };\n\n  constructor(params = {}) {\n    super(params, Polyhedron.defaults, Polyhedron.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Polyhedron\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new (params.buffer ? PolyhedronBufferGeometry : PolyhedronGeometry)(\n      params.geometry.verticesOfCube,\n      params.geometry.indicesOfFaces,\n      params.geometry.radius,\n      params.geometry.detail\n    );\n  }\n}\n\nexport {\n  Polyhedron\n};\n","import {\n  Mesh,\n  RingGeometry,\n  RingBufferGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Ring\n * @category components/meshes\n * @description Ring class creates a circle or just 2D Torus. Does not support physics.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#RingGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Ring, and adding to app</caption>\n * new Ring({\n *   geometry: {\n *     innerRadius: 5,\n *     outerRadius: 2\n *   },\n *\n *   material: new THREE.MeshLambertMaterial({\n *     color: 0xffffff,\n *     side THREE.DoubleSide\n *   }),\n *\n *   position: [0, 8, 0],\n *\n *   rotation: {\n *     x: Math.PI/4\n *   }\n * }).addTo(app);\n */\nclass Ring extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Ring#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     innerRadius: 0,\n   *     outerRadius: 50,\n   *     thetaSegments: 8,\n   *     phiSegments: 8,\n   *     thetaStart: 0,\n   *     thetaLength: Math.PI * 2\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      innerRadius: 0,\n      outerRadius: 50,\n      thetaSegments: 8,\n      phiSegments: 8,\n      thetaStart: 0,\n      thetaLength: Math.PI * 2\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Ring#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: [\n   *     'innerRadius',\n   *     'outerRadius',\n   *     'thetaSegments',\n   *     'phiSegments',\n   *     'thetaStart',\n   *     'thetaLength'\n   *   ]\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.defaults,\n    geometry: [\n      'innerRadius',\n      'outerRadius',\n      'thetaSegments',\n      'phiSegments',\n      'thetaStart',\n      'thetaLength'\n    ]\n  };\n\n  constructor(params = {}) {\n    super(params, Ring.defaults, Ring.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Ring\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new (params.buffer ? RingBufferGeometry : RingGeometry)(\n      params.geometry.innerRadius,\n      params.geometry.outerRadius,\n      params.geometry.thetaSegments,\n      params.geometry.phiSegments,\n      params.geometry.thetaStart,\n      params.geometry.thetaLength\n    );\n  }\n}\n\nexport {\n  Ring\n};\n","import {\n  Mesh,\n  ShapeBufferGeometry,\n  ShapeGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Shape\n * @category components/meshes\n * @description Shape is a universal class. It allows you to create different 2D shapes in 3D scene.<br/>\n * Unfortunately, not all of them support physics, an alternative is to make a similar 3D object and scale its width down to near zero.\n * <br/><br/>\n * `Shape` consists of shapes that are in its shapes parameter.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#ShapeGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a plane looking Shape from a THREE.Shape, and adding it to app</caption>\n * const rectWidth = 10,\n * rectLength = 5;\n *\n * const rectShape = new THREE.Shape();\n * rectShape.moveTo(0,0);\n * rectShape.lineTo(0, rectWidth);\n * rectShape.lineTo(rectLength, rectWidth);\n * rectShape.lineTo(rectLength, 0);\n * rectShape.lineTo(0, 0);\n *\n * const plane = new Shape({\n *   geometry: {\n *     shape: rectShape\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   })\n * }).addTo(app);\n */\nclass Shape extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Shape#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     shapes: []\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      shapes: []\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Shape#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: ['shapes']\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['shapes']\n  };\n\n  constructor(params = {}) {\n    super(params, Shape.defaults, Shape.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Shape\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new (params.buffer ? ShapeBufferGeometry : ShapeGeometry)(\n      params.geometry.shapes\n    );\n  }\n}\n\nexport {\n  Shape\n};\n","import {\n  Mesh,\n  SphereBufferGeometry,\n  SphereGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Sphere\n * @category components/meshes\n * @description Sphere class is used to create sphere objects by its radius property and other values that determines its detality.\n * <br/><br/>\n * It is similar to THREE.SphereGeometry, but it also contains all `Shape` properties, such as material, mass and vectors like position (pos) and rotation (rot).\n * <br/><br/>\n * Then it creates an `Three.js mesh` or a `Physijs mesh`, that is similar to `Three.js mesh`, but it also take into consideration collision calculations.\n * This mesh is a combination of `Three.js geometry` and `Physijs material` (The same as in three.js, but with friction and restitution).\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#SphereGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Sphere, and adding it to app</caption>\n * new Sphere({\n *   geometry: {\n *     radius: 2\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: {\n *     y: 100\n *   }\n * }).addTo(app);\n */\nclass Sphere extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Sphere#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     radius: 1,\n   *     widthSegments: 8,\n   *     heightSegments: 6\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      radius: 1,\n      widthSegments: 8,\n      heightSegments: 6\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Sphere#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: ['radius', 'widthSegments', 'heightSegments']\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['radius', 'widthSegments', 'heightSegments']\n  };\n\n  constructor(params = {}) {\n    super(params, Sphere.defaults, Sphere.instructions);\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Sphere\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const geometry = new (params.buffer ? SphereBufferGeometry : SphereGeometry)(\n      params.geometry.radius,\n      params.geometry.widthSegments,\n      params.geometry.heightSegments\n    );\n\n    return geometry;\n  }\n}\n\nexport {\n  Sphere\n};\n","import {\n  Mesh,\n  TetrahedronBufferGeometry,\n  TetrahedronGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Tetrahedron\n * @category components/meshes\n * @description In geometry, a tetrahedron is a polyhedron composed of four triangular faces, six straight edges, and four vertex corners.\n * The tetrahedron is the simplest of all the ordinary convex polyhedra and the only one that has fewer than 5 faces.\n * <br/><br/>\n * `Tetrahedron` creates a Tetrahedron object by its `radius` and `detail`\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#TetrahedronGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Tetrahedron, and adding it to app</caption>\n * new Tetrahedron({\n *   geometry: {\n *     radius: 2,\n *     detail: 1\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: {\n *     x: 0,\n *     y: 100,\n *     z: 0\n *   }\n * }).addTo(app);\n */\nclass Tetrahedron extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Tetrahedron#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     radius: 1,\n   *     detail: 0\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      radius: 1,\n      detail: 0\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Tetrahedron#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: ['radius', 'detail']\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['radius', 'detail']\n  };\n\n  constructor(params = {}) {\n    super(params, Tetrahedron.defaults, Tetrahedron.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Tetrahedron\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new (params.buffer ? TetrahedronBufferGeometry : TetrahedronGeometry)(\n      params.geometry.radius,\n      params.geometry.detail\n    );\n  }\n}\n\nexport {\n  Tetrahedron\n};\n","import {\n  Font,\n  Mesh,\n  TextGeometry,\n  FontLoader\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Text\n * @category components/meshes\n * @description Text class is made for creating 3D text objects.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#TextGeometry\"></iframe>\n * <br/><br/>\n * Physics text object can be convex or concave. By default it's convex but you can also switch to concave.\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Text, and adding it to app</caption>\n * new Text({\n *   geometry: {\n *     text: 'hello world',\n *     parameters: {\n *       font: 'path/to/font.typeface.js',\n *       size: 20,\n *       height: 5,\n *       curveSegments: 6\n *     }\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: {\n *     x: -40,\n *     y: 20,\n *     z: 0\n *   }\n * }).addTo(app);\n */\nclass Text extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Text#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     text: 'Hello World!',\n   *     loader: new FontLoader(),\n   *\n   *     parameters: {\n   *       size: 12,\n   *       height: 50,\n   *       curveSegments: 12,\n   *       font: new Font(),\n   *       bevelEnabled: false,\n   *       bevelThickness: 10,\n   *       bevelSize: 8\n   *     }\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      text: 'Hello World!',\n      loader: new FontLoader(),\n\n      parameters: {\n        size: 12,\n        height: 50,\n        curveSegments: 12,\n        font: new Font(),\n        bevelEnabled: false,\n        bevelThickness: 10,\n        bevelSize: 8\n      }\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Text#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: ['text', 'loader', 'parameters']\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: ['text', 'loader', 'parameters']\n  }\n\n  constructor(params = {}) {\n    super(params, Text.defaults, Text.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Text\n   */\n  build(params = {}) {\n    const promise = new Promise(resolve => {\n      FontLoader.load(params.geometry.parameters.font, font => {\n        params.geometry.parameters.font = font;\n\n        const {geometry, material} = this.applyBridge({\n          geometry: new TextGeometry(\n            params.geometry.text,\n            params.geometry.parameters\n          ),\n\n          material: params.material\n        });\n\n        resolve(\n          this.applyBridge({\n            mesh: new Mesh(geometry, material)\n          }).mesh\n        );\n      });\n    });\n\n    super.wait(promise);\n\n    return promise;\n  }\n}\n\nexport {\n  Text\n};\n","import {\n  Mesh,\n  TorusGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Torus\n * @category components/meshes\n * @description Torus class makes a torus figure. A donut is a torus.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/index.html#api/geometries/TorusGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Torus, and adding it to app</caption>\n * new Torus({\n *   geometry: {\n *     radius: 5,\n *     tube: 2\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   position: {\n *     y: 35\n *   }\n * }).addTo(app);\n */\nclass Torus extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Torus#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     radius: 100,\n   *     tube: 40,\n   *     radialSegments: 8,\n   *     tubularSegments: 6,\n   *     arc: Math.PI * 2\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      radius: 100,\n      tube: 40,\n      radialSegments: 8,\n      tubularSegments: 6,\n      arc: Math.PI * 2\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Torus#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: [\n   *     'radius',\n   *     'tube',\n   *     'radialSegments',\n   *     'tubularSegments',\n   *     'arc'\n   *   ]\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: [\n      'radius',\n      'tube',\n      'radialSegments',\n      'tubularSegments',\n      'arc'\n    ]\n  };\n\n  constructor(params = {}) {\n    super(params, Torus.defaults, Torus.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Torus\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    return new TorusGeometry(\n      params.geometry.radius,\n      params.geometry.tube,\n      params.geometry.radialSegments,\n      params.geometry.tubularSegments,\n      params.geometry.arc\n    );\n  }\n}\n\nexport {\n  Torus\n};\n","import {\n  Mesh,\n  TorusKnotBufferGeometry,\n  TorusKnotGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Torusknot\n * @category components/meshes\n * @description Torusknot class makes a torusknot figure. It's like a crooked donut, very crooked.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/scenes/geometry-browser.html#TorusKnotGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Torusknot, and adding it to app</caption>\n * new Torusknot({\n *   geometry: {\n *     radius:5,\n *     tube: 2\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *\n *   pos: {\n *     y: 100\n *   }\n * }).addTo(app);\n */\nclass Torusknot extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Torusknot#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     radius: 100,\n   *     tube: 40,\n   *     radialSegments: 64,\n   *     tubularSegments: 8,\n   *     p: 2,\n   *     q: 3\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      radius: 100,\n      tube: 40,\n      radialSegments: 64,\n      tubularSegments: 8,\n      p: 2,\n      q: 3\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Torusknot#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: [\n   *     'radius',\n   *     'tube',\n   *     'radialSegments',\n   *     'tubularSegments',\n   *     'p',\n   *     'q'\n   *   ]\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: [\n      'radius',\n      'tube',\n      'radialSegments',\n      'tubularSegments',\n      'p',\n      'q'\n    ]\n  };\n\n  constructor(params = {}) {\n    super(params, Torusknot.defaults, Torusknot.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Torusknot\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const GConstruct = params.buffer ? TorusKnotBufferGeometry : TorusKnotGeometry;\n\n    return new GConstruct(\n      params.geometry.radius,\n      params.geometry.tube,\n      params.geometry.radialSegments,\n      params.geometry.tubularSegments,\n      params.geometry.p,\n      params.geometry.q\n    );\n  }\n}\n\nexport {\n  Torusknot\n};\n","import {\n  Mesh,\n  LineCurve3,\n  Vector3,\n  TubeBufferGeometry,\n  TubeGeometry\n} from 'three';\n\nimport {MeshComponent} from '../../core/MeshComponent';\n\n/**\n * @class Tube\n * @category components/meshes\n * @description Tube class makes a tube that extrudes along a 3d curve.\n * @classDesc\n * <iframe src=\"https://threejs.org/docs/index.html#api/geometries/TubeGeometry\"></iframe>\n * @param {Object} [params] - The params.\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Creating a Tube from a three.js Curve, and adding it to app</caption>\n * const CustomSinCurve = THREE.Curve.create(\n *   function (scale) { // custom curve constructor\n *     this.scale = (scale === undefined) ? 1 : scale;\n *   },\n *\n *   function (t) { // getPoint: t is between 0-1\n *     const tx = t * 3 - 1.5,\n *     ty = Math.sin( 2 * Math.PI * t ),\n *     tz = 0;\n *\n *     return new THREE.Vector3(tx, ty, tz).multiplyScalar(this.scale);\n *   }\n * );\n *\n * const path = new CustomSinCurve(10);\n *\n * new Tube({\n *   geometry: {\n *     path: path\n *   },\n *\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   })\n * }).addTo(app);\n */\nclass Tube extends MeshComponent {\n  /**\n   * Default values for parameters\n   * @member {Object} module:components/meshes.Tube#defaults\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: {\n   *     path: new THREE.LineCurve3(new Vector3(0, 0, 0), new Vector3(0, 0, 1)),\n   *     segments: 20,\n   *     radius: 2,\n   *     radiusSegments: 8,\n   *     closed: false\n   *   }\n   * }\n   * </pre>\n   */\n  static defaults = {\n    ...MeshComponent.defaults,\n    geometry: {\n      path: new LineCurve3(new Vector3(0, 0, 0), new Vector3(0, 0, 1)),\n      segments: 20,\n      radius: 2,\n      radiusSegments: 8,\n      closed: false\n    }\n  };\n\n  /**\n   * Instructions\n   * @member {Object} module:components/meshes.Tube#instructions\n   * @static\n   * @default <pre>\n   * {\n   *   geometry: [\n   *     'path',\n   *     'segments',\n   *     'radius',\n   *     'radiusSegments',\n   *     'closed'\n   *   ]\n   * }\n   * </pre>\n   */\n  static instructions = {\n    ...MeshComponent.instructions,\n    geometry: [\n      'path',\n      'segments',\n      'radius',\n      'radiusSegments',\n      'closed'\n    ]\n  };\n\n  constructor(params = {}) {\n    super(params, Tube.defaults, Tube.instructions);\n\n    if (params.build) {\n      this.build(params);\n      super.wrap();\n    }\n  }\n\n  /**\n   * @method build\n   * @description Build livecycle creates a mesh using input params.\n   * @param {Object} params Component parameters.\n   * @return {THREE.Mesh} Built mesh\n   * @memberof module:components/meshes.Tube\n   */\n  build(params = this.params) {\n    const {geometry, material} = this.applyBridge({\n      geometry: this.buildGeometry(params),\n      material: params.material\n    });\n\n    return this.applyBridge({mesh: new Mesh(geometry, material)}).mesh;\n  }\n\n  buildGeometry(params = {}) {\n    const geometry = new (params.buffer ? TubeBufferGeometry : TubeGeometry)(\n      params.geometry.path,\n      params.geometry.segments,\n      params.geometry.radius,\n      params.geometry.radiusSegments,\n      params.geometry.closed\n    );\n\n    return geometry;\n  }\n}\n\nexport {\n  Tube\n};\n","import {Object3D} from 'three';\nimport {MeshComponent} from '../../core/MeshComponent';\nimport {Component} from '../../core/Component';\n\n/**\n * @class Group\n * @category components/meshes\n * @description Sometimes you need to make groups of objects (it's not conveniently to apply transforms to each object when can make just one to a group).<br/>\n * In Three.js you make it using `THREE.Object3D` and it's children. <br/><br/>\n * In whs.js we have `Group`\n * @extends module:core.MeshComponent\n * @memberof module:components/meshes\n * @example <caption>Approach 2 - Adding objects to an empty group</caption>\n * const sphere = new Sphere();\n * const box = new Box();\n * const group = new Group();\n *\n * sphere.addTo(group);\n * box.addTo(group);\n* @example <caption>Approach 2 - Making a group from objects</caption>\n * const sphere = new Sphere();\n * const box = new Box();\n * const group = new Group(box, sphere);\n * // OR: const group = new Group([box, sphere]);\n */\nclass Group extends MeshComponent {\n  constructor(...objects) {\n    super({});\n\n    for (let i = 0; i < objects.length; i++) {\n      const obj = objects[i];\n\n      if (obj instanceof Component) obj.addTo(this);\n      else if (obj instanceof Object3D) this.native.add(obj);\n    }\n  }\n\n  build() {\n    return new Object3D();\n  }\n}\n\nexport {\n  Group\n};\n","/** @module components/meshes */\nexport * from './Box';\nexport * from './Circle';\nexport * from './Cone';\nexport * from './Cylinder';\nexport * from './Dodecahedron';\nexport * from './Extrude';\nexport * from './Icosahedron';\nexport * from './Lathe';\nexport * from './Line';\nexport * from './Importer';\nexport * from './Octahedron';\nexport * from './Parametric';\nexport * from './Plane';\nexport * from './Polyhedron';\nexport * from './Ring';\nexport * from './Shape';\nexport * from './Sphere';\nexport * from './Tetrahedron';\nexport * from './Text';\nexport * from './Torus';\nexport * from './Torusknot';\nexport * from './Tube';\nexport * from './Group';\n","/**\n * @class ElementModule\n * @category modules/app\n * @param {Object} [container=document.body] container is the DOM object to which application's canvas will be added to.\n * @memberof module:modules/app\n * @example <caption>Creating an element module, passing it to the App</caption>\n * new App([\n *   new ElementModule(document.getElementById('app'))\n * ]);\n */\nexport class ElementModule {\n  constructor(container = document.body) {\n    if (container.container) {\n      console.warn('ElementModule now accepts only argument which is a DOM object, not a params object.');\n      this.container = container.container;\n    } else this.container = container;\n\n    this.createElement();\n  }\n\n  /**\n   * @method createElement\n   * @instance\n   * @description Creates a canvas element.\n   * @memberof module:modules/app.ResizeModule\n   */\n  createElement() {\n    this.element = window.document.createElement('div');\n\n    this.element.className = 'whs-app';\n    this.element.style.width = 'inherit';\n    this.element.style.height = 'inherit';\n    this.element.style.position = 'relative';\n  }\n\n  manager(manager) {\n    manager.set('element', this.element);\n    manager.set('container', this.container);\n  }\n\n  integrate(self) {\n    self.container.appendChild(self.element);\n  }\n}\n","import {\n  WebGLRenderer,\n  Vector2\n} from 'three';\n\nimport {Loop} from '../../core/Loop';\n\n/**\n * @class RenderingModule\n * @category modules/app\n * @param {Object} [params]\n * @memberof module:modules/app\n * @example <caption> Creating a rendering module and passing it to App's modules</caption>\n * new App([\n *   new ElementModule(),\n *   new SceneModule(),\n *   new CameraModule({\n *     position: new THREE.Vector3(0, 6, 18),\n *     far: 10000\n *   }),\n *   new RenderingModule({\n *     bgColor: 0x162129,\n *\n *     renderer: {\n *       antialias: true,\n *       shadowmap: {\n *         type: THREE.PCFSoftShadowMap\n *       }\n *     }\n *   }, {shadow: true})\n * ]);\n */\nexport class RenderingModule {\n  static additional = {\n    shadow(renderer) {\n      renderer.shadowMap.enabled = true;\n    }\n  }\n\n  enabled = true;\n\n  defer = new Promise(resolve => {\n    this.resolve = resolve;\n  });\n\n  constructor(params = {}, {shadow: isShadow} = {shadow: false}) {\n    this.params = Object.assign({\n      width: window.innerWidth,\n      height: window.innerHeight,\n\n      resolution: new Vector2(1, 1),\n      pixelRatio: window.devicePixelRatio,\n\n      bgColor: 0x000000,\n      bgOpacity: 1,\n\n      renderer: {}\n    }, params);\n\n    const {\n      bgColor,\n      bgOpacity,\n      renderer,\n      pixelRatio,\n      width,\n      height,\n      resolution\n    } = this.params;\n\n    this.renderer = new WebGLRenderer(renderer);\n    this.effects = [];\n    this.applyAdditional('shadow', isShadow);\n\n    this.renderer.setClearColor(\n      bgColor,\n      bgOpacity\n    );\n\n    if (pixelRatio) this.renderer.setPixelRatio(pixelRatio);\n\n    this.setSize(\n      Number(width * resolution.x).toFixed(),\n      Number(height * resolution.y).toFixed()\n    );\n  }\n\n  applyAdditional(name, isApplied = false) {\n    if (!isApplied) return;\n    RenderingModule.additional[name].apply(this, [this.renderer]);\n  }\n\n  integrateRenderer(element, scene, camera) {\n    this.scene = scene;\n    this.camera = camera;\n    this.renderLoop = new Loop(() => this.renderer.render(this.scene, this.camera));\n    this.attachToCanvas(element);\n\n    return this.renderLoop;\n  }\n\n  effect(effect, cb) {\n    this.defer.then(() => {\n      this.renderLoop.stop();\n\n      const size = this.renderer.getSize();\n      effect.setSize(size.width, size.height);\n\n      const loop = new Loop(cb ? cb : () => {\n        effect.render(this.scene, this.camera);\n      });\n\n      this.effects.push(loop);\n      if (this.enabled) loop.start(this.app);\n    });\n  }\n\n  /**\n   * @method setSize\n   * @description Update render target width and height.\n   * @param {Number} width\n   * @param {Number} height\n   * @memberof module:modules/app.RenderingModule\n   */\n  setSize(width, height) {\n    if (this.renderer) this.renderer.setSize(width, height);\n  }\n\n  attachToCanvas(element) {\n    const canvas = this.renderer.domElement;\n\n    // attach to new parent world dom\n    element.appendChild(canvas);\n    canvas.style.width = '100%';\n    canvas.style.height = '100%';\n  }\n\n  stop() {\n    this.enabled = false;\n    this.renderLoop.stop();\n    this.effects.forEach(loop => loop.stop());\n  }\n\n  play() {\n    this.renderLoop.start();\n    this.effects.forEach(loop => loop.start());\n  }\n\n  manager(manager) {\n    manager.define('rendering');\n    manager.set('renderer', this.renderer);\n\n    this.app = manager.handler;\n\n    this.renderLoop = this.integrateRenderer(\n      manager.get('element'),\n      manager.get('scene'),\n      manager.get('camera').native\n    );\n\n    manager.update({\n      element: element => {\n        this.attachToCanvas(element);\n      },\n      scene: scene => {\n        this.scene = scene;\n      },\n      camera: camera => {\n        this.camera = camera.native;\n      }\n    });\n\n    this.resolve();\n  }\n\n  integrate(self) {\n    self.renderLoop.start(this);\n    self.effects.forEach(loop => loop.start(this));\n  }\n\n  dispose(self) {\n    self.renderLoop.stop(this);\n    self.effects.forEach(loop => loop.stop(this));\n    self.renderer.forceContextLoss();\n  }\n}\n","import {\n  Scene\n} from 'three';\n\n/**\n * @class SceneModule\n * @category modules/app\n * @param {Boolean} [willSceneBeReplaced=false] willSceneBeReplaced should be true only if you are going to overwrite scene dependency even without the use of default one.\n * @memberof module:modules/app\n */\nexport class SceneModule {\n  constructor(willSceneBeReplaced = false) {\n    this.scene = willSceneBeReplaced ? null : new Scene();\n  }\n\n  manager(manager) {\n    manager.set('scene', this.scene);\n  }\n\n  integrate(self) {\n    this.children = [];\n\n    this.add = function (object) {\n      object.parent = this;\n\n      return new Promise((resolve, reject) => {\n        object.defer(() => {\n          const {native} = object;\n          if (!native) reject();\n\n          const addPromise = this.applyBridge({onAdd: object}).onAdd;\n\n          const resolver = () => {\n            self.scene.add(native);\n            this.children.push(object);\n\n            resolve(object);\n          };\n\n          if (addPromise instanceof Promise)\n            addPromise.then(resolver);\n          else resolver();\n        });\n      });\n    };\n\n    this.remove = function (object) {\n      object.parent = null;\n      self.scene.remove(object.native);\n    };\n\n    this.setScene = function (scene) {\n      self.scene = scene;\n      this.manager.set('scene', scene);\n    };\n  }\n}\n","// import {addResizeListener} from 'detect-element-resize';\n\n/**\n * @class ResizeModule\n * @category modules/app\n * @param {Object} [params={auto: true}] - If auto is set to true - resize will be triggered when container resizes\n * @memberof module:modules/app\n */\nexport class ResizeModule {\n  constructor(params = {}) {\n    this.params = Object.assign({\n      auto: true\n    }, params);\n\n    this.callbacks = [this.setSize.bind(this)];\n  }\n\n  /**\n   * @function setSize\n   * @instance\n   * @description This function sets the provided width & height to the renderer object.\n   * @param {Number} [width=1] - The promise that should be added to a queue.\n   * @param {Number} [height=1] - that is resolved when all promises completed.\n   * @memberof module:modules/app.ResizeModule\n   */\n  setSize(width = 1, height = 1) {\n    this.camera.native.aspect = width / height;\n    this.camera.native.updateProjectionMatrix();\n\n    if (this.rendering) this.rendering.setSize(width, height);\n  }\n\n  /**\n   * @method trigger\n   * @instance\n   * @description Triggers resize when called. width & height are determined automatically\n   * This invokes each callbacks with the new width and height as params\n   * @memberof module:modules/app.ResizeModule\n   */\n  trigger() {\n    const {\n      container: {\n        offsetWidth,\n        offsetHeight\n      },\n      resolution\n    } = this;\n\n    const width = Number(offsetWidth * resolution.x).toFixed();\n    const height = Number(offsetHeight * resolution.y).toFixed();\n\n    this.callbacks.forEach(cb => {\n      cb(width, height);\n    });\n  }\n\n  /**\n   * @method addAutoresize\n   * @instance\n   * @description Sets module to autoresize, this adds an event listene on window resize to trigger the resize\n   * @memberof module:modules/app.ResizeModule\n   */\n  addAutoresize() {\n    this.container = this.getContainer();\n    this.resolution = this.getResolution();\n\n    if (this.params.auto) window.addEventListener('resize', this.trigger.bind(this));\n  }\n\n  /**\n   * @method addCallback\n   * @instance\n   * @description Adds a call back function to the existing callbacks list.\n   * @param {Function} func - The callback function to add\n   * @memberof module:modules/app.ResizeModule\n   */\n  addCallback(func) {\n    this.callbacks.push(func);\n  }\n\n  manager(manager) {\n    manager.define('resize');\n\n    this.rendering = manager.get('renderer');\n    this.camera = manager.get('camera');\n\n    this.getResolution = () => manager.use('rendering').params.resolution;\n    this.getContainer = () => manager.get('container');\n\n    this.addAutoresize();\n  }\n}\n","import { ShaderMaterial, Uniform, Vector2 } from \"three\";\r\n\r\nconst fragment = \"uniform sampler2D tDiffuse;\\r\\n\\r\\nvarying vec2 vUv0;\\r\\nvarying vec2 vUv1;\\r\\nvarying vec2 vUv2;\\r\\nvarying vec2 vUv3;\\r\\n\\r\\nvoid main() {\\r\\n\\r\\n\\t// Sample top left texel.\\r\\n\\tvec4 sum = texture2D(tDiffuse, vUv0);\\r\\n\\r\\n\\t// Sample top right texel.\\r\\n\\tsum += texture2D(tDiffuse, vUv1);\\r\\n\\r\\n\\t// Sample bottom right texel.\\r\\n\\tsum += texture2D(tDiffuse, vUv2);\\r\\n\\r\\n\\t// Sample bottom left texel.\\r\\n\\tsum += texture2D(tDiffuse, vUv3);\\r\\n\\r\\n\\t// Compute the average.\\r\\n\\tgl_FragColor = sum * 0.25;\\r\\n\\r\\n}\\r\\n\";\r\nconst vertex = \"uniform vec2 texelSize;\\r\\nuniform vec2 halfTexelSize;\\r\\nuniform float kernel;\\r\\n\\r\\nvarying vec2 vUv0;\\r\\nvarying vec2 vUv1;\\r\\nvarying vec2 vUv2;\\r\\nvarying vec2 vUv3;\\r\\n\\r\\nvoid main() {\\r\\n\\r\\n\\tvec2 dUv = (texelSize * vec2(kernel)) + halfTexelSize;\\r\\n\\r\\n\\tvUv0 = vec2(uv.x - dUv.x, uv.y + dUv.y);\\r\\n\\tvUv1 = vec2(uv.x + dUv.x, uv.y + dUv.y);\\r\\n\\tvUv2 = vec2(uv.x + dUv.x, uv.y - dUv.y);\\r\\n\\tvUv3 = vec2(uv.x - dUv.x, uv.y - dUv.y);\\r\\n\\r\\n\\tgl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\\r\\n\\r\\n}\\r\\n\";\r\n\r\n/**\r\n * An optimised convolution shader material.\r\n *\r\n * Based on the GDC2003 Presentation by Masaki Kawase, Bunkasha Games:\r\n *  Frame Buffer Postprocessing Effects in DOUBLE-S.T.E.A.L (Wreckless)\r\n * and an article by Filip Strugar, Intel:\r\n *  An investigation of fast real-time GPU-based image blur algorithms\r\n *\r\n * Further modified according to Apple's\r\n * [Best Practices for Shaders](https://goo.gl/lmRoM5).\r\n */\r\n\r\nexport class ConvolutionMaterial extends ShaderMaterial {\r\n\r\n\t/**\r\n\t * Constructs a new convolution material.\r\n\t *\r\n\t * @param {Vector2} [texelSize] - The absolute screen texel size.\r\n\t */\r\n\r\n\tconstructor(texelSize = new Vector2()) {\r\n\r\n\t\tsuper({\r\n\r\n\t\t\ttype: \"ConvolutionMaterial\",\r\n\r\n\t\t\tuniforms: {\r\n\r\n\t\t\t\ttDiffuse: new Uniform(null),\r\n\t\t\t\ttexelSize: new Uniform(new Vector2()),\r\n\t\t\t\thalfTexelSize: new Uniform(new Vector2()),\r\n\t\t\t\tkernel: new Uniform(0.0)\r\n\r\n\t\t\t},\r\n\r\n\t\t\tfragmentShader: fragment,\r\n\t\t\tvertexShader: vertex,\r\n\r\n\t\t\tdepthWrite: false,\r\n\t\t\tdepthTest: false\r\n\r\n\t\t});\r\n\r\n\t\tthis.setTexelSize(texelSize.x, texelSize.y);\r\n\r\n\t\t/**\r\n\t\t * The current kernel size.\r\n\t\t *\r\n\t\t * @type {KernelSize}\r\n\t\t * @default KernelSize.LARGE\r\n\t\t */\r\n\r\n\t\tthis.kernelSize = KernelSize.LARGE;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Returns the kernel.\r\n\t *\r\n\t * @return {Float32Array} The kernel.\r\n\t */\r\n\r\n\tgetKernel() { return kernelPresets[this.kernelSize]; }\r\n\r\n\t/**\r\n\t * Sets the texel size.\r\n\t *\r\n\t * @param {Number} x - The texel width.\r\n\t * @param {Number} y - The texel height.\r\n\t */\r\n\r\n\tsetTexelSize(x, y) {\r\n\r\n\t\tthis.uniforms.texelSize.value.set(x, y);\r\n\t\tthis.uniforms.halfTexelSize.value.set(x, y).multiplyScalar(0.5);\r\n\r\n\t}\r\n\r\n}\r\n\r\n/**\r\n * The Kawase blur kernel presets.\r\n *\r\n * @type {Float32Array[]}\r\n * @private\r\n */\r\n\r\nconst kernelPresets = [\r\n\tnew Float32Array([0.0, 0.0]),\r\n\tnew Float32Array([0.0, 1.0, 1.0]),\r\n\tnew Float32Array([0.0, 1.0, 1.0, 2.0]),\r\n\tnew Float32Array([0.0, 1.0, 2.0, 2.0, 3.0]),\r\n\tnew Float32Array([0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 5.0]),\r\n\tnew Float32Array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 8.0, 9.0, 10.0])\r\n];\r\n\r\n/**\r\n * A kernel size enumeration.\r\n *\r\n * @type {Object}\r\n * @property {Number} VERY_SMALL - A very small kernel that matches a 7x7 Gauss blur kernel.\r\n * @property {Number} SMALL - A small kernel that matches a 15x15 Gauss blur kernel.\r\n * @property {Number} MEDIUM - A medium sized kernel that matches a 23x23 Gauss blur kernel.\r\n * @property {Number} LARGE - A large kernel that matches a 35x35 Gauss blur kernel.\r\n * @property {Number} VERY_LARGE - A very large kernel that matches a 63x63 Gauss blur kernel.\r\n * @property {Number} HUGE - A huge kernel that matches a 127x127 Gauss blur kernel.\r\n */\r\n\r\nexport const KernelSize = {\r\n\r\n\tVERY_SMALL: 0,\r\n\tSMALL: 1,\r\n\tMEDIUM: 2,\r\n\tLARGE: 3,\r\n\tVERY_LARGE: 4,\r\n\tHUGE: 5\r\n\r\n};\r\n","import { ShaderMaterial, Uniform } from \"three\";\r\n\r\nconst fragment = \"uniform sampler2D tDiffuse;\\r\\nuniform float opacity;\\r\\n\\r\\nvarying vec2 vUv;\\r\\n\\r\\nvoid main() {\\r\\n\\r\\n\\tvec4 texel = texture2D(tDiffuse, vUv);\\r\\n\\tgl_FragColor = opacity * texel;\\r\\n\\r\\n}\\r\\n\";\r\nconst vertex = \"varying vec2 vUv;\\r\\n\\r\\nvoid main() {\\r\\n\\r\\n\\tvUv = uv;\\r\\n\\tgl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\\r\\n\\r\\n}\\r\\n\";\r\n\r\n/**\r\n * A simple copy shader material.\r\n */\r\n\r\nexport class CopyMaterial extends ShaderMaterial {\r\n\r\n\t/**\r\n\t * Constructs a new copy material.\r\n\t */\r\n\r\n\tconstructor() {\r\n\r\n\t\tsuper({\r\n\r\n\t\t\ttype: \"CopyMaterial\",\r\n\r\n\t\t\tuniforms: {\r\n\r\n\t\t\t\ttDiffuse: new Uniform(null),\r\n\t\t\t\topacity: new Uniform(1.0)\r\n\r\n\t\t\t},\r\n\r\n\t\t\tfragmentShader: fragment,\r\n\t\t\tvertexShader: vertex,\r\n\r\n\t\t\tdepthWrite: false,\r\n\t\t\tdepthTest: false\r\n\r\n\t\t});\r\n\r\n\t}\r\n\r\n}\r\n","/**\r\n * A collection of shader materials that are used in the post processing passes.\r\n *\r\n * @module postprocessing/materials\r\n */\r\n\r\nexport { AdaptiveLuminosityMaterial } from \"./adaptive-luminosity.js\";\r\nexport { BokehMaterial } from \"./bokeh.js\";\r\nexport { Bokeh2Material } from \"./bokeh2.js\";\r\nexport { CombineMaterial } from \"./combine.js\";\r\nexport { ConvolutionMaterial, KernelSize } from \"./convolution.js\";\r\nexport { CopyMaterial } from \"./copy.js\";\r\nexport { DepthMaterial } from \"./depth.js\";\r\nexport { DotScreenMaterial } from \"./dot-screen.js\";\r\nexport { FilmMaterial } from \"./film.js\";\r\nexport { GlitchMaterial } from \"./glitch.js\";\r\nexport { GodRaysMaterial } from \"./god-rays.js\";\r\nexport { LuminosityMaterial } from \"./luminosity.js\";\r\nexport { PixelationMaterial } from \"./pixelation.js\";\r\nexport { ShockWaveMaterial } from \"./shock-wave.js\";\r\nexport { SMAABlendMaterial } from \"./smaa-blend.js\";\r\nexport { SMAAColorEdgesMaterial } from \"./smaa-color-edges.js\";\r\nexport { SMAAWeightsMaterial } from \"./smaa-weights.js\";\r\nexport { ToneMappingMaterial } from \"./tone-mapping.js\";\r\n","import { Scene, Mesh, OrthographicCamera, PlaneBufferGeometry } from \"three\";\r\n\r\n/**\r\n * An abstract pass.\r\n *\r\n * Passes that do not rely on the depth buffer should explicitly disable the\r\n * depth test and depth write in their respective shader materials.\r\n *\r\n * This class implements a {@link Pass#dispose} method that frees memory on\r\n * demand.\r\n */\r\n\r\nexport class Pass {\r\n\r\n\t/**\r\n\t * Constructs a new pass.\r\n\t *\r\n\t * @param {Scene} [scene] - The scene to render.\r\n\t * @param {Camera} [camera] - The camera.\r\n\t * @param {Mesh} [quad] - A quad that fills the screen to render 2D filter effects. Set this to null, if you don't need it (see {@link RenderPass}).\r\n\t */\r\n\r\n\tconstructor(\r\n\t\tscene = new Scene(),\r\n\t\tcamera = new OrthographicCamera(-1, 1, 1, -1, 0, 1),\r\n\t\tquad = new Mesh(new PlaneBufferGeometry(2, 2), null)\r\n\t) {\r\n\r\n\t\t/**\r\n\t\t * The name of this pass.\r\n\t\t *\r\n\t\t * @type {String}\r\n\t\t */\r\n\r\n\t\tthis.name = \"Pass\";\r\n\r\n\t\t/**\r\n\t\t * The scene to render.\r\n\t\t *\r\n\t\t * @type {Scene}\r\n\t\t * @protected\r\n\t\t * @default new Scene()\r\n\t\t */\r\n\r\n\t\tthis.scene = scene;\r\n\r\n\t\t/**\r\n\t\t * The camera.\r\n\t\t *\r\n\t\t * @type {Camera}\r\n\t\t * @protected\r\n\t\t * @default new OrthographicCamera(-1, 1, 1, -1, 0, 1)\r\n\t\t */\r\n\r\n\t\tthis.camera = camera;\r\n\r\n\t\t/**\r\n\t\t * A quad mesh that fills the screen.\r\n\t\t *\r\n\t\t * Assign your shader material to this mesh!\r\n\t\t *\r\n\t\t * @type {Mesh}\r\n\t\t * @protected\r\n\t\t * @default new Mesh(new PlaneBufferGeometry(2, 2), null)\r\n\t\t * @example this.quad.material = this.myMaterial;\r\n\t\t */\r\n\r\n\t\tthis.quad = quad;\r\n\r\n\t\tif(this.quad !== null) {\r\n\r\n\t\t\tthis.quad.frustumCulled = false;\r\n\r\n\t\t\tif(this.scene !== null) {\r\n\r\n\t\t\t\tthis.scene.add(this.quad);\r\n\r\n\t\t\t}\r\n\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * Indicates whether the read and write buffers should be swapped after this\r\n\t\t * pass has finished rendering.\r\n\t\t *\r\n\t\t * Set this to true if this pass renders to the write buffer so that a\r\n\t\t * following pass can find the result in the read buffer.\r\n\t\t *\r\n\t\t * @type {Boolean}\r\n\t\t * @default false\r\n\t\t */\r\n\r\n\t\tthis.needsSwap = false;\r\n\r\n\t\t/**\r\n\t\t * Enabled flag.\r\n\t\t *\r\n\t\t * @type {Boolean}\r\n\t\t * @default true\r\n\t\t */\r\n\r\n\t\tthis.enabled = true;\r\n\r\n\t\t/**\r\n\t\t * Render to screen flag.\r\n\t\t *\r\n\t\t * @type {Boolean}\r\n\t\t * @default false\r\n\t\t */\r\n\r\n\t\tthis.renderToScreen = false;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Renders the effect.\r\n\t *\r\n\t * This is an abstract method that must be overridden.\r\n\t *\r\n\t * @abstract\r\n\t * @throws {Error} An error is thrown if the method is not overridden.\r\n\t * @param {WebGLRenderer} renderer - The renderer.\r\n\t * @param {WebGLRenderTarget} readBuffer - A read buffer. Contains the result of the previous pass.\r\n\t * @param {WebGLRenderTarget} writeBuffer - A write buffer. Normally used as the render target when the read buffer is used as input.\r\n\t * @param {Number} [delta] - The delta time.\r\n\t * @param {Boolean} [maskActive] - Indicates whether a stencil test mask is active or not.\r\n\t */\r\n\r\n\trender(renderer, readBuffer, writeBuffer, delta, maskActive) {\r\n\r\n\t\tthrow new Error(\"Render method not implemented!\");\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Updates this pass with the renderer's size.\r\n\t *\r\n\t * You may override this method in case you want to be informed about the main\r\n\t * render size.\r\n\t *\r\n\t * The {@link EffectComposer} calls this method before this pass is\r\n\t * initialised and every time its own size is updated.\r\n\t *\r\n\t * @param {Number} width - The renderer's width.\r\n\t * @param {Number} height - The renderer's height.\r\n\t * @example this.myRenderTarget.setSize(width, height);\r\n\t */\r\n\r\n\tsetSize(width, height) {}\r\n\r\n\t/**\r\n\t * Performs initialisation tasks.\r\n\t *\r\n\t * By overriding this method you gain access to the renderer. You'll also be\r\n\t * able to configure your custom render targets to use the appropriate format\r\n\t * (RGB or RGBA).\r\n\t *\r\n\t * The provided renderer can be used to warm up special off-screen render\r\n\t * targets by performing a preliminary render operation.\r\n\t *\r\n\t * The {@link EffectComposer} calls this method when this pass is added to its\r\n\t * queue.\r\n\t *\r\n\t * @method initialise\r\n\t * @param {WebGLRenderer} renderer - The renderer.\r\n\t * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n\t * @example if(!alpha) { this.myRenderTarget.texture.format = RGBFormat; }\r\n\t */\r\n\r\n\tinitialise(renderer, alpha) {}\r\n\r\n\t/**\r\n\t * Performs a shallow search for properties that define a dispose method and\r\n\t * deletes them. The pass will be inoperative after this method was called!\r\n\t *\r\n\t * Disposable objects:\r\n\t *  - render targets\r\n\t *  - materials\r\n\t *  - textures\r\n\t *\r\n\t * The {@link EffectComposer} calls this method when it is being destroyed.\r\n\t * You may, however, use it independently to free memory when you are certain\r\n\t * that you don't need this pass anymore.\r\n\t */\r\n\r\n\tdispose() {\r\n\r\n\t\tconst keys = Object.keys(this);\r\n\r\n\t\tlet key;\r\n\r\n\t\tfor(key of keys) {\r\n\r\n\t\t\tif(this[key] !== null && typeof this[key].dispose === \"function\") {\r\n\r\n\t\t\t\tthis[key].dispose();\r\n\t\t\t\tthis[key] = null;\r\n\r\n\t\t\t}\r\n\r\n\t\t}\r\n\r\n\t}\r\n\r\n}\r\n","import { Color } from \"three\";\r\nimport { Pass } from \"./pass.js\";\r\n\r\n/**\r\n * Used for saving the original clear color of the renderer.\r\n *\r\n * @type Color\r\n * @private\r\n * @static\r\n */\r\n\r\nconst color = new Color();\r\n\r\n/**\r\n * A clear pass.\r\n *\r\n * You can prevent specific buffers from being cleared by setting either the\r\n * autoClearColor, autoClearStencil or autoClearDepth properties of the renderer\r\n * to false.\r\n */\r\n\r\nexport class ClearPass extends Pass {\r\n\r\n\t/**\r\n\t * Constructs a new clear pass.\r\n\t *\r\n\t * @param {Object} [options] - Additional options.\r\n\t * @param {Color} [options.clearColor=null] - An override clear color.\r\n\t * @param {Number} [options.clearAlpha=0.0] - An override clear alpha.\r\n\t */\r\n\r\n\tconstructor(options = {}) {\r\n\r\n\t\tsuper(null, null, null);\r\n\r\n\t\t/**\r\n\t\t * The name of this pass.\r\n\t\t */\r\n\r\n\t\tthis.name = \"ClearPass\";\r\n\r\n\t\t/**\r\n\t\t * Clear color.\r\n\t\t *\r\n\t\t * @type {Color}\r\n\t\t * @default null\r\n\t\t */\r\n\r\n\t\tthis.clearColor = (options.clearColor !== undefined) ? options.clearColor : null;\r\n\r\n\t\t/**\r\n\t\t * Clear alpha.\r\n\t\t *\r\n\t\t * @type {Number}\r\n\t\t * @default 0.0\r\n\t\t */\r\n\r\n\t\tthis.clearAlpha = (options.clearAlpha !== undefined) ? options.clearAlpha : 0.0;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Clears the read buffer or the screen.\r\n\t *\r\n\t * @param {WebGLRenderer} renderer - The renderer.\r\n\t * @param {WebGLRenderTarget} readBuffer - The read buffer.\r\n\t */\r\n\r\n\trender(renderer, readBuffer) {\r\n\r\n\t\tconst clearColor = this.clearColor;\r\n\r\n\t\tlet clearAlpha;\r\n\r\n\t\tif(clearColor !== null) {\r\n\r\n\t\t\tcolor.copy(renderer.getClearColor());\r\n\t\t\tclearAlpha = renderer.getClearAlpha();\r\n\t\t\trenderer.setClearColor(clearColor, this.clearAlpha);\r\n\r\n\t\t}\r\n\r\n\t\trenderer.setRenderTarget(this.renderToScreen ? null : readBuffer);\r\n\t\trenderer.clear();\r\n\r\n\t\tif(clearColor !== null) {\r\n\r\n\t\t\trenderer.setClearColor(color, clearAlpha);\r\n\r\n\t\t}\r\n\r\n\t}\r\n\r\n}\r\n","import { Pass } from \"./pass.js\";\r\n\r\n/**\r\n * A pass that disables the stencil mask.\r\n */\r\n\r\nexport class ClearMaskPass extends Pass {\r\n\r\n\t/**\r\n\t * Constructs a new clear mask pass.\r\n\t */\r\n\r\n\tconstructor() {\r\n\r\n\t\tsuper(null, null, null);\r\n\r\n\t\t/**\r\n\t\t * The name of this pass.\r\n\t\t */\r\n\r\n\t\tthis.name = \"ClearMaskPass\";\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Disables the stencil test.\r\n\t *\r\n\t * @param {WebGLRenderer} renderer - The renderer.\r\n\t */\r\n\r\n\trender(renderer) {\r\n\r\n\t\trenderer.state.buffers.stencil.setTest(false);\r\n\r\n\t}\r\n\r\n}\r\n","import { DataTexture, RGBFormat, FloatType } from \"three\";\r\nimport { GlitchMaterial } from \"../materials\";\r\nimport { Pass } from \"./pass.js\";\r\n\r\n/**\r\n * Returns a random integer in the specified range.\r\n *\r\n * @private\r\n * @static\r\n * @param {Number} low - The lowest possible value.\r\n * @param {Number} high - The highest possible value.\r\n * @return {Number} The random value.\r\n */\r\n\r\nfunction randomInt(low, high) {\r\n\r\n\treturn low + Math.floor(Math.random() * (high - low + 1));\r\n\r\n}\r\n\r\n/**\r\n * Returns a random float in the specified range.\r\n *\r\n * @private\r\n * @static\r\n * @param {Number} low - The lowest possible value.\r\n * @param {Number} high - The highest possible value.\r\n * @return {Number} The random value.\r\n */\r\n\r\nfunction randomFloat(low, high) {\r\n\r\n\treturn low + Math.random() * (high - low);\r\n\r\n}\r\n\r\n/**\r\n * A glitch pass.\r\n */\r\n\r\nexport class GlitchPass extends Pass {\r\n\r\n\t/**\r\n\t * Constructs a new glitch pass.\r\n\t *\r\n\t * @param {Object} [options] - The options.\r\n\t * @param {Texture} [options.perturbMap] - A perturbation map. If none is provided, a noise texture will be created.\r\n\t * @param {Number} [options.dtSize=64] - The size of the generated noise map. Will be ignored if a perturbation map is provided.\r\n\t */\r\n\r\n\tconstructor(options = {}) {\r\n\r\n\t\tsuper();\r\n\r\n\t\t/**\r\n\t\t * The name of this pass.\r\n\t\t */\r\n\r\n\t\tthis.name = \"GlitchPass\";\r\n\r\n\t\t/**\r\n\t\t * This pass renders to the write buffer.\r\n\t\t */\r\n\r\n\t\tthis.needsSwap = true;\r\n\r\n\t\t/**\r\n\t\t * Glitch shader material.\r\n\t\t *\r\n\t\t * @type {GlitchMaterial}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.material = new GlitchMaterial();\r\n\r\n\t\tthis.quad.material = this.material;\r\n\r\n\t\t/**\r\n\t\t * A perturbation map.\r\n\t\t *\r\n\t\t * @type {Texture}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.texture = null;\r\n\r\n\t\tthis.perturbMap = (options.perturbMap !== undefined) ? options.perturbMap : this.generatePerturbMap(options.dtSize);\r\n\t\tthis.perturbMap.name = \"Glitch.Perturbation\";\r\n\t\tthis.perturbMap.generateMipmaps = false;\r\n\r\n\t\t/**\r\n\t\t * The effect mode.\r\n\t\t *\r\n\t\t * @type {GlitchMode}\r\n\t\t * @default GlitchMode.SPORADIC\r\n\t\t */\r\n\r\n\t\tthis.mode = GlitchMode.SPORADIC;\r\n\r\n\t\t/**\r\n\t\t * Counter for glitch activation and deactivation.\r\n\t\t *\r\n\t\t * @type {Number}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.counter = 0;\r\n\r\n\t\t/**\r\n\t\t * A random break point for the sporadic glitch activation.\r\n\t\t *\r\n\t\t * @type {Number}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.breakPoint = randomInt(120, 240);\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * The current perturbation map.\r\n\t *\r\n\t * @type {Texture}\r\n\t */\r\n\r\n\tget perturbMap() { return this.texture; }\r\n\r\n\t/**\r\n\t * Assigning a new perturbation map does not destroy the current one!\r\n\t *\r\n\t * @type {Texture}\r\n\t */\r\n\r\n\tset perturbMap(x) {\r\n\r\n\t\tthis.texture = x;\r\n\t\tthis.material.uniforms.tPerturb.value = x;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Destroys the current perturbation map and replaces it with a new one.\r\n\t *\r\n\t * @param {Number} [size=64] - The texture size.\r\n\t * @return {DataTexture} The perturbation texture.\r\n\t */\r\n\r\n\tgeneratePerturbMap(size = 64) {\r\n\r\n\t\tconst pixels = size * size;\r\n\t\tconst data = new Float32Array(pixels * 3);\r\n\r\n\t\tlet dt = this.perturbMap;\r\n\t\tlet i, x;\r\n\r\n\t\tfor(i = 0; i < pixels; ++i) {\r\n\r\n\t\t\tx = Math.random();\r\n\r\n\t\t\tdata[i * 3] = x;\r\n\t\t\tdata[i * 3 + 1] = x;\r\n\t\t\tdata[i * 3 + 2] = x;\r\n\r\n\t\t}\r\n\r\n\t\tif(dt !== null) {\r\n\r\n\t\t\tdt.dispose();\r\n\r\n\t\t}\r\n\r\n\t\tdt = new DataTexture(data, size, size, RGBFormat, FloatType);\r\n\t\tdt.needsUpdate = true;\r\n\r\n\t\tthis.perturbMap = dt;\r\n\r\n\t\treturn dt;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Renders the effect.\r\n\t *\r\n\t * @param {WebGLRenderer} renderer - The renderer.\r\n\t * @param {WebGLRenderTarget} readBuffer - The read buffer.\r\n\t * @param {WebGLRenderTarget} writeBuffer - The write buffer.\r\n\t */\r\n\r\n\trender(renderer, readBuffer, writeBuffer) {\r\n\r\n\t\tconst mode = this.mode;\r\n\t\tconst counter = this.counter;\r\n\t\tconst breakPoint = this.breakPoint;\r\n\t\tconst uniforms = this.material.uniforms;\r\n\r\n\t\tuniforms.tDiffuse.value = readBuffer.texture;\r\n\t\tuniforms.seed.value = Math.random();\r\n\t\tuniforms.active.value = true;\r\n\r\n\t\tif(counter % breakPoint === 0 || mode === GlitchMode.CONSTANT_WILD) {\r\n\r\n\t\t\tuniforms.amount.value = Math.random() / 30.0;\r\n\t\t\tuniforms.angle.value = randomFloat(-Math.PI, Math.PI);\r\n\t\t\tuniforms.seedX.value = randomFloat(-1.0, 1.0);\r\n\t\t\tuniforms.seedY.value = randomFloat(-1.0, 1.0);\r\n\t\t\tuniforms.distortionX.value = randomFloat(0.0, 1.0);\r\n\t\t\tuniforms.distortionY.value = randomFloat(0.0, 1.0);\r\n\r\n\t\t\tthis.breakPoint = randomInt(120, 240);\r\n\t\t\tthis.counter = 0;\r\n\r\n\t\t} else {\r\n\r\n\t\t\tif(counter % breakPoint < breakPoint / 5 || mode === GlitchMode.CONSTANT_MILD) {\r\n\r\n\t\t\t\tuniforms.amount.value = Math.random() / 90.0;\r\n\t\t\t\tuniforms.angle.value = randomFloat(-Math.PI, Math.PI);\r\n\t\t\t\tuniforms.distortionX.value = randomFloat(0.0, 1.0);\r\n\t\t\t\tuniforms.distortionY.value = randomFloat(0.0, 1.0);\r\n\t\t\t\tuniforms.seedX.value = randomFloat(-0.3, 0.3);\r\n\t\t\t\tuniforms.seedY.value = randomFloat(-0.3, 0.3);\r\n\r\n\t\t\t} else {\r\n\r\n\t\t\t\t// Sporadic.\r\n\t\t\t\tuniforms.active.value = false;\r\n\r\n\t\t\t}\r\n\r\n\t\t}\r\n\r\n\t\t++this.counter;\r\n\r\n\t\trenderer.render(this.scene, this.camera, this.renderToScreen ? null : writeBuffer);\r\n\r\n\t}\r\n\r\n}\r\n\r\n/**\r\n * A glitch mode enumeration.\r\n *\r\n * @type {Object}\r\n * @property {Number} SPORADIC - Sporadic glitches.\r\n * @property {Number} CONSTANT_MILD - Constant mild glitches.\r\n * @property {Number} CONSTANT_WILD - Constant wild glitches.\r\n */\r\n\r\nexport const GlitchMode = {\r\n\r\n\tSPORADIC: 0,\r\n\tCONSTANT_MILD: 1,\r\n\tCONSTANT_WILD: 2\r\n\r\n};\r\n","import { ClearPass } from \"./clear.js\";\r\nimport { Pass } from \"./pass.js\";\r\n\r\n/**\r\n * A pass that renders a given scene directly on screen or into the read buffer\r\n * for further processing.\r\n */\r\n\r\nexport class RenderPass extends Pass {\r\n\r\n\t/**\r\n\t * Constructs a new render pass.\r\n\t *\r\n\t * @param {Scene} scene - The scene to render.\r\n\t * @param {Camera} camera - The camera to use to render the scene.\r\n\t * @param {Object} [options] - Additional options.\r\n\t * @param {Material} [options.overrideMaterial=null] - An override material for the scene.\r\n\t * @param {Color} [options.clearColor=null] - An override clear color.\r\n\t * @param {Number} [options.clearAlpha=1.0] - An override clear alpha.\r\n\t * @param {Boolean} [options.clearDepth=false] - Whether depth should be cleared explicitly.\r\n\t * @param {Boolean} [options.clear=true] - Whether all buffers should be cleared.\r\n\t */\r\n\r\n\tconstructor(scene, camera, options = {}) {\r\n\r\n\t\tsuper(scene, camera, null);\r\n\r\n\t\t/**\r\n\t\t * The name of this pass.\r\n\t\t */\r\n\r\n\t\tthis.name = \"RenderPass\";\r\n\r\n\t\t/**\r\n\t\t * A clear pass.\r\n\t\t *\r\n\t\t * @type {ClearPass}\r\n\t\t */\r\n\r\n\t\tthis.clearPass = new ClearPass(options);\r\n\r\n\t\t/**\r\n\t\t * An override material.\r\n\t\t *\r\n\t\t * @type {Material}\r\n\t\t * @default null\r\n\t\t */\r\n\r\n\t\tthis.overrideMaterial = (options.overrideMaterial !== undefined) ? options.overrideMaterial : null;\r\n\r\n\t\t/**\r\n\t\t * Indicates whether the depth buffer should be cleared explicitly.\r\n\t\t *\r\n\t\t * @type {Boolean}\r\n\t\t * @default false\r\n\t\t */\r\n\r\n\t\tthis.clearDepth = (options.clearDepth !== undefined) ? options.clearDepth : false;\r\n\r\n\t\t/**\r\n\t\t * Indicates whether the color, depth and stencil buffers should be cleared.\r\n\t\t *\r\n\t\t * Even with clear set to true you can prevent specific buffers from being\r\n\t\t * cleared by setting either the autoClearColor, autoClearStencil or\r\n\t\t * autoClearDepth properties of the renderer to false.\r\n\t\t *\r\n\t\t * @type {Boolean}\r\n\t\t * @default true\r\n\t\t */\r\n\r\n\t\tthis.clear = (options.clear !== undefined) ? options.clear : true;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Renders the scene.\r\n\t *\r\n\t * @param {WebGLRenderer} renderer - The renderer.\r\n\t * @param {WebGLRenderTarget} readBuffer - The read buffer.\r\n\t */\r\n\r\n\trender(renderer, readBuffer) {\r\n\r\n\t\tconst scene = this.scene;\r\n\t\tconst target = this.renderToScreen ? null : readBuffer;\r\n\r\n\t\tif(this.clear) {\r\n\r\n\t\t\tthis.clearPass.render(renderer, target);\r\n\r\n\t\t} else if(this.clearDepth) {\r\n\r\n\t\t\trenderer.setRenderTarget(target);\r\n\t\t\trenderer.clearDepth();\r\n\r\n\t\t}\r\n\r\n\t\tscene.overrideMaterial = this.overrideMaterial;\r\n\t\trenderer.render(scene, this.camera, target);\r\n\t\tscene.overrideMaterial = null;\r\n\r\n\t}\r\n\r\n}\r\n","import { Pass } from \"./pass.js\";\r\n\r\n/**\r\n * A mask pass.\r\n */\r\n\r\nexport class MaskPass extends Pass {\r\n\r\n\t/**\r\n\t * Constructs a new mask pass.\r\n\t *\r\n\t * @param {Scene} scene - The scene to render.\r\n\t * @param {Camera} camera - The camera to use.\r\n\t */\r\n\r\n\tconstructor(scene, camera) {\r\n\r\n\t\tsuper(scene, camera, null);\r\n\r\n\t\t/**\r\n\t\t * The name of this pass.\r\n\t\t */\r\n\r\n\t\tthis.name = \"MaskPass\";\r\n\r\n\t\t/**\r\n\t\t * Inverse flag.\r\n\t\t *\r\n\t\t * @type {Boolean}\r\n\t\t * @default false\r\n\t\t */\r\n\r\n\t\tthis.inverse = false;\r\n\r\n\t\t/**\r\n\t\t * Stencil buffer clear flag.\r\n\t\t *\r\n\t\t * @type {Boolean}\r\n\t\t * @default true\r\n\t\t */\r\n\r\n\t\tthis.clearStencil = true;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a stencil bit mask.\r\n\t *\r\n\t * @param {WebGLRenderer} renderer - The renderer.\r\n\t * @param {WebGLRenderTarget} readBuffer - The read buffer.\r\n\t * @param {WebGLRenderTarget} writeBuffer - The write buffer.\r\n\t */\r\n\r\n\trender(renderer, readBuffer, writeBuffer) {\r\n\r\n\t\tconst context = renderer.context;\r\n\t\tconst state = renderer.state;\r\n\r\n\t\tconst scene = this.scene;\r\n\t\tconst camera = this.camera;\r\n\r\n\t\tconst writeValue = this.inverse ? 0 : 1;\r\n\t\tconst clearValue = 1 - writeValue;\r\n\r\n\t\t// Don't update color or depth.\r\n\t\tstate.buffers.color.setMask(false);\r\n\t\tstate.buffers.depth.setMask(false);\r\n\r\n\t\t// Lock the buffers.\r\n\t\tstate.buffers.color.setLocked(true);\r\n\t\tstate.buffers.depth.setLocked(true);\r\n\r\n\t\t// Configure the stencil.\r\n\t\tstate.buffers.stencil.setTest(true);\r\n\t\tstate.buffers.stencil.setOp(context.REPLACE, context.REPLACE, context.REPLACE);\r\n\t\tstate.buffers.stencil.setFunc(context.ALWAYS, writeValue, 0xffffffff);\r\n\t\tstate.buffers.stencil.setClear(clearValue);\r\n\r\n\t\t// Clear the stencil.\r\n\t\tif(this.clearStencil) {\r\n\r\n\t\t\trenderer.setRenderTarget(readBuffer);\r\n\t\t\trenderer.clearStencil();\r\n\r\n\t\t\trenderer.setRenderTarget(writeBuffer);\r\n\t\t\trenderer.clearStencil();\r\n\r\n\t\t}\r\n\r\n\t\t// Draw the mask into both buffers.\r\n\t\trenderer.render(scene, camera, readBuffer);\r\n\t\trenderer.render(scene, camera, writeBuffer);\r\n\r\n\t\t// Unlock the buffers.\r\n\t\tstate.buffers.color.setLocked(false);\r\n\t\tstate.buffers.depth.setLocked(false);\r\n\r\n\t\t// Only render where the stencil is set to 1.\r\n\t\tstate.buffers.stencil.setFunc(context.EQUAL, 1, 0xffffffff);\r\n\t\tstate.buffers.stencil.setOp(context.KEEP, context.KEEP, context.KEEP);\r\n\r\n\t}\r\n\r\n}\r\n","import { Pass } from \"./pass.js\";\r\n\r\n/**\r\n * A shader pass.\r\n *\r\n * Used to render any shader material as a 2D filter.\r\n */\r\n\r\nexport class ShaderPass extends Pass {\r\n\r\n\t/**\r\n\t * Constructs a new shader pass.\r\n\t *\r\n\t * @param {ShaderMaterial} material - The shader material to use.\r\n\t * @param {String} [textureID=\"tDiffuse\"] - The texture uniform identifier.\r\n\t */\r\n\r\n\tconstructor(material, textureID = \"tDiffuse\") {\r\n\r\n\t\tsuper();\r\n\r\n\t\t/**\r\n\t\t * The name of this pass.\r\n\t\t */\r\n\r\n\t\tthis.name = \"ShaderPass\";\r\n\r\n\t\t/**\r\n\t\t * This pass renders to the write buffer.\r\n\t\t */\r\n\r\n\t\tthis.needsSwap = true;\r\n\r\n\t\t/**\r\n\t\t * The shader material to use for rendering.\r\n\t\t *\r\n\t\t * @type {ShaderMaterial}\r\n\t\t */\r\n\r\n\t\tthis.material = material;\r\n\r\n\t\tthis.quad.material = this.material;\r\n\r\n\t\t/**\r\n\t\t * The name of the color sampler uniform of the given material.\r\n\t\t *\r\n\t\t * @type {String}\r\n\t\t * @default \"tDiffuse\"\r\n\t\t */\r\n\r\n\t\tthis.textureID = textureID;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Renders the effect.\r\n\t *\r\n\t * @param {WebGLRenderer} renderer - The renderer.\r\n\t * @param {WebGLRenderTarget} readBuffer - The read buffer.\r\n\t * @param {WebGLRenderTarget} writeBuffer - The write buffer.\r\n\t */\r\n\r\n\trender(renderer, readBuffer, writeBuffer) {\r\n\r\n\t\tif(this.material.uniforms[this.textureID] !== undefined) {\r\n\r\n\t\t\tthis.material.uniforms[this.textureID].value = readBuffer.texture;\r\n\r\n\t\t}\r\n\r\n\t\trenderer.render(this.scene, this.camera, this.renderToScreen ? null : writeBuffer);\r\n\r\n\t}\r\n\r\n}\r\n","import { Vector3 } from \"three\";\r\nimport { CopyMaterial, ShockWaveMaterial } from \"../materials\";\r\nimport { Pass } from \"./pass.js\";\r\n\r\n/**\r\n * Half PI.\r\n *\r\n * @type {Number}\r\n * @private\r\n * @static\r\n * @final\r\n */\r\n\r\nconst HALF_PI = Math.PI * 0.5;\r\n\r\n/**\r\n * A vector.\r\n *\r\n * @type {Vector3}\r\n * @private\r\n * @static\r\n * @final\r\n */\r\n\r\nconst v = new Vector3();\r\n\r\n/**\r\n * A vector.\r\n *\r\n * @type {Vector3}\r\n * @private\r\n * @static\r\n * @final\r\n */\r\n\r\nconst ab = new Vector3();\r\n\r\n/**\r\n * A shock wave pass.\r\n */\r\n\r\nexport class ShockWavePass extends Pass {\r\n\r\n\t/**\r\n\t * Constructs a new shock wave pass.\r\n\t *\r\n\t * @param {Camera} camera - The main camera.\r\n\t * @param {Vector3} [epicenter] - The world position of the shock wave epicenter.\r\n\t * @param {Object} [options] - The options.\r\n\t * @param {Number} [options.speed=1.0] - The animation speed.\r\n\t * @param {Number} [options.maxRadius=1.0] - The extent of the shock wave.\r\n\t * @param {Number} [options.waveSize=0.2] - The wave size.\r\n\t * @param {Number} [options.amplitude=0.05] - The distortion amplitude.\r\n\t */\r\n\r\n\tconstructor(camera, epicenter = new Vector3(), options = {}) {\r\n\r\n\t\tsuper();\r\n\r\n\t\t/**\r\n\t\t * The name of this pass.\r\n\t\t */\r\n\r\n\t\tthis.name = \"ShockWavePass\";\r\n\r\n\t\t/**\r\n\t\t * This pass renders to the write buffer.\r\n\t\t */\r\n\r\n\t\tthis.needsSwap = true;\r\n\r\n\t\t/**\r\n\t\t * The main camera.\r\n\t\t *\r\n\t\t * @type {Object3D}\r\n\t\t */\r\n\r\n\t\tthis.mainCamera = camera;\r\n\r\n\t\t/**\r\n\t\t * The epicenter.\r\n\t\t *\r\n\t\t * @type {Vector3}\r\n\t\t * @example shockWavePass.epicenter = myMesh.position;\r\n\t\t */\r\n\r\n\t\tthis.epicenter = epicenter;\r\n\r\n\t\t/**\r\n\t\t * The object position in screen space.\r\n\t\t *\r\n\t\t * @type {Vector3}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.screenPosition = new Vector3();\r\n\r\n\t\t/**\r\n\t\t * The speed of the shock wave animation.\r\n\t\t *\r\n\t\t * @type {Number}\r\n\t\t * @default 2.0\r\n\t\t */\r\n\r\n\t\tthis.speed = (options.speed !== undefined) ? options.speed : 2.0;\r\n\r\n\t\t/**\r\n\t\t * A time accumulator.\r\n\t\t *\r\n\t\t * @type {Number}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.time = 0.0;\r\n\r\n\t\t/**\r\n\t\t * Indicates whether the shock wave animation is active.\r\n\t\t *\r\n\t\t * @type {Boolean}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.active = false;\r\n\r\n\t\t/**\r\n\t\t * A shock wave shader material.\r\n\t\t *\r\n\t\t * @type {ShockWaveMaterial}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.shockWaveMaterial = new ShockWaveMaterial(options);\r\n\r\n\t\tthis.shockWaveMaterial.uniforms.center.value = this.screenPosition;\r\n\r\n\t\t/**\r\n\t\t * A copy shader material.\r\n\t\t *\r\n\t\t * @type {CopyMaterial}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.copyMaterial = new CopyMaterial();\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Emits the shock wave.\r\n\t */\r\n\r\n\texplode() {\r\n\r\n\t\tthis.time = 0.0;\r\n\t\tthis.active = true;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Renders the effect.\r\n\t *\r\n\t * @param {WebGLRenderer} renderer - The renderer.\r\n\t * @param {WebGLRenderTarget} readBuffer - The read buffer.\r\n\t * @param {WebGLRenderTarget} writeBuffer - The write buffer.\r\n\t * @param {Number} delta - The render delta time.\r\n\t */\r\n\r\n\trender(renderer, readBuffer, writeBuffer, delta) {\r\n\r\n\t\tconst epicenter = this.epicenter;\r\n\t\tconst mainCamera = this.mainCamera;\r\n\t\tconst screenPosition = this.screenPosition;\r\n\r\n\t\tconst shockWaveMaterial = this.shockWaveMaterial;\r\n\t\tconst uniforms = shockWaveMaterial.uniforms;\r\n\t\tconst center = uniforms.center;\r\n\t\tconst radius = uniforms.radius;\r\n\t\tconst maxRadius = uniforms.maxRadius;\r\n\t\tconst waveSize = uniforms.waveSize;\r\n\r\n\t\tthis.copyMaterial.uniforms.tDiffuse.value = readBuffer.texture;\r\n\t\tthis.quad.material = this.copyMaterial;\r\n\r\n\t\tif(this.active) {\r\n\r\n\t\t\t// Calculate direction vectors.\r\n\t\t\tmainCamera.getWorldDirection(v);\r\n\t\t\tab.copy(mainCamera.position).sub(epicenter);\r\n\r\n\t\t\t// Don't render the effect if the object is behind the camera.\r\n\t\t\tif(v.angleTo(ab) > HALF_PI) {\r\n\r\n\t\t\t\t// Scale the effect based on distance to the object.\r\n\t\t\t\tuniforms.cameraDistance.value = mainCamera.position.distanceTo(epicenter);\r\n\r\n\t\t\t\t// Calculate the screen position of the epicenter.\r\n\t\t\t\tscreenPosition.copy(epicenter).project(mainCamera);\r\n\t\t\t\tcenter.value.x = (screenPosition.x + 1.0) * 0.5;\r\n\t\t\t\tcenter.value.y = (screenPosition.y + 1.0) * 0.5;\r\n\r\n\t\t\t\tuniforms.tDiffuse.value = readBuffer.texture;\r\n\t\t\t\tthis.quad.material = shockWaveMaterial;\r\n\r\n\t\t\t}\r\n\r\n\t\t\t// Update the shock wave radius based on time.\r\n\t\t\tthis.time += delta;\r\n\t\t\tradius.value = this.time * this.speed - waveSize.value;\r\n\r\n\t\t\tif(radius.value >= (maxRadius.value + waveSize.value) * 2) {\r\n\r\n\t\t\t\tthis.active = false;\r\n\r\n\t\t\t}\r\n\r\n\t\t}\r\n\r\n\t\trenderer.render(this.scene, this.camera, this.renderToScreen ? null : writeBuffer);\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Updates this pass with the renderer's size.\r\n\t *\r\n\t * @param {Number} width - The width.\r\n\t * @param {Number} height - The height.\r\n\t */\r\n\r\n\tsetSize(width, height) {\r\n\r\n\t\tthis.shockWaveMaterial.uniforms.aspect.value = width / height;\r\n\r\n\t}\r\n\r\n}\r\n","/**\r\n * A compilation of the post processing passes.\r\n *\r\n * @module postprocessing/passes\r\n */\r\n\r\nexport { BloomPass } from \"./bloom.js\";\r\nexport { BlurPass } from \"./blur.js\";\r\nexport { BokehPass } from \"./bokeh.js\";\r\nexport { Bokeh2Pass } from \"./bokeh2.js\";\r\nexport { ClearPass } from \"./clear.js\";\r\nexport { ClearMaskPass } from \"./clear-mask.js\";\r\nexport { DotScreenPass } from \"./dot-screen.js\";\r\nexport { DepthPass } from \"./depth.js\";\r\nexport { FilmPass } from \"./film.js\";\r\nexport { GlitchMode, GlitchPass } from \"./glitch.js\";\r\nexport { GodRaysPass } from \"./god-rays.js\";\r\nexport { MaskPass } from \"./mask.js\";\r\nexport { Pass } from \"./pass.js\";\r\nexport { PixelationPass } from \"./pixelation.js\";\r\nexport { RenderPass } from \"./render.js\";\r\nexport { SavePass } from \"./save.js\";\r\nexport { ShaderPass } from \"./shader.js\";\r\nexport { ShockWavePass } from \"./shock-wave.js\";\r\nexport { SMAAPass } from \"./smaa.js\";\r\nexport { TexturePass } from \"./texture.js\";\r\nexport { ToneMappingPass } from \"./tone-mapping.js\";\r\n","import {\r\n\tDepthStencilFormat,\r\n\tDepthTexture,\r\n\tLinearFilter,\r\n\tRGBAFormat,\r\n\tRGBFormat,\r\n\tUnsignedInt248Type,\r\n\tWebGLRenderTarget\r\n} from \"three\";\r\n\r\nimport { ClearMaskPass, MaskPass, ShaderPass } from \"../passes\";\r\nimport { CopyMaterial } from \"../materials\";\r\n\r\n/**\r\n * The EffectComposer may be used in place of a normal WebGLRenderer.\r\n *\r\n * The auto clear behaviour of the provided renderer will be disabled to prevent\r\n * unnecessary clear operations.\r\n *\r\n * It is common practice to use a {@link RenderPass} as the first pass to\r\n * automatically clear the screen and render the scene to a texture for further\r\n * processing.\r\n */\r\n\r\nexport class EffectComposer {\r\n\r\n\t/**\r\n\t * Constructs a new effect composer.\r\n\t *\r\n\t * @param {WebGLRenderer} [renderer] - The renderer that should be used.\r\n\t * @param {Object} [options] - The options.\r\n\t * @param {Boolean} [options.depthBuffer=true] - Whether the main render targets should have a depth buffer.\r\n\t * @param {Boolean} [options.stencilBuffer=false] - Whether the main render targets should have a stencil buffer.\r\n\t * @param {Boolean} [options.depthTexture=false] - Set to true if one of your passes relies on a depth texture.\r\n\t */\r\n\r\n\tconstructor(renderer = null, options = {}) {\r\n\r\n\t\t/**\r\n\t\t * The renderer.\r\n\t\t *\r\n\t\t * You may replace the renderer at any time by using\r\n\t\t * {@link EffectComposer#replaceRenderer}.\r\n\t\t *\r\n\t\t * @type {WebGLRenderer}\r\n\t\t */\r\n\r\n\t\tthis.renderer = renderer;\r\n\r\n\t\t/**\r\n\t\t * The read buffer.\r\n\t\t *\r\n\t\t * Reading from and writing to the same render target should be avoided.\r\n\t\t * Therefore, two seperate yet identical buffers are used.\r\n\t\t *\r\n\t\t * @type {WebGLRenderTarget}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.readBuffer = null;\r\n\r\n\t\t/**\r\n\t\t * The write buffer.\r\n\t\t *\r\n\t\t * @type {WebGLRenderTarget}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.writeBuffer = null;\r\n\r\n\t\tif(this.renderer !== null) {\r\n\r\n\t\t\tthis.renderer.autoClear = false;\r\n\r\n\t\t\tthis.readBuffer = this.createBuffer(\r\n\t\t\t\t(options.depthBuffer !== undefined) ? options.depthBuffer : true,\r\n\t\t\t\t(options.stencilBuffer !== undefined) ? options.stencilBuffer : false,\r\n\t\t\t\t(options.depthTexture !== undefined) ? options.depthTexture : false\r\n\t\t\t);\r\n\r\n\t\t\tthis.writeBuffer = this.readBuffer.clone();\r\n\r\n\t\t}\r\n\r\n\t\t/**\r\n\t\t * A copy pass used for copying masked scenes.\r\n\t\t *\r\n\t\t * @type {ShaderPass}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.copyPass = new ShaderPass(new CopyMaterial());\r\n\r\n\t\t/**\r\n\t\t * The passes.\r\n\t\t *\r\n\t\t * @type {Pass[]}\r\n\t\t * @private\r\n\t\t */\r\n\r\n\t\tthis.passes = [];\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * The depth texture of the read and write buffers.\r\n\t *\r\n\t * @type {DepthTexture}\r\n\t * @default null\r\n\t */\r\n\r\n\tget depthTexture() { return this.readBuffer.depthTexture; }\r\n\r\n\t/**\r\n\t * The read and write buffers share a single depth texture. Depth will be\r\n\t * written to this texture when something is rendered into one of the buffers\r\n\t * and the involved materials have depth write enabled.\r\n\t *\r\n\t * You may enable this mechanism during the instantiation of the composer or\r\n\t * by assigning a DepthTexture instance later on. You may also disable it by\r\n\t * assigning null.\r\n\t *\r\n\t * @type {DepthTexture}\r\n\t */\r\n\r\n\tset depthTexture(x) {\r\n\r\n\t\tthis.readBuffer.depthTexture = x;\r\n\t\tthis.writeBuffer.depthTexture = x;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Replaces the current renderer with the given one. The DOM element of the\r\n\t * current renderer will automatically be removed from its parent node and the\r\n\t * DOM element of the new renderer will take its place.\r\n\t *\r\n\t * The auto clear mechanism of the provided renderer will be disabled.\r\n\t *\r\n\t * Switching between renderers allows you to dynamically enable or disable\r\n\t * antialiasing.\r\n\t *\r\n\t * @param {WebGLRenderer} renderer - The new renderer.\r\n\t * @return {WebGLRenderer} The old renderer.\r\n\t */\r\n\r\n\treplaceRenderer(renderer) {\r\n\r\n\t\tconst oldRenderer = this.renderer;\r\n\r\n\t\tlet parent, oldSize, newSize;\r\n\r\n\t\tif(oldRenderer !== null && oldRenderer !== renderer) {\r\n\r\n\t\t\tthis.renderer = renderer;\r\n\t\t\tthis.renderer.autoClear = false;\r\n\r\n\t\t\tparent = oldRenderer.domElement.parentNode;\r\n\t\t\toldSize = oldRenderer.getSize();\r\n\t\t\tnewSize = renderer.getSize();\r\n\r\n\t\t\tif(parent !== null) {\r\n\r\n\t\t\t\tparent.removeChild(oldRenderer.domElement);\r\n\t\t\t\tparent.appendChild(renderer.domElement);\r\n\r\n\t\t\t}\r\n\r\n\t\t\tif(oldSize.width !== newSize.width || oldSize.height !== newSize.height) {\r\n\r\n\t\t\t\tthis.setSize();\r\n\r\n\t\t\t}\r\n\r\n\t\t}\r\n\r\n\t\treturn oldRenderer;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a new render target by replicating the renderer's canvas.\r\n\t *\r\n\t * The created render target uses a linear filter for texel minification and\r\n\t * magnification. Its render texture format depends on whether the renderer\r\n\t * uses the alpha channel. Mipmaps are disabled.\r\n\t *\r\n\t * @param {Boolean} depthBuffer - Whether the render target should have a depth buffer.\r\n\t * @param {Boolean} stencilBuffer - Whether the render target should have a stencil buffer.\r\n\t * @param {Boolean} depthTexture - Whether the render target should have a depth texture.\r\n\t * @return {WebGLRenderTarget} A new render target that equals the renderer's canvas.\r\n\t */\r\n\r\n\tcreateBuffer(depthBuffer, stencilBuffer, depthTexture) {\r\n\r\n\t\tconst size = this.renderer.getSize();\r\n\t\tconst pixelRatio = this.renderer.getPixelRatio();\r\n\t\tconst alpha = this.renderer.context.getContextAttributes().alpha;\r\n\r\n\t\tconst renderTarget = new WebGLRenderTarget(size.width * pixelRatio, size.height * pixelRatio, {\r\n\t\t\tminFilter: LinearFilter,\r\n\t\t\tmagFilter: LinearFilter,\r\n\t\t\tformat: alpha ? RGBAFormat : RGBFormat,\r\n\t\t\tdepthBuffer: depthBuffer,\r\n\t\t\tstencilBuffer: stencilBuffer,\r\n\t\t\tdepthTexture: depthTexture ? new DepthTexture() : null\r\n\t\t});\r\n\r\n\t\tif(depthTexture && stencilBuffer) {\r\n\r\n\t\t\trenderTarget.depthTexture.format = DepthStencilFormat;\r\n\t\t\trenderTarget.depthTexture.type = UnsignedInt248Type;\r\n\r\n\t\t}\r\n\r\n\t\trenderTarget.texture.name = \"EffectComposer.Buffer\";\r\n\t\trenderTarget.texture.generateMipmaps = false;\r\n\r\n\t\treturn renderTarget;\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Adds a pass, optionally at a specific index.\r\n\t *\r\n\t * @param {Pass} pass - A new pass.\r\n\t * @param {Number} [index] - An index at which the pass should be inserted.\r\n\t */\r\n\r\n\taddPass(pass, index) {\r\n\r\n\t\tconst renderer = this.renderer;\r\n\t\tconst size = renderer.getSize();\r\n\t\tconst pixelRatio = renderer.getPixelRatio();\r\n\r\n\t\tpass.setSize(size.width * pixelRatio, size.height * pixelRatio);\r\n\t\tpass.initialise(renderer, renderer.context.getContextAttributes().alpha);\r\n\r\n\t\tif(index !== undefined) {\r\n\r\n\t\t\tthis.passes.splice(index, 0, pass);\r\n\r\n\t\t} else {\r\n\r\n\t\t\tthis.passes.push(pass);\r\n\r\n\t\t}\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Removes a pass.\r\n\t *\r\n\t * @param {Pass} pass - The pass.\r\n\t */\r\n\r\n\tremovePass(pass) {\r\n\r\n\t\tthis.passes.splice(this.passes.indexOf(pass), 1);\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Renders all enabled passes in the order in which they were added.\r\n\t *\r\n\t * @param {Number} delta - The time between the last frame and the current one in seconds.\r\n\t */\r\n\r\n\trender(delta) {\r\n\r\n\t\tconst passes = this.passes;\r\n\t\tconst renderer = this.renderer;\r\n\t\tconst copyPass = this.copyPass;\r\n\r\n\t\tlet readBuffer = this.readBuffer;\r\n\t\tlet writeBuffer = this.writeBuffer;\r\n\r\n\t\tlet maskActive = false;\r\n\t\tlet pass, context, buffer;\r\n\t\tlet i, l;\r\n\r\n\t\tfor(i = 0, l = passes.length; i < l; ++i) {\r\n\r\n\t\t\tpass = passes[i];\r\n\r\n\t\t\tif(pass.enabled) {\r\n\r\n\t\t\t\tpass.render(renderer, readBuffer, writeBuffer, delta, maskActive);\r\n\r\n\t\t\t\tif(pass.needsSwap) {\r\n\r\n\t\t\t\t\tif(maskActive) {\r\n\r\n\t\t\t\t\t\tcontext = renderer.context;\r\n\t\t\t\t\t\tcontext.stencilFunc(context.NOTEQUAL, 1, 0xffffffff);\r\n\t\t\t\t\t\tcopyPass.render(renderer, readBuffer, writeBuffer);\r\n\t\t\t\t\t\tcontext.stencilFunc(context.EQUAL, 1, 0xffffffff);\r\n\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tbuffer = readBuffer;\r\n\t\t\t\t\treadBuffer = writeBuffer;\r\n\t\t\t\t\twriteBuffer = buffer;\r\n\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif(pass instanceof MaskPass) {\r\n\r\n\t\t\t\t\tmaskActive = true;\r\n\r\n\t\t\t\t} else if(pass instanceof ClearMaskPass) {\r\n\r\n\t\t\t\t\tmaskActive = false;\r\n\r\n\t\t\t\t}\r\n\r\n\t\t\t}\r\n\r\n\t\t}\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Sets the size of the buffers and the renderer's output canvas.\r\n\t *\r\n\t * Every pass will be informed of the new size. It's up to each pass how that\r\n\t * information is used.\r\n\t *\r\n\t * If no width or height is specified, the render targets and passes will be\r\n\t * updated with the current size of the renderer.\r\n\t *\r\n\t * @param {Number} [width] - The width.\r\n\t * @param {Number} [height] - The height.\r\n\t */\r\n\r\n\tsetSize(width, height) {\r\n\r\n\t\tconst passes = this.passes;\r\n\t\tconst size = this.renderer.getSize();\r\n\t\tconst pixelRatio = this.renderer.getPixelRatio();\r\n\r\n\t\tlet i, l;\r\n\r\n\t\tif(width === undefined || height === undefined) {\r\n\r\n\t\t\twidth = size.width;\r\n\t\t\theight = size.height;\r\n\r\n\t\t}\r\n\r\n\t\tthis.renderer.setSize(width, height);\r\n\r\n\t\twidth *= pixelRatio;\r\n\t\theight *= pixelRatio;\r\n\r\n\t\tthis.readBuffer.setSize(width, height);\r\n\t\tthis.writeBuffer.setSize(width, height);\r\n\r\n\t\tfor(i = 0, l = passes.length; i < l; ++i) {\r\n\r\n\t\t\tpasses[i].setSize(width, height);\r\n\r\n\t\t}\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Resets this composer by deleting all passes and creating new buffers.\r\n\t *\r\n\t * @param {WebGLRenderTarget} [renderTarget] - A new render target. If none is provided, the settings of the renderer will be used.\r\n\t */\r\n\r\n\treset(renderTarget) {\r\n\r\n\t\tconst depthBuffer = this.readBuffer.depthBuffer;\r\n\t\tconst stencilBuffer = this.readBuffer.stencilBuffer;\r\n\t\tconst depthTexture = (this.readBuffer.depthTexture !== null);\r\n\r\n\t\tthis.dispose((renderTarget === undefined) ?\r\n\t\t\tthis.createBuffer(depthBuffer, stencilBuffer, depthTexture) :\r\n\t\t\trenderTarget\r\n\t\t);\r\n\r\n\t}\r\n\r\n\t/**\r\n\t * Destroys all passes and render targets.\r\n\t *\r\n\t * This method deallocates all render targets, textures and materials created\r\n\t * by the passes. It also deletes this composer's frame buffers.\r\n\t *\r\n\t * @param {WebGLRenderTarget} [renderTarget] - A new render target. If none is provided, the composer will become inoperative.\r\n\t */\r\n\r\n\tdispose(renderTarget) {\r\n\r\n\t\tconst passes = this.passes;\r\n\r\n\t\tif(this.readBuffer !== null && this.writeBuffer !== null) {\r\n\r\n\t\t\tthis.readBuffer.dispose();\r\n\t\t\tthis.writeBuffer.dispose();\r\n\r\n\t\t\tthis.readBuffer = null;\r\n\t\t\tthis.writeBuffer = null;\r\n\r\n\t\t}\r\n\r\n\t\twhile(passes.length > 0) {\r\n\r\n\t\t\tpasses.pop().dispose();\r\n\r\n\t\t}\r\n\r\n\t\tif(renderTarget !== undefined) {\r\n\r\n\t\t\t// Reanimate.\r\n\t\t\tthis.readBuffer = renderTarget;\r\n\t\t\tthis.writeBuffer = this.readBuffer.clone();\r\n\r\n\t\t} else {\r\n\r\n\t\t\tthis.copyPass.dispose();\r\n\r\n\t\t}\r\n\r\n\t}\r\n\r\n}\r\n","/**\r\n * Core components.\r\n *\r\n * @module postprocessing/core\r\n */\r\n\r\nexport { EffectComposer } from \"./effect-composer.js\";\r\n","/**\r\n * Exposure of the library components.\r\n *\r\n * @module postprocessing\r\n */\r\n\r\nexport { EffectComposer } from \"./core\";\r\n\r\nexport {\r\n\tBloomPass,\r\n\tBlurPass,\r\n\tBokehPass,\r\n\tBokeh2Pass,\r\n\tClearPass,\r\n\tClearMaskPass,\r\n\tDepthPass,\r\n\tDotScreenPass,\r\n\tFilmPass,\r\n\tGlitchMode,\r\n\tGlitchPass,\r\n\tGodRaysPass,\r\n\tMaskPass,\r\n\tPass,\r\n\tPixelationPass,\r\n\tRenderPass,\r\n\tSavePass,\r\n\tShaderPass,\r\n\tShockWavePass,\r\n\tSMAAPass,\r\n\tTexturePass,\r\n\tToneMappingPass\r\n} from \"./passes\";\r\n\r\nexport {\r\n\tAdaptiveLuminosityMaterial,\r\n\tBokehMaterial,\r\n\tBokeh2Material,\r\n\tCombineMaterial,\r\n\tConvolutionMaterial,\r\n\tCopyMaterial,\r\n\tDepthMaterial,\r\n\tDotScreenMaterial,\r\n\tFilmMaterial,\r\n\tGlitchMaterial,\r\n\tGodRaysMaterial,\r\n\tKernelSize,\r\n\tLuminosityMaterial,\r\n\tPixelationMaterial,\r\n\tShockWaveMaterial,\r\n\tSMAABlendMaterial,\r\n\tSMAAColorEdgesMaterial,\r\n\tSMAAWeightsMaterial,\r\n\tToneMappingMaterial\r\n} from \"./materials\";\r\n","import {\n  EffectComposer,\n  RenderPass,\n  ShaderPass\n} from 'postprocessing';\n\nimport {Loop} from '../../core/Loop';\n\nconst polyfill = (object, method, showWarn = true) => {\n  if (object[method]) return;\n  if (showWarn) console.warn(`@PostProcessorModule: pass.${method}() was not found.`, object);\n  object[method] = () => {};\n};\n\nexport class PostProcessorModule {\n  currentPass = null;\n\n  defer = new Promise(resolve => {\n    this.resolve = resolve;\n  });\n\n  constructor({debug} = {debug: true}) {\n    this.debug = debug;\n  }\n\n  manager(manager) {\n    manager.define('postprocessor');\n\n    this.effects = manager.use('rendering').effects;\n    this.renderer = manager.get('renderer');\n    this.scene = manager.get('scene');\n    this.camera = manager.get('camera');\n\n    this.composer = new EffectComposer(this.renderer);\n\n    manager.use('rendering').stop();\n\n    const composer = this.composer;\n    this.renderLoop = new Loop(clock => composer.render(clock.getDelta())).start(manager.handler);\n\n    manager.update({\n      renderer: renderer => {\n        this.composer.replaceRenderer(renderer);\n      },\n\n      scene: scene => {\n        this.scene = scene;\n      },\n\n      camera: camera => {\n        this.camera = camera;\n      }\n    });\n\n    this.resolve();\n  }\n\n  render() {\n    this.defer.then(() => {\n      const pass = new RenderPass(this.scene, this.camera.native);\n\n      // TODO: Support for effects.\n\n      this.composer.addPass(pass);\n      this.currentPass = pass;\n    });\n\n    return this;\n  }\n\n  // API\n\n  pass(pass) {\n    this.defer.then(() => {\n      polyfill(pass, 'setSize', this.debug);\n      polyfill(pass, 'initialise', this.debug);\n\n      this.composer.addPass(pass);\n      this.currentPass = pass;\n    });\n\n    return this;\n  }\n\n  shader(material, textureID = 'readBuffer') {\n    this.defer.then(() => {\n      if (!material.uniforms[textureID])\n        material.uniforms[textureID] = {value: null};\n\n      const pass = new ShaderPass(material, textureID);\n      this.composer.addPass(pass);\n      this.currentPass = pass;\n    });\n\n    return this;\n  }\n\n  // Pass API\n\n  get(name) {\n    return name\n      ? this.composer.passes.filter(pass => pass.name === name)[0]\n      : this.currentPass;\n  }\n\n  to(name) {\n    this.currentPass = name;\n  }\n\n  renderToScreen(bool = true) {\n    this.defer.then(() => {\n      this.currentPass.renderToScreen = bool;\n    });\n\n    return this;\n  }\n\n  name(name) {\n    this.defer.then(() => {\n      this.currentPass.name = name;\n    });\n\n    return this;\n  }\n}\n","export class EventsPatchModule {\n  manager(manager) {\n    manager.define('events');\n    this.element = manager.get('renderer').domElement;\n  }\n\n  patchEvents(originObject, destObject, events = []) {\n    events.forEach(event =>\n      originObject.addEventListener(event, e => destObject.emit(event, e))\n    );\n  }\n\n  integrate(self) {\n    const {element, patchEvents} = self;\n\n    patchEvents(element, this, [\n      'mousemove',\n      'mouseup',\n      'contextmenu',\n      'mousedown',\n      'click',\n      'wheel',\n      'touchstart',\n      'touchend',\n      'touchmove',\n      'keydown'\n    ]);\n\n    patchEvents(element, this, [\n      'keydown',\n      'keyup',\n      'keypress'\n    ]);\n  }\n}\n","import {\n  Vector2,\n  Raycaster,\n  Plane,\n  Vector3\n} from 'three';\n\nimport Events from 'minivents';\nimport {EventsPatchModule} from './EventsPatchModule';\n\n/**\n * @class VirtualMouseModule\n * @category modules/app\n * @param {Boolean} [globalMovement=false]\n * @memberof module:modules/app\n * @extends Events\n */\nexport class VirtualMouseModule extends Events {\n  mouse = new Vector2();\n  raycaster = new Raycaster();\n  world = null;\n  canvas = null;\n  projectionPlane = new Plane(new Vector3(0, 0, 1), 0);\n\n  constructor(globalMovement = false) {\n    super();\n    this.globalMovement = globalMovement;\n  }\n\n  update(e, customX, customY) {\n    const rect = this.canvas.getBoundingClientRect();\n\n    const x = customX || e.clientX;\n    const y = customY || e.clientY;\n\n    this.mouse.x = ((x - rect.left) / (rect.right - rect.left)) * 2 - 1;\n    this.mouse.y = -((y - rect.top) / (rect.bottom - rect.top)) * 2 + 1;\n\n    this.projectionPlane.normal.copy(this.camera.getWorldDirection());\n\n    this.raycaster.setFromCamera(this.mouse, this.camera);\n    this.emit('move');\n  }\n\n  manager(manager) {\n    manager.define('mouse');\n    manager.require('events', () => new EventsPatchModule());\n\n    this.canvas = manager.get('renderer').domElement;\n    this.camera = manager.get('camera').native;\n  }\n\n  integrate(self) {\n    [\n      'click',\n      'mousedown',\n      'mouseup',\n      'mousemove'\n    ].forEach(ev => this.on(ev, e => self.emit(ev, e)));\n\n    self.globalX = 0;\n    self.globalY = 0;\n\n    this.on('mousemove', e => {\n      if (document.pointerLockElement !== null) {\n        self.globalX += e.movementX;\n        self.globalY += e.movementY;\n\n        self.update(e, self.globalX, self.globalY);\n      } else self.update(e);\n    });\n  }\n\n  track(component, nested = true) {\n    let isHovered = false;\n\n    this.on('move', () => {\n      if (this.hovers(component, nested)) {\n        if (isHovered) component.emit('mousemove');\n        else {\n          component.emit('mouseover');\n          isHovered = true;\n        }\n      } else if (isHovered) {\n        component.emit('mouseout');\n        isHovered = false;\n      }\n    });\n\n    this.on('click', () => {\n      if (isHovered) component.emit('click');\n      else component.emit('offClick');\n    });\n\n    this.on('mousedown', () => {\n      if (isHovered) component.emit('mousedown');\n    });\n\n    this.on('mouseup', () => {\n      if (isHovered) component.emit('mouseup');\n    });\n  }\n\n  intersection({native}, nested = true) {\n    if (native.children.length > 0 && nested) {\n      const objects = [];\n      native.traverse(child => objects.push(child));\n\n      return this.raycaster.intersectObjects(objects);\n    }\n\n    return this.raycaster.intersectObject(native);\n  }\n\n  project(plane = this.projectionPlane) {\n    return this.raycaster.ray.intersectPlane(plane);\n  }\n\n  hovers(component, nested = true) {\n    return this.intersection(component, nested).length > 0;\n  }\n\n  get ray() {\n    return this.raycaster.ray;\n  }\n\n  get x() {\n    return this.mouse.x;\n  }\n\n  get y() {\n    return this.mouse.y;\n  }\n}\n","import {Loop} from '../../core/Loop';\nimport {EventsPatchModule} from './EventsPatchModule';\n\nexport class ControlsModule {\n  static from(controls) {\n    return new ControlsModule({controls});\n  }\n\n  constructor(params = {}) {\n    this.params = Object.assign({\n      controls: false,\n      fix: controls => controls,\n\n      update(c) {\n        this.controls.update(c.getDelta());\n      }\n    }, params);\n\n    this.controls = this.params.controls;\n    this.update = this.params.update;\n  }\n\n  manager(manager) {\n    manager.require('events', () => new EventsPatchModule());\n  }\n\n  setControls(controls) {\n    this.controls = controls;\n    return this;\n  }\n\n  setUpdate(update) {\n    this.update = update;\n    return this;\n  }\n\n  integrate(self) {\n    self.updateLoop = new Loop(self.update.bind(self));\n    self.updateLoop.start(this);\n  }\n}\n","import {\n  FogExp2,\n  Fog\n} from 'three';\n\n/**\n * @class FogModule\n * @category modules/app\n * @param {Object} [params={color: 0xefd1b5, density: 0.020, near: 10, far: 1000}] - The parameters object.\n * @param {String} [type=exp2] - The type of fog - exp2 or linear\n * @memberof module:modules/app\n * @example <caption>How to create and apply a FogModule</caption>\n * const fogModule = new FogModule({\n *    color: 0xffffff,\n *    density: 0.03,\n *    near: 20,\n *    far: 200\n *  }, 'exp2');\n *\n * new App([\n *  ...,\n *  fogModule\n * ]);\n */\nexport class FogModule {\n  constructor(params = {}, type) {\n    this.params = Object.assign({\n      color: 0xefd1b5,\n      density: 0.020,\n      near: 10,\n      far: 1000\n    }, params);\n    if (!type || type === 'exp2') this.fog = new FogExp2(this.params.color, this.params.density);\n    else if (type === 'linear') this.fog = new Fog(this.params.color, this.params.near, this.params.far);\n  }\n\n  manager(manager) {\n    manager.set('fog', this.fog);\n    manager.get('scene').fog = this.fog;\n  }\n}\n","import {createStore} from 'redux';\n\nconst isEqualDefault = (a, b) => {\n  if (a === b) return true;\n  else if (a && a.equals && a.equals(b)) return true;\n\n  return false;\n};\n\n/**\n * @class StateModule\n * @description `StateModule` is useful for apps, where you need state manipulation.\n * This can be: _transitions between screens, games, development moments_.\n * You can check [basic/state](https://whs-dev.surge.sh/examples/?basic/state) example.\n * @category modules/app\n * @param {Object} [params]\n * @memberof module:modules/app\n * @example <caption> Creating a state module</caption>\n * new App([\n *   // ...\n *   new StateModule().default({\n *     sphereColor: 0xff0000\n *   })\n * ]);\n */\nexport class StateModule {\n  static actionGenerate(isEqual) {\n    return (state = [{}, ''], {key, data}) => {\n      if (isEqual(state[0][key], data)) return state;\n\n      state[0][key] = data;\n      state[1] = key;\n\n      return state;\n    };\n  }\n\n  constructor(equalCheck = isEqualDefault) {\n    this.store = createStore(\n      StateModule.actionGenerate(equalCheck)\n    );\n\n    this.configuration = {};\n    this.currentConfig = 'default';\n    this.prevConfig = 'default';\n  }\n\n  /**\n   * @method default\n   * @description Add default configuration.\n   * @param {Object} data Configuration setup\n   * @memberof module:modules/app.StateModule\n   * @example\n   * new WHS.StateModule().default({\n   *   sphereColor: UTILS.$colors.mesh,\n   *   planeColor: 0x447F8B\n   * })\n   */\n  default(data) {\n    this.config({default: data});\n    return this;\n  }\n\n  /**\n   * @method setEqualCheck\n   * @description Sets an equalCheck function\n   * @param {Object} data Configuration setup\n   * @memberof module:modules/app.StateModule\n   */\n  setEqualCheck(func) {\n    this.store.replaceReducer(\n      StateModule.actionGenerate(func)\n    );\n  }\n\n  manager(manager) {\n    manager.define('state');\n  }\n\n  /**\n   * @method config\n   * @description Load configurations from object.\n   * @param {Object} configs Configuration data\n   * @memberof module:modules/app.StateModule\n   * @example <caption> Adding `green` configuration</caption>\n   * state.config({\n   *   green: {\n   *     sphereColor: 0x00ff00,\n   *     planeColor: 0x00ff00\n   *   }\n   * });\n   */\n  config(configs) {\n    for (const key in configs) {\n      if (key) {\n        this.configuration[key] = key === 'default'\n          ? configs[key]\n          : Object.assign({}, this.configuration.default, configs[key]);\n      }\n    }\n  }\n\n  /**\n   * @method update\n   * @description Load updates from object.\n   * @param {Object} updates Updates data\n   * @memberof module:modules/app.StateModule\n   * @example <caption> Update callback for `sphereColor`</caption>\n   * state.update({\n   *   sphereColor: color => sphere.material.color.setHex(color)\n   * });\n   */\n  update(updates = {}) {\n    this.store.subscribe(() => {\n      const [data, changedKey] = this.store.getState();\n      const callback = updates[changedKey];\n\n      if (callback) callback(data[changedKey]);\n    });\n  }\n\n  /**\n   * @method to\n   * @description Switch to configuration.\n   * @param {String} configName Configuration name.\n   * @memberof module:modules/app.StateModule\n   * @example <caption> Changes configuration to `green`</caption>\n   * state.to('green');\n   */\n  to(configName) {\n    this.prevConfig = this.currentConfig;\n    this.currentConfig = configName;\n\n    const config = this.configuration[configName]\n      ? this.configuration[configName]\n      : this.configuration.default;\n\n    this.set(config);\n  }\n\n  /**\n   * @method set\n   * @description Set current parameters.\n   * @param {Object} data Configuration parameters.\n   * @memberof module:modules/app.StateModule\n   * @example\n   * state.set({\n   *   sphereColor: 0x00ff00\n   * });\n   */\n  set(data) {\n    for (const key in data)\n      if (key) this.store.dispatch({type: 'ADD', key, data: data[key]});\n  }\n\n  /**\n   * @method get\n   * @description Return data of parameter.\n   * @param {String} key Parameter name.\n   * @memberof module:modules/app.StateModule\n   * @example\n   * state.get('sphereColor'); // 0x00ff00\n   */\n  get(key) {\n    return this.store.getState()[0][key];\n  }\n\n  /**\n   * @method prev\n   * @description Return `trueVal` if `config` match previous configuration, in other case - return `falseVal`.\n   * @param {String} config Configuration name.\n   * @param {Any} trueVal Value returned if condition is truthy.\n   * @param {Any} falseVal CValue returned if condition is falsy.\n   * @memberof module:modules/app.StateModule\n   */\n  prev(config, trueVal, falseVal) {\n    return this.prevConfig === config ? trueVal : falseVal;\n  }\n\n  /**\n   * @method current\n   * @description Return `trueVal` if `config` match current configuration, in other case - return `falseVal`.\n   * @param {String} config Configuration name.\n   * @param {Any} trueVal Value returned if condition is truthy.\n   * @param {Any} falseVal CValue returned if condition is falsy.\n   * @memberof module:modules/app.StateModule\n   */\n  current(config, trueVal, falseVal) {\n    return this.currentConfig === config ? trueVal : falseVal;\n  }\n}\n","import {\n  MOUSE,\n  Quaternion,\n  Spherical,\n  Vector2,\n  PerspectiveCamera,\n  OrthographicCamera,\n  EventDispatcher,\n  Vector3\n} from 'three';\n\n// This set of controls performs orbiting, dollying (zooming), and panning.\n// Unlike TrackballControls, it maintains the \"up\" direction object.up (+Y by default).\n//\n//    Orbit - left mouse / touch: one finger move\n//    Zoom - middle mouse, or mousewheel / touch: two finger spread or squish\n//    Pan - right mouse, or arrow keys / touch: three finter swipe\n\nexport class ThreeOrbitControls extends EventDispatcher {\n  constructor(object, domElement, eventHandler) {\n    super();\n\n    this.object = object;\n\n    this.domElement = (domElement === undefined) ? document : domElement;\n    this.eventHandler = eventHandler;\n\n    // Set to false to disable this control\n    this.enabled = true;\n\n    // \"target\" sets the location of focus, where the object orbits around\n    this.target = new Vector3();\n\n    // How far you can dolly in and out ( PerspectiveCamera only )\n    this.minDistance = 0;\n    this.maxDistance = Infinity;\n\n    // How far you can zoom in and out ( OrthographicCamera only )\n    this.minZoom = 0;\n    this.maxZoom = Infinity;\n\n    // How far you can orbit vertically, upper and lower limits.\n    // Range is 0 to Math.PI radians.\n    this.minPolarAngle = 0; // radians\n    this.maxPolarAngle = Math.PI; // radians\n\n    // How far you can orbit horizontally, upper and lower limits.\n    // If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ].\n    this.minAzimuthAngle = -Infinity; // radians\n    this.maxAzimuthAngle = Infinity; // radians\n\n    // Set to true to enable damping (inertia)\n    // If damping is enabled, you must call controls.update() in your animation loop\n    this.enableDamping = false;\n    this.dampingFactor = 0.25;\n\n    // This option actually enables dollying in and out; left as \"zoom\" for backwards compatibility.\n    // Set to false to disable zooming\n    this.enableZoom = true;\n    this.zoomSpeed = 1.0;\n\n    // Set to false to disable rotating\n    this.enableRotate = true;\n    this.rotateSpeed = 1.0;\n\n    // Set to false to disable panning\n    this.enablePan = true;\n    this.keyPanSpeed = 7.0; // pixels moved per arrow key push\n\n    // Set to true to automatically rotate around the target\n    // If auto-rotate is enabled, you must call controls.update() in your animation loop\n    this.autoRotate = false;\n    this.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60\n\n    // Set to false to disable use of the keys\n    this.enableKeys = true;\n\n    // The four arrow keys\n    this.keys = {LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40};\n\n    // Mouse buttons\n    this.mouseButtons = {ORBIT: MOUSE.LEFT, ZOOM: MOUSE.MIDDLE, PAN: MOUSE.RIGHT};\n\n    // for reset\n    this.target0 = this.target.clone();\n    this.position0 = this.object.position.clone();\n    this.zoom0 = this.object.zoom;\n\n    //\n    // public methods\n    //\n\n    this.getPolarAngle = () => {\n      return spherical.phi;\n    };\n\n    this.getAzimuthalAngle = () => {\n      return spherical.theta;\n    };\n\n    this.reset = () => {\n      this.target.copy(this.target0);\n      this.object.position.copy(this.position0);\n      this.object.zoom = this.zoom0;\n\n      this.object.updateProjectionMatrix();\n      this.dispatchEvent(changeEvent);\n\n      this.update();\n\n      state = STATE.NONE;\n    };\n\n    // this method is exposed, but perhaps it would be better if we can make it private...\n    this.update = () => {\n      const offset = new Vector3();\n\n      // so camera.up is the orbit axis\n      const quat = new Quaternion().setFromUnitVectors(object.up, new Vector3(0, 1, 0));\n      const quatInverse = quat.clone().inverse();\n\n      const lastPosition = new Vector3();\n      const lastQuaternion = new Quaternion();\n\n      return (() => {\n        const position = this.object.position;\n\n        offset.copy(position).sub(this.target);\n\n        // rotate offset to \"y-axis-is-up\" space\n        offset.applyQuaternion(quat);\n\n        // angle from z-axis around y-axis\n        spherical.setFromVector3(offset);\n\n        if (this.autoRotate && state === STATE.NONE)\n          rotateLeft(getAutoRotationAngle());\n\n        spherical.theta += sphericalDelta.theta;\n        spherical.phi += sphericalDelta.phi;\n\n        // restrict theta to be between desired limits\n        spherical.theta = Math.max(this.minAzimuthAngle, Math.min(this.maxAzimuthAngle, spherical.theta));\n\n        // restrict phi to be between desired limits\n        spherical.phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, spherical.phi));\n\n        spherical.makeSafe();\n\n        spherical.radius *= scale;\n\n        // restrict radius to be between desired limits\n        spherical.radius = Math.max(this.minDistance, Math.min(this.maxDistance, spherical.radius));\n\n        // move target to panned location\n        this.target.add(panOffset);\n\n        offset.setFromSpherical(spherical);\n\n        // rotate offset back to \"camera-up-vector-is-up\" space\n        offset.applyQuaternion(quatInverse);\n\n        position.copy(this.target).add(offset);\n\n        this.object.lookAt(this.target);\n\n        if (this.enableDamping === true) {\n          sphericalDelta.theta *= (1 - this.dampingFactor);\n          sphericalDelta.phi *= (1 - this.dampingFactor);\n        } else\n          sphericalDelta.set(0, 0, 0);\n\n        scale = 1;\n        panOffset.set(0, 0, 0);\n\n        // update condition is:\n        // min(camera displacement, camera rotation in radians)^2 > EPS\n        // using small-angle approximation cos(x/2) = 1 - x^2 / 8\n\n        if (zoomChanged\n          || lastPosition.distanceToSquared(this.object.position) > EPS\n          || 8 * (1 - lastQuaternion.dot(this.object.quaternion)) > EPS) {\n          this.dispatchEvent(changeEvent);\n\n          lastPosition.copy(this.object.position);\n          lastQuaternion.copy(this.object.quaternion);\n          zoomChanged = false;\n\n          return true;\n        }\n\n        return false;\n      })();\n    };\n\n    this.dispose = () => {\n      this.domElement.removeEventListener('contextmenu', onContextMenu, false);\n      this.domElement.removeEventListener('mousedown', onMouseDown, false);\n      this.domElement.removeEventListener('wheel', onMouseWheel, false);\n\n      this.domElement.removeEventListener('touchstart', onTouchStart, false);\n      this.domElement.removeEventListener('touchend', onTouchEnd, false);\n      this.domElement.removeEventListener('touchmove', onTouchMove, false);\n\n      document.removeEventListener('mousemove', onMouseMove, false);\n      document.removeEventListener('mouseup', onMouseUp, false);\n\n      window.removeEventListener('keydown', onKeyDown, false);\n\n      // this.dispatchEvent( { type: 'dispose' } ); // should this be added here?\n    };\n\n    //\n    // internals\n    //\n\n    const changeEvent = {type: 'change'};\n    const startEvent = {type: 'start'};\n    const endEvent = {type: 'end'};\n\n    const STATE = {NONE: -1, ROTATE: 0, DOLLY: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_DOLLY: 4, TOUCH_PAN: 5};\n\n    let state = STATE.NONE;\n\n    const EPS = 0.000001;\n\n    // current position in spherical coordinates\n    const spherical = new Spherical();\n    const sphericalDelta = new Spherical();\n\n    let scale = 1;\n    const panOffset = new Vector3();\n    let zoomChanged = false;\n\n    const rotateStart = new Vector2();\n    const rotateEnd = new Vector2();\n    const rotateDelta = new Vector2();\n\n    const panStart = new Vector2();\n    const panEnd = new Vector2();\n    const panDelta = new Vector2();\n\n    const dollyStart = new Vector2();\n    const dollyEnd = new Vector2();\n    const dollyDelta = new Vector2();\n\n    const getAutoRotationAngle = () => {\n      return 2 * Math.PI / 60 / 60 * this.autoRotateSpeed;\n    };\n\n    const getZoomScale = () => {\n      return Math.pow(0.95, this.zoomSpeed);\n    };\n\n    const rotateLeft = angle => {\n      sphericalDelta.theta -= angle;\n    };\n\n    const rotateUp = angle => {\n      sphericalDelta.phi -= angle;\n    };\n\n    const panLeft = (() => {\n      const v = new Vector3();\n\n      return (distance, objectMatrix) => {\n        v.setFromMatrixColumn(objectMatrix, 0); // get X column of objectMatrix\n        v.multiplyScalar(-distance);\n        panOffset.add(v);\n      };\n    })();\n\n    const panUp = (() => {\n      const v = new Vector3();\n\n      return (distance, objectMatrix) => {\n        v.setFromMatrixColumn(objectMatrix, 1); // get Y column of objectMatrix\n        v.multiplyScalar(distance);\n        panOffset.add(v);\n      };\n    })();\n\n    // deltaX and deltaY are in pixels; right and down are positive\n    const pan = (() => {\n      const offset = new Vector3();\n\n      return (deltaX, deltaY) => {\n        const element = this.domElement === document ? this.domElement.body : this.domElement;\n\n        if (this.object instanceof PerspectiveCamera) {\n          // perspective\n          const position = this.object.position;\n          offset.copy(position).sub(this.target);\n          let targetDistance = offset.length();\n\n          // half of the fov is center to top of screen\n          targetDistance *= Math.tan((this.object.fov / 2) * Math.PI / 180.0);\n\n          // we actually don't use screenWidth, since perspective camera is fixed to screen height\n          panLeft(2 * deltaX * targetDistance / element.clientHeight, this.object.matrix);\n          panUp(2 * deltaY * targetDistance / element.clientHeight, this.object.matrix);\n        } else if (this.object instanceof OrthographicCamera) {\n          // orthographic\n          panLeft(deltaX * (this.object.right - this.object.left) / this.object.zoom / element.clientWidth, this.object.matrix);\n          panUp(deltaY * (this.object.top - this.object.bottom) / this.object.zoom / element.clientHeight, this.object.matrix);\n        } else {\n          // camera neither orthographic nor perspective\n          console.warn('WARNING: OrbitControlsModule.js encountered an unknown camera type - pan disabled.');\n          this.enablePan = false;\n        }\n      };\n    })();\n\n    const dollyIn = dollyScale => {\n      if (this.object instanceof PerspectiveCamera)\n        scale /= dollyScale;\n\n      else if (this.object instanceof OrthographicCamera) {\n        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom * dollyScale));\n        this.object.updateProjectionMatrix();\n        zoomChanged = true;\n      } else {\n        console.warn('WARNING: OrbitControlsModule.js encountered an unknown camera type - dolly/zoom disabled.');\n        this.enableZoom = false;\n      }\n    };\n\n    const dollyOut = dollyScale => {\n      if (this.object instanceof PerspectiveCamera)\n        scale *= dollyScale;\n\n      else if (this.object instanceof OrthographicCamera) {\n        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / dollyScale));\n        this.object.updateProjectionMatrix();\n        zoomChanged = true;\n      } else {\n        console.warn('WARNING: OrbitControlsModule.js encountered an unknown camera type - dolly/zoom disabled.');\n        this.enableZoom = false;\n      }\n    };\n\n    //\n    // event callbacks - update the object state\n    //\n\n    const handleMouseDownRotate = event => {\n      // console.log( 'handleMouseDownRotate' );\n\n      rotateStart.set(event.clientX, event.clientY);\n    };\n\n    const handleMouseDownDolly = event => {\n      // console.log( 'handleMouseDownDolly' );\n\n      dollyStart.set(event.clientX, event.clientY);\n    };\n\n    const handleMouseDownPan = event => {\n      // console.log( 'handleMouseDownPan' );\n\n      panStart.set(event.clientX, event.clientY);\n    };\n\n    const handleMouseMoveRotate = event => {\n      // console.log( 'handleMouseMoveRotate' );\n\n      rotateEnd.set(event.clientX, event.clientY);\n      rotateDelta.subVectors(rotateEnd, rotateStart);\n\n      const element = this.domElement === document ? this.domElement.body : this.domElement;\n\n      // rotating across whole screen goes 360 degrees around\n      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientWidth * this.rotateSpeed);\n\n      // rotating up and down along whole screen attempts to go 360, but limited to 180\n      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight * this.rotateSpeed);\n\n      rotateStart.copy(rotateEnd);\n\n      this.update();\n    };\n\n    const handleMouseMoveDolly = event => {\n      // console.log( 'handleMouseMoveDolly' );\n\n      dollyEnd.set(event.clientX, event.clientY);\n\n      dollyDelta.subVectors(dollyEnd, dollyStart);\n\n      if (dollyDelta.y > 0)\n        dollyIn(getZoomScale());\n\n      else if (dollyDelta.y < 0)\n        dollyOut(getZoomScale());\n\n      dollyStart.copy(dollyEnd);\n\n      this.update();\n    };\n\n    const handleMouseMovePan = event => {\n      // console.log( 'handleMouseMovePan' );\n\n      panEnd.set(event.clientX, event.clientY);\n\n      panDelta.subVectors(panEnd, panStart);\n\n      pan(panDelta.x, panDelta.y);\n\n      panStart.copy(panEnd);\n\n      this.update();\n    };\n\n    const handleMouseUp = event => {\n      // console.log( 'handleMouseUp' );\n    };\n\n    const handleMouseWheel = event => {\n      // console.log( 'handleMouseWheel' );\n\n      if (event.deltaY < 0)\n        dollyOut(getZoomScale());\n\n      else if (event.deltaY > 0)\n        dollyIn(getZoomScale());\n\n      this.update();\n    };\n\n    const handleKeyDown = event => {\n      // console.log( 'handleKeyDown' );\n\n      switch (event.keyCode) {\n        case this.keys.UP:\n          pan(0, this.keyPanSpeed);\n          this.update();\n          break;\n\n        case this.keys.BOTTOM:\n          pan(0, -this.keyPanSpeed);\n          this.update();\n          break;\n\n        case this.keys.LEFT:\n          pan(this.keyPanSpeed, 0);\n          this.update();\n          break;\n\n        case this.keys.RIGHT:\n          pan(-this.keyPanSpeed, 0);\n          this.update();\n          break;\n\n      }\n    };\n\n    const handleTouchStartRotate = event => {\n      // console.log( 'handleTouchStartRotate' );\n\n      rotateStart.set(event.touches[0].pageX, event.touches[0].pageY);\n    };\n\n    const handleTouchStartDolly = event => {\n      // console.log( 'handleTouchStartDolly' );\n\n      const dx = event.touches[0].pageX - event.touches[1].pageX;\n      const dy = event.touches[0].pageY - event.touches[1].pageY;\n\n      const distance = Math.sqrt(dx * dx + dy * dy);\n\n      dollyStart.set(0, distance);\n    };\n\n    const handleTouchStartPan = event => {\n      // console.log( 'handleTouchStartPan' );\n\n      panStart.set(event.touches[0].pageX, event.touches[0].pageY);\n    };\n\n    const handleTouchMoveRotate = event => {\n      // console.log( 'handleTouchMoveRotate' );\n\n      rotateEnd.set(event.touches[0].pageX, event.touches[0].pageY);\n      rotateDelta.subVectors(rotateEnd, rotateStart);\n\n      const element = this.domElement === document ? this.domElement.body : this.domElement;\n\n      // rotating across whole screen goes 360 degrees around\n      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientWidth * this.rotateSpeed);\n\n      // rotating up and down along whole screen attempts to go 360, but limited to 180\n      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight * this.rotateSpeed);\n\n      rotateStart.copy(rotateEnd);\n\n      this.update();\n    };\n\n    const handleTouchMoveDolly = event => {\n      // console.log( 'handleTouchMoveDolly' );\n\n      const dx = event.touches[0].pageX - event.touches[1].pageX;\n      const dy = event.touches[0].pageY - event.touches[1].pageY;\n\n      const distance = Math.sqrt(dx * dx + dy * dy);\n\n      dollyEnd.set(0, distance);\n\n      dollyDelta.subVectors(dollyEnd, dollyStart);\n\n      if (dollyDelta.y > 0)\n        dollyOut(getZoomScale());\n\n      else if (dollyDelta.y < 0)\n        dollyIn(getZoomScale());\n\n      dollyStart.copy(dollyEnd);\n\n      this.update();\n    };\n\n    const handleTouchMovePan = event => {\n      // console.log( 'handleTouchMovePan' );\n\n      panEnd.set(event.touches[0].pageX, event.touches[0].pageY);\n\n      panDelta.subVectors(panEnd, panStart);\n\n      pan(panDelta.x, panDelta.y);\n\n      panStart.copy(panEnd);\n\n      this.update();\n    };\n\n    const handleTouchEnd = () => {\n      // console.log( 'handleTouchEnd' );\n    };\n\n    //\n    // event handlers - FSM: listen for events and reset state\n    //\n\n    const onMouseDown = event => {\n      if (this.enabled === false) return;\n\n      event.preventDefault();\n\n      if (event.button === this.mouseButtons.ORBIT) {\n        if (this.enableRotate === false) return;\n\n        handleMouseDownRotate(event);\n\n        state = STATE.ROTATE;\n      } else if (event.button === this.mouseButtons.ZOOM) {\n        if (this.enableZoom === false) return;\n\n        handleMouseDownDolly(event);\n\n        state = STATE.DOLLY;\n      } else if (event.button === this.mouseButtons.PAN) {\n        if (this.enablePan === false) return;\n\n        handleMouseDownPan(event);\n\n        state = STATE.PAN;\n      }\n\n      if (state !== STATE.NONE) {\n        this.eventHandler.on('mousemove', onMouseMove, false);\n        this.eventHandler.on('mouseup', onMouseUp, false);\n\n        this.dispatchEvent(startEvent);\n      }\n    };\n\n    const onMouseMove = event => {\n      if (this.enabled === false) return;\n\n      event.preventDefault();\n\n      if (state === STATE.ROTATE) {\n        if (this.enableRotate === false) return;\n\n        handleMouseMoveRotate(event);\n      } else if (state === STATE.DOLLY) {\n        if (this.enableZoom === false) return;\n\n        handleMouseMoveDolly(event);\n      } else if (state === STATE.PAN) {\n        if (this.enablePan === false) return;\n\n        handleMouseMovePan(event);\n      }\n    };\n\n    const onMouseUp = event => {\n      if (this.enabled === false) return;\n\n      handleMouseUp(event);\n\n      document.removeEventListener('mousemove', onMouseMove, false);\n      document.removeEventListener('mouseup', onMouseUp, false);\n\n      this.dispatchEvent(endEvent);\n\n      state = STATE.NONE;\n    };\n\n    const onMouseWheel = event => {\n      if (this.enabled === false || this.enableZoom === false || (state !== STATE.NONE && state !== STATE.ROTATE)) return;\n\n      event.preventDefault();\n      event.stopPropagation();\n\n      handleMouseWheel(event);\n\n      this.dispatchEvent(startEvent); // not sure why these are here...\n      this.dispatchEvent(endEvent);\n    };\n\n    const onKeyDown = event => {\n      if (this.enabled === false || this.enableKeys === false || this.enablePan === false) return;\n\n      handleKeyDown(event);\n    };\n\n    const onTouchStart = event => {\n      if (this.enabled === false) return;\n\n      switch (event.touches.length) {\n        case 1: // one-fingered touch: rotate\n\n          if (this.enableRotate === false) return;\n\n          handleTouchStartRotate(event);\n\n          state = STATE.TOUCH_ROTATE;\n\n          break;\n\n        case 2: // two-fingered touch: dolly\n\n          if (this.enableZoom === false) return;\n\n          handleTouchStartDolly(event);\n\n          state = STATE.TOUCH_DOLLY;\n\n          break;\n\n        case 3: // three-fingered touch: pan\n\n          if (this.enablePan === false) return;\n\n          handleTouchStartPan(event);\n\n          state = STATE.TOUCH_PAN;\n\n          break;\n\n        default:\n\n          state = STATE.NONE;\n\n      }\n\n      if (state !== STATE.NONE)\n        this.dispatchEvent(startEvent);\n    };\n\n    const onTouchMove = event => {\n      if (this.enabled === false) return;\n\n      event.preventDefault();\n      event.stopPropagation();\n\n      switch (event.touches.length) {\n        case 1: // one-fingered touch: rotate\n\n          if (this.enableRotate === false) return;\n          if (state !== STATE.TOUCH_ROTATE) return; // is this needed?...\n\n          handleTouchMoveRotate(event);\n\n          break;\n\n        case 2: // two-fingered touch: dolly\n\n          if (this.enableZoom === false) return;\n          if (state !== STATE.TOUCH_DOLLY) return; // is this needed?...\n\n          handleTouchMoveDolly(event);\n\n          break;\n\n        case 3: // three-fingered touch: pan\n\n          if (this.enablePan === false) return;\n          if (state !== STATE.TOUCH_PAN) return; // is this needed?...\n\n          handleTouchMovePan(event);\n\n          break;\n\n        default:\n\n          state = STATE.NONE;\n\n      }\n    };\n\n    const onTouchEnd = event => {\n      if (this.enabled === false) return;\n\n      handleTouchEnd(event);\n\n      this.dispatchEvent(endEvent);\n\n      state = STATE.NONE;\n    };\n\n    const onContextMenu = event => {\n      event.preventDefault();\n    };\n\n    //\n\n    this.eventHandler.on('contextmenu', onContextMenu, false);\n\n    this.eventHandler.on('mousedown', onMouseDown, false);\n    this.eventHandler.on('wheel', onMouseWheel, false);\n\n    this.eventHandler.on('touchstart', onTouchStart, false);\n    this.eventHandler.on('touchend', onTouchEnd, false);\n    this.eventHandler.on('touchmove', onTouchMove, false);\n\n    this.eventHandler.on('keydown', onKeyDown, false);\n\n    // force an update at start\n\n    this.update();\n  }\n\n  get center() {\n    console.warn('OrbitControls: .center has been renamed to .target');\n    return this.target;\n  }\n\n  get noZoom() {\n    console.warn('OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.');\n    return !this.enableZoom;\n  }\n\n  set noZoom(value) {\n    console.warn('OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.');\n    this.enableZoom = !value;\n  }\n\n  get noRotate() {\n    console.warn('OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.');\n    return !this.enableRotate;\n  }\n\n  set noRotate(value) {\n    console.warn('OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.');\n    this.enableRotate = !value;\n  }\n\n  get noPan() {\n    console.warn('OrbitControls: .noPan has been deprecated. Use .enablePan instead.');\n    return !this.enablePan;\n  }\n\n  set noPan(value) {\n    console.warn('OrbitControls: .noPan has been deprecated. Use .enablePan instead.');\n    this.enablePan = !value;\n  }\n\n  get noKeys() {\n    console.warn('OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.');\n    return !this.enableKeys;\n  }\n\n  set noKeys(value) {\n    console.warn('OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.');\n    this.enableKeys = !value;\n  }\n\n  get staticMoving() {\n    console.warn('OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.');\n    return !this.enableDamping;\n  }\n\n  set staticMoving(value) {\n    console.warn('OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.');\n    this.enableDamping = !value;\n  }\n\n  get dynamicDampingFactor() {\n    console.warn('OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.');\n    return this.dampingFactor;\n  }\n\n  set dynamicDampingFactor(value) {\n    console.warn('OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.');\n    this.dampingFactor = value;\n  }\n}\n","import {Vector3} from 'three';\nimport {ControlsModule} from '../ControlsModule';\n\nimport {ThreeOrbitControls} from './lib/ThreeOrbitControls';\n\nexport class OrbitControlsModule extends ControlsModule {\n  constructor(params = {}) {\n    super(params);\n\n    this.params = Object.assign({\n      follow: false,\n      object: null,\n      target: new Vector3(0, 0, 0)\n    }, params);\n  }\n\n  manager(manager) {\n    super.manager(manager);\n\n    const {object: obj, follow, target} = this.params;\n    const object = obj ? obj.native : manager.get('camera').native;\n\n    const controls = new ThreeOrbitControls(\n      object,\n      manager.get('element'),\n      manager.handler\n    );\n\n    const updateProcessor = follow ? c => {\n      controls.update(c.getDelta());\n      controls.target.copy(target);\n    } : c => {\n      controls.update(c.getDelta());\n    };\n\n    this.setControls(controls);\n    this.setUpdate(updateProcessor);\n\n    manager.update({\n      camera: camera => {\n        if (obj) return;\n        controls.object = camera.native;\n      }\n    });\n\n    controls.target.copy(target);\n  }\n}\n","/** @module modules/app/controls */\nexport * from './OrbitControlsModule';\n","/** @module modules/app */\nexport * from './ElementModule';\nexport * from './RenderingModule';\nexport * from './SceneModule';\nexport * from './ResizeModule';\nexport * from './PostProcessorModule';\nexport * from './VirtualMouseModule';\nexport * from './EventsPatchModule';\nexport * from './ControlsModule';\nexport * from './FogModule';\nexport * from './StateModule';\n\n// controls\nexport * from './controls/index';\n","/**\n * @class DynamicGeometryModule\n * @category modules/mesh\n * @param {Object} [params={attributes: false}] - params\n * @param {Boolean} [patchEvents=true]\n * @memberof module:modules/mesh\n */\nexport class DynamicGeometryModule {\n  constructor(params = {}) {\n    this.params = Object.assign({\n      attributes: false\n    }, params);\n  }\n\n  integrate(self) {\n    const params = self.params;\n\n    this.g_ = function (params = {}) {\n      if (this.buildGeometry) {\n        this.native.geometry = this.buildGeometry(\n          this.updateParams({geometry: params})\n        );\n      }\n    };\n\n    if (params.attributes) {\n      for (const key in this.params.geometry) {\n        if (key) {\n          Object.defineProperty(this, `g_${key}`, {\n            get() {\n              return this.native.geometry.parameters[key];\n            },\n            set(value) {\n              this.native.geometry = this.buildGeometry(this.updateParams({geometry: {[key]: value}}));\n            },\n            configurable: true,\n            enumerable: true\n          });\n        }\n      }\n    }\n  }\n}\n","import {\n  RepeatWrapping,\n  UVMapping,\n  NearestFilter,\n  LinearMipMapLinearFilter,\n  TextureLoader,\n  Vector2\n} from 'three';\n\nconst loader = new TextureLoader();\n\n/**\n * @class TextureModule\n * @category modules/mesh\n * @description A TextureModule can be applied to any Mesh or Model.\n * @param {Array} [textures] - array of texture objects\n * @memberof module:modules/mesh\n * @example <caption>Creating an instance. url takes a path, or a data object.</caption>\n * var woodTexture = new TextureModule({\n *   url: `${process.assetsPath}/textures/wood.jpg`\n * });\n * @example <caption>More comprehensive example, wood texture applied to a Box.</caption>\n * new Box({\n *   geometry: {\n *     width: 2,\n *     height: 2,\n *     depth: 2\n *   },\n *   modules: [\n *     new TextureModule({\n *       url: `path/to/texture.jpg`,\n *       repeat: new THREE.Vector2(1, 1) // optional\n *     })\n *   ],\n *   material: new THREE.MeshBasicMaterial({\n *     color: 0xffffff\n *   }),\n *   position: [50, 60, 70]\n * }).addTo(app);\n */\nexport class TextureModule {\n  static load(url) {\n    return new TextureModule({url}).textures[0][1];\n  }\n\n  textures = [];\n\n  constructor(...textures) {\n    textures.forEach(({\n      url,\n      type = 'map',\n      offset = new Vector2(0, 0),\n      repeat = new Vector2(1, 1),\n      wrap = RepeatWrapping,\n      mapping = UVMapping,\n      fix = tex => tex\n    }) => {\n      const texture = loader.load(url);\n\n      if (wrap.length > 0) {\n        texture.wrapS = wrap[0];\n        texture.wrapT = wrap[1];\n      } else\n        texture.wrapS = texture.wrapT = wrap;\n\n      texture.mapping = mapping;\n\n      texture.offset.copy(offset);\n      texture.repeat.copy(repeat);\n\n      texture.magFilter = NearestFilter;\n      texture.minFilter = LinearMipMapLinearFilter;\n\n      this.textures.push([type, fix(texture)]);\n    });\n  }\n\n  bridge = {\n    material(material, self) {\n      self.textures.forEach(texture => {\n        material[texture[0]] = texture[1];\n      });\n\n      return material;\n    }\n  }\n}\n","import {\n  AnimationMixer,\n  AnimationClip,\n  Clock\n} from 'three';\n\nimport {Loop} from '../../core/Loop';\n\n/**\n * @class AnimationModule\n * @category modules/mesh\n * @description Convenience module that wraps the <a href='https://threejs.org/docs/#manual/introduction/Animation-system'>three.js animation system</a>\n * @param {App} app - the app\n * @param {Boolean} [isDeferred=false] - set to true if animation should not start automatically\n * @param {Object} [params={speed: 1}] - the params\n * @memberof module:modules/mesh\n * @example <caption>Create animation module and play a given clip of an imported model</caption>\n * const animationModule = new AnimationModule(app, false, {\n *   speed: 1.2 // speed up animation by 20%\n * });\n *\n * new Importer({\n *   parser(geometry, materials) {\n *     // Override parse to generate a skinnedMesh, needed for skinned models\n *     return new THREE.SkinnedMesh(geometry, materials);\n *   },\n *\n *   url: `path/to/model.json`,\n *   useCustomMaterial: true,\n *\n *   material: new THREE.MeshStandardMaterial({\n *     skinning: true\n *   }),\n *\n *   modules: [animationModule]\n * }).addTo(app).then(() => {\n *   // adding model to app returns a promise, so pipe the function to kick off the animation clip\n *   animationModule.play('clipName');\n * });\n */\nexport class AnimationModule {\n  constructor(app, isDeferred, params = {}) {\n    this.params = Object.assign({\n      speed: 1\n    }, params);\n    this.clock = new Clock();\n\n    this.app = app;\n    this.isDeferred = isDeferred;\n  }\n\n  /**\n   * @method play\n   * @instance\n   * @description Plays the given clip name\n   * @param {String} clipName - the clip to play\n   * @memberof module:modules/mesh.AnimationModule\n   */\n  play(clipName) {\n    const clip = AnimationClip.findByName(this.clips, clipName);\n    const action = this.mixer.clipAction(clip);\n\n    action.play();\n  }\n\n  /**\n   * @method update\n   * @instance\n   * @description Update the mixer (being called on frame animation loop)\n   * @memberof module:modules/mesh.AnimationModule\n   */\n  update() {\n    if (this.mixer) this.mixer.update(this.clock.getDelta() * this.params.speed);\n  }\n\n  integrate(self) {\n    self.loop = new Loop(() => {\n      self.update();\n    });\n\n    if (!self.isDeferred) self.loop.start(self.app);\n  }\n\n  manager(manager) {\n    manager.define('animation');\n  }\n\n  bridge = {\n    mesh(mesh, self) {\n      mesh.geometry.skeleton = mesh.skeleton;\n\n      self.mixer = new AnimationMixer(mesh.geometry);\n      self.clips = mesh.geometry.animations;\n\n      return mesh;\n    }\n  }\n}\n","/** @module modules/mesh */\nexport * from './DynamicGeometryModule';\nexport * from './TextureModule';\nexport * from './AnimationModule';\n","/**\n * @class DefineModule\n * @category modules\n * @param {String} name\n * @param {Object} data\n * @memberof module:modules\n * @example <caption> Creating a DefineModule with PerspectiveCamera as camera module and passing it to App's modules</caption>\n * new App([\n *   // ...\n *   new DefineModule('camera', new PerspectiveCamera())\n * ]);\n */\nexport class DefineModule {\n  constructor(name, data) {\n    this.name = name;\n    this.data = data;\n  }\n\n  manager(manager) {\n    manager.set(this.name, this.data);\n  }\n}\n","/** @module modules */\n\nexport * from './app/index';\nexport * from './mesh/index';\n\n// modules\nexport * from './DefineModule';\n","import {Importer} from './components/meshes/Importer';\nimport {PerspectiveCamera} from './components/cameras/PerspectiveCamera';\n\nexport class Model extends Importer {\n  constructor(params, ...additional) {\n    console.warn('Model is deprecated. Use Importer instead.');\n\n    if (params.geometry) {\n      params.url = params.geometry.path;\n      params.loader = params.geometry.loader;\n    }\n\n    super(params, ...additional);\n  }\n}\n\nexport class CameraModule {\n  constructor(params = {}) {\n    console.warn('CameraModule is deprecated. Use DefineModule instead.');\n    this.camera = new PerspectiveCamera(params);\n  }\n\n  integrate(self) {\n    this.add(self.camera);\n  }\n\n  manager(manager) {\n    manager.set('camera', this.camera);\n  }\n}\n","/**\n * Namespace containing all classes from all modules. Used as global in UMD pattern.\n * @namespace WHS\n * @example <caption>The use of WHS namespace.</caption>\n * new WHS.App() // core\n * new WHS.PerspectiveCamera() // components\n * new WHS.ResizeModule() // modules\n * WHS.extend() // utils\n */\n\n\nexport * from './core/index';\nexport * from './components/lights/index';\nexport * from './components/cameras/index';\nexport * from './components/meshes/index';\nexport * from './utils/index';\nexport * from './modules/index';\n\n// DEPRECATION\nexport * from './deprecation';\n"],"names":["extend","object","extensions","extension","Object","getOwnPropertyNames","prop","undefined","toString","constructor","Array","isArray","slice","instruct","array","instArray","tempObject","i","max","length","guide","transformData","instructions","key","toArray","instruction","tempArray","CompositionError","classInstance","message","component","stackArray","stack","split","splice","join","console","error","name","Error","DependencyError","activeModule","dependencyModule","ManagerError","warnDeps","REVISION","err","ModuleSystem","source","modules","applyModule","applyBridge","onCopy","bridgeMap","module","bridge","apply","cb","func","moduleScope","push","manager","active","integrate","bind","disposeModule","indexOf","dispose","Events","Symbol","objectProto","hasOwnProperty","symToStringTag","nativeObjectToString","root","ponyfill","$$observable","ModuleManager","handler","currentModule","store","createStore","state","action","data","dispatch","getState","Boolean","depsMap","subscribe","changedKey","callback","warn","set","moduleExecutor","use","Component","params","defaults","_wait","children","integrateModules","promise","Promise","all","isDeffered","wait","then","copy","customize","native","clone","parent","resolve","reject","defer","addPromise","onAdd","resolver","add","remove","_manager","_native","mesh","attributes","mappers","target","mapper","k","map","attribute","defineProperty","prototype","getter","setter","configurable","enumerable","value","mirror","MeshComponent","geom","Mesh","material","geometry","custom","build","wrap","applyCommand","position","rotation","scale","shadow","x","y","z","castShadow","cast","receiveShadow","receive","onWrap","quaternion","dest","LightComponent","mapSize","width","height","bias","radius","shadowCamera","camera","near","far","fov","left","right","top","bottom","CameraComponent","system","window","global","performance","present","App","log","version","simulate","updateEnabled","loops","requestAnimFrame","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","setTimeout","process","ll","e","enabled","execute","clock","loop","index","get","Loop","useClock","Clock","world","addLoop","start","stop","removeLoop","AmbientLight","light","AmbientLightNative","color","intensity","DirectionalLight","wrapShadow","DirectionalLightNative","HemisphereLight","HemisphereLightNative","skyColor","groundColor","PointLight","PointLightNative","distance","decay","SpotLight","SpotLightNative","angle","exponent","Math","PI","AreaLight","RectAreaLightNative","CubeCamera","CubeCameraNative","cubeResolution","OrthographicCamera","OrthographicCameraNative","innerWidth","innerHeight","PerspectiveCamera","PerspectiveCameraNative","aspect","Box","buildGeometry","buffer","BoxBufferGeometry","BoxGeometry","depth","widthSegments","heightSegments","depthSegments","Circle","CircleBufferGeometry","CircleGeometry","segments","thetaStart","thetaLength","Cone","ConeBufferGeometry","ConeGeometry","radiusSegments","openEnded","Cylinder","CylinderBufferGeometry","CylinderGeometry","radiusTop","radiusBottom","Dodecahedron","DodecahedronBufferGeometry","DodecahedronGeometry","detail","Extrude","ExtrudeGeometry","shapes","options","BufferGeometry","fromGeometry","Icosahedron","IcosahedronBufferGeometry","IcosahedronGeometry","Lathe","LatheBufferGeometry","LatheGeometry","points","Line","LineNative","Geometry","pp","curve","getPoints","verts","Float32Array","i3","addAttribute","BufferAttribute","vertices","LineCurve3","Vector3","Importer","filter","processFilter","forEach","el","texturePath","laoder","setTexturePath","loader","load","url","onLoad","parser","useCustomMaterial","mat","onProgress","onError","JSONLoader","materials","Octahedron","OctahedronBufferGeometry","OctahedronGeometry","Parametric","ParametricBufferGeometry","ParametricGeometry","slices","stacks","u","v","Plane","PlaneBufferGeometry","PlaneGeometry","wSegments","hSegments","verticesOfCube","indicesOfFaces","Polyhedron","PolyhedronBufferGeometry","PolyhedronGeometry","Ring","RingBufferGeometry","RingGeometry","innerRadius","outerRadius","thetaSegments","phiSegments","Shape","ShapeBufferGeometry","ShapeGeometry","Sphere","SphereBufferGeometry","SphereGeometry","Tetrahedron","TetrahedronBufferGeometry","TetrahedronGeometry","Text","parameters","font","TextGeometry","text","FontLoader","Font","Torus","TorusGeometry","tube","radialSegments","tubularSegments","arc","Torusknot","GConstruct","TorusKnotBufferGeometry","TorusKnotGeometry","p","q","Tube","TubeBufferGeometry","TubeGeometry","path","closed","Group","objects","obj","addTo","Object3D","ElementModule","container","document","body","createElement","element","className","style","self","appendChild","RenderingModule","isShadow","assign","Vector2","devicePixelRatio","bgColor","bgOpacity","renderer","pixelRatio","resolution","WebGLRenderer","effects","applyAdditional","setClearColor","setPixelRatio","setSize","Number","toFixed","isApplied","additional","scene","renderLoop","render","attachToCanvas","effect","size","getSize","app","canvas","domElement","define","integrateRenderer","update","forceContextLoss","shadowMap","SceneModule","willSceneBeReplaced","Scene","setScene","ResizeModule","callbacks","updateProjectionMatrix","rendering","offsetWidth","offsetHeight","getContainer","getResolution","auto","addEventListener","trigger","addAutoresize","fragment","vertex","polyfill","method","showWarn","PostProcessorModule","debug","currentPass","composer","EffectComposer","getDelta","replaceRenderer","pass","RenderPass","addPass","textureID","uniforms","ShaderPass","passes","bool","renderToScreen","EventsPatchModule","originObject","destObject","events","event","emit","patchEvents","VirtualMouseModule","globalMovement","mouse","raycaster","Raycaster","projectionPlane","customX","customY","rect","getBoundingClientRect","clientX","clientY","normal","getWorldDirection","setFromCamera","require","on","ev","globalX","globalY","pointerLockElement","movementX","movementY","nested","isHovered","hovers","traverse","child","intersectObjects","intersectObject","plane","ray","intersectPlane","intersection","ControlsModule","controls","c","updateLoop","FogModule","type","fog","FogExp2","density","Fog","isEqualDefault","a","b","equals","StateModule","isEqual","equalCheck","actionGenerate","configuration","currentConfig","prevConfig","config","default","replaceReducer","configs","updates","configName","trueVal","falseVal","ThreeOrbitControls","eventHandler","minDistance","maxDistance","Infinity","minZoom","maxZoom","minPolarAngle","maxPolarAngle","minAzimuthAngle","maxAzimuthAngle","enableDamping","dampingFactor","enableZoom","zoomSpeed","enableRotate","rotateSpeed","enablePan","keyPanSpeed","autoRotate","autoRotateSpeed","enableKeys","keys","LEFT","UP","RIGHT","BOTTOM","mouseButtons","ORBIT","MOUSE","ZOOM","MIDDLE","PAN","target0","position0","zoom0","zoom","getPolarAngle","spherical","phi","getAzimuthalAngle","theta","reset","dispatchEvent","changeEvent","STATE","NONE","offset","quat","Quaternion","setFromUnitVectors","up","quatInverse","inverse","lastPosition","lastQuaternion","sub","applyQuaternion","setFromVector3","rotateLeft","getAutoRotationAngle","sphericalDelta","min","makeSafe","panOffset","setFromSpherical","lookAt","zoomChanged","distanceToSquared","EPS","dot","removeEventListener","onContextMenu","onMouseDown","onMouseWheel","onTouchStart","onTouchEnd","onTouchMove","onMouseMove","onMouseUp","onKeyDown","startEvent","endEvent","ROTATE","DOLLY","TOUCH_ROTATE","TOUCH_DOLLY","TOUCH_PAN","Spherical","rotateStart","rotateEnd","rotateDelta","panStart","panEnd","panDelta","dollyStart","dollyEnd","dollyDelta","getZoomScale","pow","rotateUp","panLeft","objectMatrix","setFromMatrixColumn","multiplyScalar","panUp","pan","deltaX","deltaY","targetDistance","tan","clientHeight","matrix","clientWidth","dollyIn","dollyScale","dollyOut","handleMouseDownRotate","handleMouseDownDolly","handleMouseDownPan","handleMouseMoveRotate","subVectors","handleMouseMoveDolly","handleMouseMovePan","handleMouseUp","handleMouseWheel","handleKeyDown","keyCode","handleTouchStartRotate","touches","pageX","pageY","handleTouchStartDolly","dx","dy","sqrt","handleTouchStartPan","handleTouchMoveRotate","handleTouchMoveDolly","handleTouchMovePan","handleTouchEnd","preventDefault","button","stopPropagation","EventDispatcher","OrbitControlsModule","follow","updateProcessor","setControls","setUpdate","DynamicGeometryModule","g_","updateParams","TextureLoader","TextureModule","textures","texture","repeat","RepeatWrapping","mapping","UVMapping","fix","tex","wrapS","wrapT","magFilter","NearestFilter","minFilter","LinearMipMapLinearFilter","AnimationModule","isDeferred","skeleton","mixer","AnimationMixer","clips","animations","clipName","clip","AnimationClip","findByName","clipAction","play","speed","DefineModule","Model","CameraModule"],"mappings":"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"}