oxygen-core/bin/index.js

Oxygen game engine (Xenon Core for browsers)

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.lazyInitialization = lazyInitialization;
Object.defineProperty(exports, "JSONAsset", {
  enumerable: true,
  get: function get() {
    return _JSONAsset.default;
  }
});
Object.defineProperty(exports, "TextAsset", {
  enumerable: true,
  get: function get() {
    return _TextAsset.default;
  }
});
Object.defineProperty(exports, "BinaryAsset", {
  enumerable: true,
  get: function get() {
    return _BinaryAsset.default;
  }
});
Object.defineProperty(exports, "ImageAsset", {
  enumerable: true,
  get: function get() {
    return _ImageAsset.default;
  }
});
Object.defineProperty(exports, "ShaderAsset", {
  enumerable: true,
  get: function get() {
    return _ShaderAsset.default;
  }
});
Object.defineProperty(exports, "SceneAsset", {
  enumerable: true,
  get: function get() {
    return _SceneAsset.default;
  }
});
Object.defineProperty(exports, "AtlasAsset", {
  enumerable: true,
  get: function get() {
    return _AtlasAsset.default;
  }
});
Object.defineProperty(exports, "FontAsset", {
  enumerable: true,
  get: function get() {
    return _FontAsset.default;
  }
});
Object.defineProperty(exports, "SoundAsset", {
  enumerable: true,
  get: function get() {
    return _SoundAsset.default;
  }
});
Object.defineProperty(exports, "MusicAsset", {
  enumerable: true,
  get: function get() {
    return _MusicAsset.default;
  }
});
Object.defineProperty(exports, "ParticleSystemAsset", {
  enumerable: true,
  get: function get() {
    return _ParticleSystemAsset.default;
  }
});
Object.defineProperty(exports, "PackAsset", {
  enumerable: true,
  get: function get() {
    return _PackAsset.default;
  }
});
Object.defineProperty(exports, "SkeletonAsset", {
  enumerable: true,
  get: function get() {
    return _SkeletonAsset.default;
  }
});
Object.defineProperty(exports, "SVGAsset", {
  enumerable: true,
  get: function get() {
    return _SVGAsset.default;
  }
});
Object.defineProperty(exports, "SetAsset", {
  enumerable: true,
  get: function get() {
    return _SetAsset.default;
  }
});
Object.defineProperty(exports, "AssemblyAsset", {
  enumerable: true,
  get: function get() {
    return _AssemblyAsset.default;
  }
});
Object.defineProperty(exports, "PostprocessRackEffectAsset", {
  enumerable: true,
  get: function get() {
    return _PostprocessRackEffectAsset.default;
  }
});
Object.defineProperty(exports, "Camera", {
  enumerable: true,
  get: function get() {
    return _Camera.default;
  }
});
Object.defineProperty(exports, "PostprocessPass", {
  enumerable: true,
  get: function get() {
    return _Camera.PostprocessPass;
  }
});
Object.defineProperty(exports, "Camera2D", {
  enumerable: true,
  get: function get() {
    return _Camera2D.default;
  }
});
Object.defineProperty(exports, "CameraDirector2D", {
  enumerable: true,
  get: function get() {
    return _CameraDirector2D.default;
  }
});
Object.defineProperty(exports, "InputHandler", {
  enumerable: true,
  get: function get() {
    return _InputHandler.default;
  }
});
Object.defineProperty(exports, "GestureListener", {
  enumerable: true,
  get: function get() {
    return _GestureListener.default;
  }
});
Object.defineProperty(exports, "Particles", {
  enumerable: true,
  get: function get() {
    return _Particles.default;
  }
});
Object.defineProperty(exports, "PhysicsBody", {
  enumerable: true,
  get: function get() {
    return _PhysicsBody.default;
  }
});
Object.defineProperty(exports, "PhysicsWorld", {
  enumerable: true,
  get: function get() {
    return _PhysicsWorld.default;
  }
});
Object.defineProperty(exports, "PrefabInstance", {
  enumerable: true,
  get: function get() {
    return _PrefabInstance.default;
  }
});
Object.defineProperty(exports, "RectangleRenderer", {
  enumerable: true,
  get: function get() {
    return _RectangleRenderer.default;
  }
});
Object.defineProperty(exports, "Script", {
  enumerable: true,
  get: function get() {
    return _Script.default;
  }
});
Object.defineProperty(exports, "Sprite", {
  enumerable: true,
  get: function get() {
    return _Sprite.default;
  }
});
Object.defineProperty(exports, "AtlasSprite", {
  enumerable: true,
  get: function get() {
    return _AtlasSprite.default;
  }
});
Object.defineProperty(exports, "TextRenderer", {
  enumerable: true,
  get: function get() {
    return _TextRenderer.default;
  }
});
Object.defineProperty(exports, "VerticesRenderer", {
  enumerable: true,
  get: function get() {
    return _VerticesRenderer.default;
  }
});
Object.defineProperty(exports, "UiSprite", {
  enumerable: true,
  get: function get() {
    return _UiSprite.default;
  }
});
Object.defineProperty(exports, "UiLayout", {
  enumerable: true,
  get: function get() {
    return _UiLayout.default;
  }
});
Object.defineProperty(exports, "Skeleton", {
  enumerable: true,
  get: function get() {
    return _Skeleton.default;
  }
});
Object.defineProperty(exports, "SortedActions", {
  enumerable: true,
  get: function get() {
    return _SortedActions.default;
  }
});
Object.defineProperty(exports, "DeferredRenderer", {
  enumerable: true,
  get: function get() {
    return _DeferredRenderer.default;
  }
});
Object.defineProperty(exports, "DeferredPipeline", {
  enumerable: true,
  get: function get() {
    return _DeferredRenderer.DeferredPipeline;
  }
});
Object.defineProperty(exports, "MultipassRenderer", {
  enumerable: true,
  get: function get() {
    return _MultipassRenderer.default;
  }
});
Object.defineProperty(exports, "MultipassPipeline", {
  enumerable: true,
  get: function get() {
    return _MultipassRenderer.MultipassPipeline;
  }
});
Object.defineProperty(exports, "PostprocessRack", {
  enumerable: true,
  get: function get() {
    return _PostprocessRack.default;
  }
});
Object.defineProperty(exports, "PostprocessRackPass", {
  enumerable: true,
  get: function get() {
    return _PostprocessRack.PostprocessRackPass;
  }
});
Object.defineProperty(exports, "PostprocessRackRawEffectPass", {
  enumerable: true,
  get: function get() {
    return _PostprocessRack.PostprocessRackRawEffectPass;
  }
});
Object.defineProperty(exports, "Shape", {
  enumerable: true,
  get: function get() {
    return _Shape.default;
  }
});
Object.defineProperty(exports, "PolygonShape", {
  enumerable: true,
  get: function get() {
    return _PolygonShape.default;
  }
});
Object.defineProperty(exports, "CircleShape", {
  enumerable: true,
  get: function get() {
    return _CircleShape.default;
  }
});
Object.defineProperty(exports, "RectangleShape", {
  enumerable: true,
  get: function get() {
    return _RectangleShape.default;
  }
});
Object.defineProperty(exports, "System", {
  enumerable: true,
  get: function get() {
    return _System.default;
  }
});
Object.defineProperty(exports, "EntitySystem", {
  enumerable: true,
  get: function get() {
    return _EntitySystem.default;
  }
});
Object.defineProperty(exports, "Component", {
  enumerable: true,
  get: function get() {
    return _Component.default;
  }
});
Object.defineProperty(exports, "Entity", {
  enumerable: true,
  get: function get() {
    return _Entity.default;
  }
});
Object.defineProperty(exports, "AssetSystem", {
  enumerable: true,
  get: function get() {
    return _AssetSystem.default;
  }
});
Object.defineProperty(exports, "Asset", {
  enumerable: true,
  get: function get() {
    return _Asset.default;
  }
});
Object.defineProperty(exports, "RenderSystem", {
  enumerable: true,
  get: function get() {
    return _RenderSystem.default;
  }
});
Object.defineProperty(exports, "RenderTargetWrapper", {
  enumerable: true,
  get: function get() {
    return _RenderSystem.RenderTargetWrapper;
  }
});
Object.defineProperty(exports, "Command", {
  enumerable: true,
  get: function get() {
    return _RenderSystem.Command;
  }
});
Object.defineProperty(exports, "Pipeline", {
  enumerable: true,
  get: function get() {
    return _RenderSystem.Pipeline;
  }
});
Object.defineProperty(exports, "RenderFullscreenCommand", {
  enumerable: true,
  get: function get() {
    return _RenderSystem.RenderFullscreenCommand;
  }
});
Object.defineProperty(exports, "InputSystem", {
  enumerable: true,
  get: function get() {
    return _InputSystem.default;
  }
});
Object.defineProperty(exports, "StorageSystem", {
  enumerable: true,
  get: function get() {
    return _StorageSystem.default;
  }
});
Object.defineProperty(exports, "AudioSystem", {
  enumerable: true,
  get: function get() {
    return _AudioSystem.default;
  }
});
Object.defineProperty(exports, "AssemblySystem", {
  enumerable: true,
  get: function get() {
    return _AssemblySystem.default;
  }
});
Object.defineProperty(exports, "Events", {
  enumerable: true,
  get: function get() {
    return _Events.default;
  }
});
Object.defineProperty(exports, "glMatrix", {
  enumerable: true,
  get: function get() {
    return _glMatrix.glMatrix;
  }
});
Object.defineProperty(exports, "mat2", {
  enumerable: true,
  get: function get() {
    return _glMatrix.mat2;
  }
});
Object.defineProperty(exports, "mat2d", {
  enumerable: true,
  get: function get() {
    return _glMatrix.mat2d;
  }
});
Object.defineProperty(exports, "mat3", {
  enumerable: true,
  get: function get() {
    return _glMatrix.mat3;
  }
});
Object.defineProperty(exports, "mat4", {
  enumerable: true,
  get: function get() {
    return _glMatrix.mat4;
  }
});
Object.defineProperty(exports, "quat", {
  enumerable: true,
  get: function get() {
    return _glMatrix.quat;
  }
});
Object.defineProperty(exports, "vec2", {
  enumerable: true,
  get: function get() {
    return _glMatrix.vec2;
  }
});
Object.defineProperty(exports, "vec3", {
  enumerable: true,
  get: function get() {
    return _glMatrix.vec3;
  }
});
Object.defineProperty(exports, "vec4", {
  enumerable: true,
  get: function get() {
    return _glMatrix.vec4;
  }
});
Object.defineProperty(exports, "box2d", {
  enumerable: true,
  get: function get() {
    return _utils.box2d;
  }
});
Object.defineProperty(exports, "Utils", {
  enumerable: true,
  get: function get() {
    return _utils.default;
  }
});
Object.defineProperty(exports, "AssetLoaders", {
  enumerable: true,
  get: function get() {
    return _assetLoaders.default;
  }
});
Object.defineProperty(exports, "Components", {
  enumerable: true,
  get: function get() {
    return _components.default;
  }
});
Object.defineProperty(exports, "Systems", {
  enumerable: true,
  get: function get() {
    return _systems.default;
  }
});
exports.EventsController = exports.default = void 0;

var _JSONAsset = _interopRequireDefault(require("./asset-loaders/JSONAsset"));

var _TextAsset = _interopRequireDefault(require("./asset-loaders/TextAsset"));

var _BinaryAsset = _interopRequireDefault(require("./asset-loaders/BinaryAsset"));

var _ImageAsset = _interopRequireDefault(require("./asset-loaders/ImageAsset"));

var _ShaderAsset = _interopRequireDefault(require("./asset-loaders/ShaderAsset"));

var _SceneAsset = _interopRequireDefault(require("./asset-loaders/SceneAsset"));

var _AtlasAsset = _interopRequireDefault(require("./asset-loaders/AtlasAsset"));

var _FontAsset = _interopRequireDefault(require("./asset-loaders/FontAsset"));

var _SoundAsset = _interopRequireDefault(require("./asset-loaders/SoundAsset"));

var _MusicAsset = _interopRequireDefault(require("./asset-loaders/MusicAsset"));

var _ParticleSystemAsset = _interopRequireDefault(require("./asset-loaders/ParticleSystemAsset"));

var _PackAsset = _interopRequireDefault(require("./asset-loaders/PackAsset"));

var _SkeletonAsset = _interopRequireDefault(require("./asset-loaders/SkeletonAsset"));

var _SVGAsset = _interopRequireDefault(require("./asset-loaders/SVGAsset"));

var _SetAsset = _interopRequireDefault(require("./asset-loaders/SetAsset"));

var _AssemblyAsset = _interopRequireDefault(require("./asset-loaders/AssemblyAsset"));

var _PostprocessRackEffectAsset = _interopRequireDefault(require("./asset-loaders/PostprocessRackEffectAsset"));

var _Camera = _interopRequireWildcard(require("./components/Camera"));

var _Camera2D = _interopRequireDefault(require("./components/Camera2D"));

var _CameraDirector2D = _interopRequireDefault(require("./components/CameraDirector2D"));

var _InputHandler = _interopRequireDefault(require("./components/InputHandler"));

var _GestureListener = _interopRequireDefault(require("./components/GestureListener"));

var _Particles = _interopRequireDefault(require("./components/Particles"));

var _PhysicsBody = _interopRequireDefault(require("./components/PhysicsBody"));

var _PhysicsWorld = _interopRequireDefault(require("./components/PhysicsWorld"));

var _PrefabInstance = _interopRequireDefault(require("./components/PrefabInstance"));

var _RectangleRenderer = _interopRequireDefault(require("./components/RectangleRenderer"));

var _Script = _interopRequireDefault(require("./components/Script"));

var _Sprite = _interopRequireDefault(require("./components/Sprite"));

var _AtlasSprite = _interopRequireDefault(require("./components/AtlasSprite"));

var _TextRenderer = _interopRequireDefault(require("./components/TextRenderer"));

var _VerticesRenderer = _interopRequireDefault(require("./components/VerticesRenderer"));

var _UiSprite = _interopRequireDefault(require("./components/UiSprite"));

var _UiLayout = _interopRequireDefault(require("./components/UiLayout"));

var _Skeleton = _interopRequireDefault(require("./components/Skeleton"));

var _SortedActions = _interopRequireDefault(require("./components/SortedActions"));

var _DeferredRenderer = _interopRequireWildcard(require("./components/DeferredRenderer"));

var _MultipassRenderer = _interopRequireWildcard(require("./components/MultipassRenderer"));

var _PostprocessRack = _interopRequireWildcard(require("./components/PostprocessRack"));

var _Shape = _interopRequireDefault(require("./components/Shape"));

var _PolygonShape = _interopRequireDefault(require("./components/PolygonShape"));

var _CircleShape = _interopRequireDefault(require("./components/CircleShape"));

var _RectangleShape = _interopRequireDefault(require("./components/RectangleShape"));

var _System = _interopRequireDefault(require("./systems/System"));

var _EntitySystem = _interopRequireDefault(require("./systems/EntitySystem"));

var _Component = _interopRequireDefault(require("./systems/EntitySystem/Component"));

var _Entity = _interopRequireDefault(require("./systems/EntitySystem/Entity"));

var _AssetSystem = _interopRequireDefault(require("./systems/AssetSystem"));

var _Asset = _interopRequireDefault(require("./systems/AssetSystem/Asset"));

var _RenderSystem = _interopRequireWildcard(require("./systems/RenderSystem"));

var _InputSystem = _interopRequireDefault(require("./systems/InputSystem"));

var _StorageSystem = _interopRequireDefault(require("./systems/StorageSystem"));

var _AudioSystem = _interopRequireDefault(require("./systems/AudioSystem"));

var _AssemblySystem = _interopRequireDefault(require("./systems/AssemblySystem"));

var _Events = _interopRequireDefault(require("./utils/Events"));

var _glMatrix = require("./utils/gl-matrix");

var _utils = _interopRequireWildcard(require("./utils"));

var _assetLoaders = _interopRequireDefault(require("./asset-loaders"));

var _components = _interopRequireDefault(require("./components"));

var _systems = _interopRequireDefault(require("./systems"));

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

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

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

var _default = {
  AssetLoaders: _assetLoaders.default,
  Components: _components.default,
  Systems: _systems.default,
  Utils: _utils.default,
  JSONAsset: _JSONAsset.default,
  TextAsset: _TextAsset.default,
  BinaryAsset: _BinaryAsset.default,
  ImageAsset: _ImageAsset.default,
  ShaderAsset: _ShaderAsset.default,
  SceneAsset: _SceneAsset.default,
  AtlasAsset: _AtlasAsset.default,
  FontAsset: _FontAsset.default,
  SoundAsset: _SoundAsset.default,
  MusicAsset: _MusicAsset.default,
  ParticleSystemAsset: _ParticleSystemAsset.default,
  PackAsset: _PackAsset.default,
  SkeletonAsset: _SkeletonAsset.default,
  SVGAsset: _SVGAsset.default,
  SetAsset: _SetAsset.default,
  AssemblyAsset: _AssemblyAsset.default,
  PostprocessRackEffectAsset: _PostprocessRackEffectAsset.default,
  Camera: _Camera.default,
  PostprocessPass: _Camera.PostprocessPass,
  Camera2D: _Camera2D.default,
  CameraDirector2D: _CameraDirector2D.default,
  InputHandler: _InputHandler.default,
  GestureListener: _GestureListener.default,
  Particles: _Particles.default,
  PhysicsBody: _PhysicsBody.default,
  PhysicsWorld: _PhysicsWorld.default,
  PrefabInstance: _PrefabInstance.default,
  RectangleRenderer: _RectangleRenderer.default,
  Script: _Script.default,
  Sprite: _Sprite.default,
  AtlasSprite: _AtlasSprite.default,
  TextRenderer: _TextRenderer.default,
  VerticesRenderer: _VerticesRenderer.default,
  UiSprite: _UiSprite.default,
  UiLayout: _UiLayout.default,
  Skeleton: _Skeleton.default,
  SortedActions: _SortedActions.default,
  DeferredRenderer: _DeferredRenderer.default,
  DeferredPipeline: _DeferredRenderer.DeferredPipeline,
  MultipassRenderer: _MultipassRenderer.default,
  MultipassPipeline: _MultipassRenderer.MultipassPipeline,
  PostprocessRack: _PostprocessRack.default,
  PostprocessRackPass: _PostprocessRack.PostprocessRackPass,
  PostprocessRackRawEffectPass: _PostprocessRack.PostprocessRackRawEffectPass,
  Shape: _Shape.default,
  PolygonShape: _PolygonShape.default,
  CircleShape: _CircleShape.default,
  RectangleShape: _RectangleShape.default,
  System: _System.default,
  EntitySystem: _EntitySystem.default,
  Component: _Component.default,
  Entity: _Entity.default,
  RenderSystem: _RenderSystem.default,
  RenderTargetWrapper: _RenderSystem.RenderTargetWrapper,
  Command: _RenderSystem.Command,
  Pipeline: _RenderSystem.Pipeline,
  RenderFullscreenCommand: _RenderSystem.RenderFullscreenCommand,
  InputSystem: _InputSystem.default,
  StorageSystem: _StorageSystem.default,
  AssetSystem: _AssetSystem.default,
  Asset: _Asset.default,
  AudioSystem: _AudioSystem.default,
  AssemblySystem: _AssemblySystem.default,
  Events: _Events.default,
  glMatrix: _glMatrix.glMatrix,
  mat2: _glMatrix.mat2,
  mat2d: _glMatrix.mat2d,
  mat3: _glMatrix.mat3,
  mat4: _glMatrix.mat4,
  quat: _glMatrix.quat,
  vec2: _glMatrix.vec2,
  vec3: _glMatrix.vec3,
  vec4: _glMatrix.vec4,
  box2d: _utils.box2d
};
exports.default = _default;

var EventsController =
/*#__PURE__*/
function () {
  _createClass(EventsController, [{
    key: "transform",
    get: function get() {
      return this._transform;
    },
    set: function set(value) {
      if (typeof value !== 'boolean') {
        throw new Error('`value` is not type of Boolean!');
      }

      this._transform = value;
    }
  }, {
    key: "update",
    get: function get() {
      return this._update;
    },
    set: function set(value) {
      if (typeof value !== 'boolean') {
        throw new Error('`value` is not type of Boolean!');
      }

      this._update = value;
    }
  }, {
    key: "view",
    get: function get() {
      return this._view;
    },
    set: function set(value) {
      if (typeof value !== 'boolean') {
        throw new Error('`value` is not type of Boolean!');
      }

      this._view = value;
    }
  }, {
    key: "gamepads",
    get: function get() {
      return this._gamepads;
    },
    set: function set(value) {
      if (typeof value !== 'boolean') {
        throw new Error('`value` is not type of Boolean!');
      }

      this._gamepads = value;
    }
  }, {
    key: "all",
    get: function get() {
      return this._transform && this._update && this._view && this._gamepads;
    },
    set: function set(value) {
      if (typeof value !== 'boolean') {
        throw new Error('`value` is not type of Boolean!');
      }

      this._transform = this._update = this._view = this._gamepads = value;
    }
  }, {
    key: "none",
    get: function get() {
      return !this._transform && !this._update && !this._view && !this._gamepads;
    },
    set: function set(value) {
      if (typeof value !== 'boolean') {
        throw new Error('`value` is not type of Boolean!');
      }

      this._transform = this._update = this._view = this._gamepads = !value;
    }
  }, {
    key: "accepted",
    get: function get() {
      var result = [];

      if (!!this._transform) {
        result.push('transform');
      }

      if (!!this._update) {
        result.push('update');
      }

      if (!!this._view) {
        result.push('view');
      }

      if (!!this._gamepads) {
        result.push('gamepads');
      }

      return result;
    },
    set: function set(value) {
      if (!Array.isArray(value)) {
        throw new Error('`value` is not type of Array!');
      }

      this._transform = value.indexOf('transform') >= 0;
      this._update = value.indexOf('update') >= 0;
      this._view = value.indexOf('view') >= 0;
      this._gamepads = value.indexOf('gamepads') >= 0;
    }
  }]);

  function EventsController() {
    _classCallCheck(this, EventsController);

    this._transform = true;
    this._update = true;
    this._view = true;
    this._gamepads = true;
  }

  return EventsController;
}();
/**
 * Function used to initialize Oxygen Core engine without any effort.
 *
 * @param {*} config - engine configuration options.
 * @return {EventsController} - instance used to dynamically control events processing.
 *
 * @example
 * lazyInitialization({
 *   entities: { triggerEvents: true },
 *   asset: { pathPrefix: 'assets/' },
 *   render: { screen: 'screen-0' },
 *   input: { triggerEvents: true },
 *   store: { id: 'my-game-id' },
 *   events: { transform: true, update: true, view: true, gamepads: true }
 * });
 */


exports.EventsController = EventsController;

function lazyInitialization(_ref) {
  var entity = _ref.entity,
      asset = _ref.asset,
      render = _ref.render,
      input = _ref.input,
      store = _ref.store,
      events = _ref.events;

  var entities = _System.default.register('EntitySystem', new _EntitySystem.default(!!entity ? entity.triggerEvents : true));

  var assets = _System.default.register('AssetSystem', new _AssetSystem.default(!!asset ? asset.pathPrefix : null, !!asset ? asset.fetchOptions : null, !!asset ? asset.fetchEngine : null));

  var renderer = _System.default.register('RenderSystem', new _RenderSystem.default(!!render ? render.screen : null, !!render ? render.optimize : true, !!render ? render.extensions : null, !!render ? render.version : 1, !!render ? render.manualMode : false));

  var inputs = _System.default.register('InputSystem', new _InputSystem.default(renderer.canvas, !!input ? input.triggerEvents : true));

  var storage = _System.default.register('StorageSystem', new _StorageSystem.default(!!store ? store.id : 'oxygen-data'));

  var audio = _System.default.register('AudioSystem', new _AudioSystem.default());

  var assembly = _System.default.register('AssemblySystem', new _AssemblySystem.default());

  var controller = new EventsController();
  controller.transform = !!events ? !!events.transform : true;
  controller.update = !!events ? !!events.update : true;
  controller.view = !!events ? !!events.view : true;
  controller.gamepads = !!events ? !!events.gamepads : true;
  entities.registerComponent('Camera2D', _Camera2D.default.factory);
  entities.registerComponent('CameraDirector2D', _CameraDirector2D.default.factory);
  entities.registerComponent('InputHandler', _InputHandler.default.factory);
  entities.registerComponent('GestureListener', _GestureListener.default.factory);
  entities.registerComponent('Particles', _Particles.default.factory);
  entities.registerComponent('PhysicsBody', _PhysicsBody.default.factory);
  entities.registerComponent('PhysicsWorld', _PhysicsWorld.default.factory);
  entities.registerComponent('PrefabInstance', _PrefabInstance.default.factory);
  entities.registerComponent('RectangleRenderer', _RectangleRenderer.default.factory);
  entities.registerComponent('Script', _Script.default.factory);
  entities.registerComponent('Sprite', _Sprite.default.factory);
  entities.registerComponent('AtlasSprite', _AtlasSprite.default.factory);
  entities.registerComponent('TextRenderer', _TextRenderer.default.factory);
  entities.registerComponent('VerticesRenderer', _VerticesRenderer.default.factory);
  entities.registerComponent('UiSprite', _UiSprite.default.factory);
  entities.registerComponent('UiLayout', _UiLayout.default.factory);
  entities.registerComponent('Skeleton', _Skeleton.default.factory);
  entities.registerComponent('SortedActions', _SortedActions.default.factory);
  entities.registerComponent('DeferredRenderer', _DeferredRenderer.default.factory);
  entities.registerComponent('MultipassRenderer', _MultipassRenderer.default.factory);
  entities.registerComponent('PostprocessRack', _PostprocessRack.default.factory);
  entities.registerComponent('PolygonShape', _PolygonShape.default.factory);
  entities.registerComponent('CircleShape', _CircleShape.default.factory);
  entities.registerComponent('RectangleShape', _RectangleShape.default.factory);
  assets.registerProtocol('json', _JSONAsset.default.factory);
  assets.registerProtocol('text', _TextAsset.default.factory);
  assets.registerProtocol('binary', _BinaryAsset.default.factory);
  assets.registerProtocol('image', _ImageAsset.default.factory);
  assets.registerProtocol('shader', _ShaderAsset.default.factory);
  assets.registerProtocol('scene', _SceneAsset.default.factory);
  assets.registerProtocol('atlas', _AtlasAsset.default.factory);
  assets.registerProtocol('font', _FontAsset.default.factory);
  assets.registerProtocol('sound', _SoundAsset.default.factory);
  assets.registerProtocol('music', _MusicAsset.default.factory);
  assets.registerProtocol('particles', _ParticleSystemAsset.default.factory);
  assets.registerProtocol('pack', _PackAsset.default.factory);
  assets.registerProtocol('skeleton', _SkeletonAsset.default.factory);
  assets.registerProtocol('svg', _SVGAsset.default.factory);
  assets.registerProtocol('set', _SetAsset.default.factory);
  assets.registerProtocol('wasm', _AssemblyAsset.default.factory);
  assets.registerProtocol('postprocess', _PostprocessRackEffectAsset.default.factory);
  assets.events.on('load', function (asset) {
    var protocol = asset.protocol,
        filename = asset.filename,
        data = asset.data;

    if (protocol === 'image' || protocol === 'svg') {
      renderer.registerTexture(filename, data, !!asset.options && !!asset.options.mipmap);
    } else if (protocol === 'shader') {
      renderer.registerShader(filename, data.vertex, data.fragment, data.layout, data.uniforms, data.samplers, data.blending, data.extensions);
    } else if (protocol === 'sound') {
      audio.registerSound(filename, data);
    } else if (protocol === 'music') {
      audio.registerMusic(filename, data);
    } else if (protocol === 'particles') {
      _Particles.default.registerProcessor(filename, data);
    } else if (protocol === 'wasm') {
      assembly.registerAssembly(filename, data, !!asset.options && !!asset.options.imports ? assembly.getImports(asset.options.imports) || {} : null);
    }
  });
  assets.events.on('unload', function (asset) {
    var protocol = asset.protocol,
        filename = asset.filename;

    if (protocol === 'image' || protocol === 'svg') {
      renderer.unregisterTexture(filename);
    } else if (protocol === 'shader') {
      renderer.unregisterShader(filename);
    } else if (protocol === 'sound') {
      audio.unregisterSound(filename);
    } else if (protocol === 'music') {
      audio.unregisterMusic(filename);
    } else if (protocol === 'particles') {
      _Particles.default.unregisterProcessor(filename);
    } else if (protocol === 'wasm') {
      assembly.unregisterAssembly(filename);
    }
  });
  renderer.events.on('render', function (context, renderer, deltaTime) {
    !!controller.transform && entities.updateTransforms();
    !!controller.update && entities.performAction('update', deltaTime);
    !!controller.view && entities.performAction('view', context, renderer, deltaTime);
    !!controller.gamepads && inputs.scanForGamepads();
  });

  _System.default.events.on('change-scene', function (path) {
    var asset = assets.get(path);

    if (!asset) {
      throw new Error("There is no asset loaded: ".concat(path));
    }

    if (!(asset instanceof _SceneAsset.default)) {
      throw new Error("Asset is not type of SceneAsset: ".concat(path));
    }

    entities.root = entities.buildEntity(asset.data);
  });

  _System.default.events.on('clear-scene', function () {
    entities.root = null;
  });

  return controller;
}