@eva/plugin-renderer 1.2.8-fix.1 → 1.2.8

package/dist/miniprogram.js

@@ -0,0 +1,1052 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : 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; }; return _extends.apply(this, arguments); }
+
+import { __values, __extends, __decorate, __spread, __assign } from 'tslib';
+import { OBSERVER_TYPE, decorators, resourceLoader, resource, RESOURCE_TYPE_STRATEGY, LOAD_SCENE_MODE, System } from '@eva/eva.js/dist/miniprogram';
+import { Container, Application } from '@eva/renderer-adapter/dist/miniprogram';
+import isEqual from 'lodash-es/isEqual';
+import EventEmitter from 'eventemitter3';
+import { glCore, Texture, BaseTexture, utils, ticker } from '@eva/miniprogram-pixi';
+
+var RendererManager = function () {
+  function RendererManager(_a) {
+    var game = _a.game,
+        rendererSystem = _a.rendererSystem;
+    this.renderers = [];
+    this.game = game;
+    this.rendererSystem = rendererSystem;
+  }
+
+  RendererManager.prototype.register = function () {
+    var e_1, _a;
+
+    var renderers = [];
+
+    for (var _i = 0; _i < arguments.length; _i++) {
+      renderers[_i] = arguments[_i];
+    }
+
+    try {
+      for (var renderers_1 = __values(renderers), renderers_1_1 = renderers_1.next(); !renderers_1_1.done; renderers_1_1 = renderers_1.next()) {
+        var renderer = renderers_1_1.value;
+        renderer.game = this.game;
+        renderer.rendererManager = this.rendererSystem.rendererManager;
+        renderer.containerManager = this.rendererSystem.containerManager;
+        this.renderers.push(renderer);
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (renderers_1_1 && !renderers_1_1.done && (_a = renderers_1.return)) _a.call(renderers_1);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+  };
+
+  RendererManager.prototype.componentChanged = function (changes) {
+    var e_2, _a;
+
+    var _loop_1 = function _loop_1(changed) {
+      var e_3, _a;
+
+      try {
+        for (var _b = (e_3 = void 0, __values(this_1.renderers)), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var renderer = _c.value;
+          var props = renderer.observerInfo[changed.componentName];
+
+          if (props) {
+            if ([OBSERVER_TYPE.ADD, OBSERVER_TYPE.REMOVE].indexOf(changed.type) > -1) {
+              try {
+                renderer.componentChanged && renderer.componentChanged(changed);
+              } catch (e) {
+                console.error("gameObject: " + changed.gameObject.name + ", " + changed.componentName + " is error.", changed, e);
+              }
+
+              continue;
+            }
+
+            var index = props.findIndex(function (prop) {
+              return isEqual(prop, changed.prop);
+            });
+
+            if (index > -1) {
+              try {
+                renderer.componentChanged && renderer.componentChanged(changed);
+              } catch (e) {
+                console.error("gameObject: " + (changed.gameObject && changed.gameObject.name) + ", " + changed.componentName + " is componentChanged error.", changed, e);
+              }
+            }
+          }
+        }
+      } catch (e_3_1) {
+        e_3 = {
+          error: e_3_1
+        };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        } finally {
+          if (e_3) throw e_3.error;
+        }
+      }
+    };
+
+    var this_1 = this;
+
+    try {
+      for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+        var changed = changes_1_1.value;
+
+        _loop_1(changed);
+      }
+    } catch (e_2_1) {
+      e_2 = {
+        error: e_2_1
+      };
+    } finally {
+      try {
+        if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
+      } finally {
+        if (e_2) throw e_2.error;
+      }
+    }
+  };
+
+  RendererManager.prototype.update = function (gameObject) {
+    var e_4, _a, e_5, _b;
+
+    try {
+      for (var _c = __values(gameObject.components), _d = _c.next(); !_d.done; _d = _c.next()) {
+        var component = _d.value;
+
+        try {
+          for (var _e = (e_5 = void 0, __values(this.renderers)), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var renderer = _f.value;
+            var cache = [];
+            var props = renderer.observerInfo[component.name];
+
+            if (props && cache.indexOf(gameObject) === -1) {
+              cache.push(gameObject);
+
+              try {
+                renderer.rendererUpdate && renderer.rendererUpdate(gameObject);
+              } catch (e) {
+                console.info("gameObject: " + gameObject.name + ", " + component.name + " is update error", e);
+              }
+            }
+          }
+        } catch (e_5_1) {
+          e_5 = {
+            error: e_5_1
+          };
+        } finally {
+          try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+          } finally {
+            if (e_5) throw e_5.error;
+          }
+        }
+      }
+    } catch (e_4_1) {
+      e_4 = {
+        error: e_4_1
+      };
+    } finally {
+      try {
+        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+      } finally {
+        if (e_4) throw e_4.error;
+      }
+    }
+  };
+
+  return RendererManager;
+}();
+
+var RendererManager$1 = RendererManager;
+
+var ContainerManager = function () {
+  function ContainerManager() {
+    this.containerMap = {};
+  }
+
+  ContainerManager.prototype.addContainer = function (_a) {
+    var name = _a.name,
+        container = _a.container;
+    this.containerMap[name] = container;
+  };
+
+  ContainerManager.prototype.getContainer = function (name) {
+    return this.containerMap[name];
+  };
+
+  ContainerManager.prototype.removeContainer = function (name) {
+    var _a;
+
+    (_a = this.containerMap[name]) === null || _a === void 0 ? void 0 : _a.destroy({
+      children: true
+    });
+    delete this.containerMap[name];
+  };
+
+  ContainerManager.prototype.updateTransform = function (_a) {
+    var name = _a.name,
+        transform = _a.transform;
+    var container = this.containerMap[name];
+    if (!container || !transform) return;
+    var anchor = transform.anchor,
+        origin = transform.origin,
+        position = transform.position,
+        rotation = transform.rotation,
+        scale = transform.scale,
+        size = transform.size,
+        skew = transform.skew;
+    container.rotation = rotation;
+    container.scale = scale;
+    container.pivot.x = size.width * origin.x;
+    container.pivot.y = size.height * origin.y;
+    container.skew = skew;
+    var x = position.x;
+    var y = position.y;
+
+    if (transform.parent) {
+      var parent_1 = transform.parent;
+      x = x + parent_1.size.width * anchor.x;
+      y = y + parent_1.size.height * anchor.y;
+    }
+
+    container.position = {
+      x: x,
+      y: y
+    };
+  };
+
+  return ContainerManager;
+}();
+
+var ContainerManager$1 = ContainerManager;
+
+var Transform = function (_super) {
+  __extends(Transform, _super);
+
+  function Transform(_a) {
+    var system = _a.system,
+        containerManager = _a.containerManager;
+
+    var _this = _super.call(this) || this;
+
+    _this.name = 'Transform';
+    _this.waitRemoveIds = [];
+    _this.waitChangeScenes = [];
+    _this.containerManager = containerManager;
+
+    _this.init(system);
+
+    return _this;
+  }
+
+  Transform.prototype.init = function (system) {
+    var _this = this;
+
+    this.system = system;
+    this.on('changeScene', function (_a) {
+      var scene = _a.scene,
+          mode = _a.mode,
+          application = _a.application;
+
+      _this.waitChangeScenes.push({
+        scene: scene,
+        mode: mode,
+        application: application
+      });
+    });
+  };
+
+  Transform.prototype.update = function () {
+    var e_1, _a, e_2, _b;
+
+    try {
+      for (var _c = __values(this.waitRemoveIds), _d = _c.next(); !_d.done; _d = _c.next()) {
+        var id = _d.value;
+        this.containerManager.removeContainer(id);
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+
+    this.waitRemoveIds = [];
+
+    try {
+      for (var _e = __values(this.waitChangeScenes), _f = _e.next(); !_f.done; _f = _e.next()) {
+        var sceneInfo = _f.value;
+        var container = this.containerManager.getContainer(sceneInfo.scene.id);
+
+        if (container) {
+          sceneInfo.application.stage.removeChildren();
+          sceneInfo.application.stage.addChild(container);
+        }
+      }
+    } catch (e_2_1) {
+      e_2 = {
+        error: e_2_1
+      };
+    } finally {
+      try {
+        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+      } finally {
+        if (e_2) throw e_2.error;
+      }
+    }
+
+    this.waitChangeScenes = [];
+  };
+
+  Transform.prototype.componentChanged = function (changed) {
+    if (changed.type === OBSERVER_TYPE.ADD) {
+      this.addContainer(changed);
+    } else if (changed.type === OBSERVER_TYPE.CHANGE) {
+      this.change(changed);
+    } else if (changed.type === OBSERVER_TYPE.REMOVE) {
+      this.waitRemoveIds.push(changed.gameObject.id);
+    }
+  };
+
+  Transform.prototype.addContainer = function (changed) {
+    var container = new Container();
+    container.name = changed.gameObject.name;
+    this.containerManager.addContainer({
+      name: changed.gameObject.id,
+      container: container
+    });
+    var transform = changed.component;
+    transform.worldTransform = container.transform.worldTransform;
+  };
+
+  Transform.prototype.change = function (changed) {
+    var transform = changed.component;
+
+    if (transform.parent) {
+      var parentContainer = this.containerManager.getContainer(transform.parent.gameObject.id);
+      parentContainer.addChild(this.containerManager.getContainer(changed.gameObject.id));
+      var render = changed.gameObject.transform.parent && changed.gameObject.transform.parent.gameObject.getComponent('Render');
+
+      if (render) {
+        render.sortDirty = true;
+      }
+    } else {
+      var container = this.containerManager.getContainer(changed.gameObject.id);
+      delete transform.worldTransform;
+      container.parent && container.parent.removeChild(container);
+    }
+  };
+
+  Transform.prototype.destroy = function () {
+    this.removeAllListeners();
+    this.waitRemoveIds = null;
+    this.waitChangeScenes = null;
+    this.system = null;
+    this.containerManager = null;
+  };
+
+  Transform = __decorate([decorators.componentObserver({
+    Transform: ['_parent']
+  })], Transform);
+  return Transform;
+}(EventEmitter);
+
+var Transform$1 = Transform;
+var result = undefined;
+
+function getSuportCompressedTextureFormats(gl) {
+  if (result) return result;
+
+  if (!gl) {
+    console.warn('WebGL not available for compressed textures. Silently failing.');
+    return {
+      s3tc: false,
+      etc: false,
+      etc1: false,
+      pvrtc: false,
+      atc: false,
+      astc: false
+    };
+  }
+
+  result = {
+    s3tc: !!gl.getExtension('WEBGL_compressed_texture_s3tc'),
+    etc: !!gl.getExtension('WEBGL_compressed_texture_etc'),
+    etc1: !!gl.getExtension('WEBGL_compressed_texture_etc1'),
+    pvrtc: !!gl.getExtension('WEBGL_compressed_texture_pvrtc') || !!gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc'),
+    atc: !!gl.getExtension('WEBGL_compressed_texture_atc'),
+    astc: !!gl.getExtension('WEBGL_compressed_texture_astc')
+  };
+
+  try {
+    console.log('Eva.js Supported Compressed Texture Format List: ' + Object.keys(result).filter(function (type) {
+      return result[type];
+    }).join(', '));
+  } catch (e) {}
+
+  return result;
+}
+
+var XLS = resourceLoader.XhrLoadStrategy;
+var XhrLoadStrategy = XLS;
+
+var _a, _b;
+
+var INTERNAL_FORMATS;
+
+(function (INTERNAL_FORMATS) {
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_S3TC_DXT1_EXT"] = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_S3TC_DXT1_EXT"] = 33777] = "COMPRESSED_RGBA_S3TC_DXT1_EXT";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_S3TC_DXT3_EXT"] = 33778] = "COMPRESSED_RGBA_S3TC_DXT3_EXT";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_S3TC_DXT5_EXT"] = 33779] = "COMPRESSED_RGBA_S3TC_DXT5_EXT";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"] = 35917] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"] = 35918] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"] = 35919] = "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB_S3TC_DXT1_EXT"] = 35916] = "COMPRESSED_SRGB_S3TC_DXT1_EXT";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_R11_EAC"] = 37488] = "COMPRESSED_R11_EAC";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SIGNED_R11_EAC"] = 37489] = "COMPRESSED_SIGNED_R11_EAC";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RG11_EAC"] = 37490] = "COMPRESSED_RG11_EAC";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SIGNED_RG11_EAC"] = 37491] = "COMPRESSED_SIGNED_RG11_EAC";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB8_ETC2"] = 37492] = "COMPRESSED_RGB8_ETC2";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA8_ETC2_EAC"] = 37496] = "COMPRESSED_RGBA8_ETC2_EAC";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ETC2"] = 37493] = "COMPRESSED_SRGB8_ETC2";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"] = 37497] = "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37494] = "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"] = 37495] = "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_PVRTC_4BPPV1_IMG"] = 35840] = "COMPRESSED_RGB_PVRTC_4BPPV1_IMG";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"] = 35842] = "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_PVRTC_2BPPV1_IMG"] = 35841] = "COMPRESSED_RGB_PVRTC_2BPPV1_IMG";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"] = 35843] = "COMPRESSED_RGBA_PVRTC_2BPPV1_IMG";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_ETC1_WEBGL"] = 36196] = "COMPRESSED_RGB_ETC1_WEBGL";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_ATC_WEBGL"] = 35986] = "COMPRESSED_RGB_ATC_WEBGL";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"] = 35986] = "COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"] = 34798] = "COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_10x10_KHR"] = 37819] = "COMPRESSED_RGBA_ASTC_10x10_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_10x5_KHR"] = 37816] = "COMPRESSED_RGBA_ASTC_10x5_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_10x6_KHR"] = 37817] = "COMPRESSED_RGBA_ASTC_10x6_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_10x8_KHR"] = 37818] = "COMPRESSED_RGBA_ASTC_10x8_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_12x10_KHR"] = 37820] = "COMPRESSED_RGBA_ASTC_12x10_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_12x12_KHR"] = 37821] = "COMPRESSED_RGBA_ASTC_12x12_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_4x4_KHR"] = 37808] = "COMPRESSED_RGBA_ASTC_4x4_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_5x4_KHR"] = 37809] = "COMPRESSED_RGBA_ASTC_5x4_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_5x5_KHR"] = 37810] = "COMPRESSED_RGBA_ASTC_5x5_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_6x5_KHR"] = 37811] = "COMPRESSED_RGBA_ASTC_6x5_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_6x6_KHR"] = 37812] = "COMPRESSED_RGBA_ASTC_6x6_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_8x5_KHR"] = 37813] = "COMPRESSED_RGBA_ASTC_8x5_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_8x6_KHR"] = 37814] = "COMPRESSED_RGBA_ASTC_8x6_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGBA_ASTC_8x8_KHR"] = 37815] = "COMPRESSED_RGBA_ASTC_8x8_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"] = 3781] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"] = 37847] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"] = 37849] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"] = 37850] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"] = 37852] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"] = 37853] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"] = 37840] = "COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"] = 37841] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"] = 37842] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"] = 37843] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"] = 37844] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"] = 37845] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"] = 37846] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR";
+  INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"] = 37847] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR";
+})(INTERNAL_FORMATS || (INTERNAL_FORMATS = {}));
+
+var INTERNAL_FORMAT_TO_BLOCK_SIZE = (_a = {}, _a[INTERNAL_FORMATS.COMPRESSED_RGB_S3TC_DXT1_EXT] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_SRGB_S3TC_DXT1_EXT] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_R11_EAC] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_SIGNED_R11_EAC] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RG11_EAC] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_SIGNED_RG11_EAC] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGB8_ETC2] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA8_ETC2_EAC] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_SRGB8_ETC2] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG] = [8, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG] = [8, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGB_ETC1_WEBGL] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGB_ATC_WEBGL] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_4x4_KHR] = [4, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_5x5_KHR] = [5, 5], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_6x6_KHR] = [6, 6], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_8x8_KHR] = [8, 8], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_10x10_KHR] = [10, 10], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_12x12_KHR] = [12, 12], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_10x5_KHR] = [10, 5], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_10x6_KHR] = [10, 6], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_10x8_KHR] = [10, 8], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_12x10_KHR] = [12, 10], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_5x4_KHR] = [5, 4], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_6x5_KHR] = [6, 5], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_8x5_KHR] = [8, 5], _a[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_8x6_KHR] = [8, 6], _a);
+var INTERNAL_FORMATS_TO_EXTENSION_NAME = (_b = {}, _b[INTERNAL_FORMATS.COMPRESSED_RGB_S3TC_DXT1_EXT] = 'WEBGL_compressed_texture_s3tc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT] = 'WEBGL_compressed_texture_s3tc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT] = 'WEBGL_compressed_texture_s3tc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT] = 'WEBGL_compressed_texture_s3tc', _b[INTERNAL_FORMATS.COMPRESSED_SRGB_S3TC_DXT1_EXT] = 'WEBGL_compressed_texture_s3tc_srgb', _b[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT] = 'WEBGL_compressed_texture_s3tc_srgb', _b[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT] = 'WEBGL_compressed_texture_s3tc_srgb', _b[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT] = 'WEBGL_compressed_texture_s3tc_srgb', _b[INTERNAL_FORMATS.COMPRESSED_R11_EAC] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_SIGNED_R11_EAC] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_RG11_EAC] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_SIGNED_RG11_EAC] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_RGB8_ETC2] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA8_ETC2_EAC] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_SRGB8_ETC2] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 'WEBGL_compressed_texture_etc', _b[INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG] = 'WEBGL_compressed_texture_pvrtc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG] = 'WEBGL_compressed_texture_pvrtc', _b[INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG] = 'WEBGL_compressed_texture_pvrtc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG] = 'WEBGL_compressed_texture_pvrtc', _b[INTERNAL_FORMATS.COMPRESSED_RGB_ETC1_WEBGL] = 'WEBGL_compressed_texture_etc1', _b[INTERNAL_FORMATS.COMPRESSED_RGB_ATC_WEBGL] = 'WEBGL_compressed_texture_atc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL] = 'WEBGL_compressed_texture_atc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL] = 'WEBGL_compressed_texture_atc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_4x4_KHR] = 'WEBGL_compressed_texture_astc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_5x5_KHR] = 'WEBGL_compressed_texture_astc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_6x6_KHR] = 'WEBGL_compressed_texture_astc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_8x8_KHR] = 'WEBGL_compressed_texture_astc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_10x10_KHR] = 'WEBGL_compressed_texture_astc', _b[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_12x12_KHR] = 'WEBGL_compressed_texture_astc', _b);
+
+var CompressedTextureResource = function () {
+  function CompressedTextureResource() {
+    this.levelBuffers = [];
+  }
+
+  CompressedTextureResource.prototype.upload = function (gl) {
+    var levels = this.levels;
+    var name = INTERNAL_FORMATS_TO_EXTENSION_NAME[this.internalFormat];
+
+    if (!gl[name]) {
+      gl[name] = true;
+
+      if (name === 'WEBGL_compressed_texture_pvrtc') {
+        gl.getExtension(name) || gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc');
+      } else {
+        gl.getExtension(name);
+      }
+    }
+
+    for (var i = 0; i < this.levels; ++i) {
+      var _a = this.levelBuffers[i],
+          levelWidth = _a.levelWidth,
+          levelHeight = _a.levelHeight,
+          levelBuffer = _a.levelBuffer;
+      gl.compressedTexImage2D(gl.TEXTURE_2D, i, this.internalFormat, levelWidth, levelHeight, 0, levelBuffer);
+    }
+
+    if (levels > 1) {
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_NEAREST);
+    } else {
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    }
+  };
+
+  return CompressedTextureResource;
+}();
+
+var FILE_HEADER_SIZE = 64;
+var KTX_FIELDS = {
+  FILE_IDENTIFIER: 0,
+  ENDIANNESS: 12,
+  GL_TYPE: 16,
+  GL_TYPE_SIZE: 20,
+  GL_FORMAT: 24,
+  GL_INTERNAL_FORMAT: 28,
+  GL_BASE_INTERNAL_FORMAT: 32,
+  PIXEL_WIDTH: 36,
+  PIXEL_HEIGHT: 40,
+  PIXEL_DEPTH: 44,
+  NUMBER_OF_ARRAY_ELEMENTS: 48,
+  NUMBER_OF_FACES: 52,
+  NUMBER_OF_MIPMAP_LEVELS: 56,
+  BYTES_OF_KEY_VALUE_DATA: 60
+};
+var FILE_IDENTIFIER = [0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A];
+var ENDIANNESS = 0x04030201;
+
+var KTXTextureResource = function (_super) {
+  __extends(KTXTextureResource, _super);
+
+  function KTXTextureResource(source, config) {
+    var _a;
+
+    var _this = _super.call(this) || this;
+
+    _this.complete = true;
+    _this.src = config.url;
+    var dataView = new DataView(source);
+
+    if (!validateKTX(dataView)) {
+      throw new Error('Not a valid KTX Texture');
+    }
+
+    var littleEndian = dataView.getUint32(KTX_FIELDS.ENDIANNESS, true) === ENDIANNESS;
+    _this.internalFormat = dataView.getUint32(KTX_FIELDS.GL_INTERNAL_FORMAT, littleEndian);
+    var pixelWidth = _this.formerWidth = dataView.getUint32(KTX_FIELDS.PIXEL_WIDTH, littleEndian);
+    var pixelHeight = _this.formerHeight = dataView.getUint32(KTX_FIELDS.PIXEL_HEIGHT, littleEndian) || 1;
+    var size = INTERNAL_FORMAT_TO_BLOCK_SIZE[_this.internalFormat];
+    _this.width = pixelWidth % size[0] === 0 ? pixelWidth : pixelWidth + size[0] - pixelWidth % size[0];
+    _this.height = pixelHeight % size[1] === 0 ? pixelHeight : pixelHeight + size[1] - pixelHeight % size[1];
+    var src = resource.resourcesMap[config.metadata.name].src[config.metadata.key];
+
+    var _b = (_a = src === null || src === void 0 ? void 0 : src.size) !== null && _a !== void 0 ? _a : {},
+        width = _b.width,
+        height = _b.height;
+
+    if (width && height) {
+      _this.naturalWidth = width;
+      _this.naturalHeight = height;
+    }
+
+    var pixelDepth = dataView.getUint32(KTX_FIELDS.PIXEL_DEPTH, littleEndian) || 1;
+    var numberOfArrayElements = dataView.getUint32(KTX_FIELDS.NUMBER_OF_ARRAY_ELEMENTS, littleEndian) || 1;
+    var numberOfFaces = dataView.getUint32(KTX_FIELDS.NUMBER_OF_FACES, littleEndian);
+    var numberOfMipmapLevels = _this.levels = dataView.getUint32(KTX_FIELDS.NUMBER_OF_MIPMAP_LEVELS, littleEndian);
+    var bytesOfKeyValueData = dataView.getUint32(KTX_FIELDS.BYTES_OF_KEY_VALUE_DATA, littleEndian);
+
+    if (pixelHeight === 0 || pixelDepth !== 1) {
+      throw new Error('Only 2D textures are supported!');
+    }
+
+    if (numberOfFaces !== 1) {
+      throw new Error('CubeTextures are not supported!');
+    }
+
+    if (numberOfArrayElements !== 1) {
+      throw new Error('It does not support array textures!');
+    }
+
+    var mipWidth = pixelWidth;
+    var mipHeight = pixelHeight;
+    var imageOffset = FILE_HEADER_SIZE + bytesOfKeyValueData;
+
+    for (var mipmapLevel = 0; mipmapLevel < numberOfMipmapLevels; mipmapLevel++) {
+      var imageSize = dataView.getUint32(imageOffset, littleEndian);
+      imageOffset += 4;
+      var size_1 = INTERNAL_FORMAT_TO_BLOCK_SIZE[_this.internalFormat];
+      var levelWidth = mipWidth % size_1[0] === 0 ? mipWidth : mipWidth + size_1[0] - mipWidth % size_1[0];
+      var levelHeight = mipHeight % size_1[1] === 0 ? mipHeight : mipHeight + size_1[1] - mipHeight % size_1[1];
+      var mip = {
+        levelID: mipmapLevel,
+        levelWidth: levelWidth,
+        levelHeight: levelHeight,
+        levelBuffer: new Uint8Array(source, imageOffset, imageSize)
+      };
+
+      _this.levelBuffers.push(mip);
+
+      imageOffset += imageSize;
+      imageOffset += 3 - (imageOffset + 3) % 4;
+      mipWidth = mipWidth >> 1 || 1;
+      mipHeight = mipHeight >> 1 || 1;
+    }
+
+    return _this;
+  }
+
+  return KTXTextureResource;
+}(CompressedTextureResource);
+
+function validateKTX(dataView) {
+  for (var i = 0; i < FILE_IDENTIFIER.length; i++) {
+    if (dataView.getUint8(i) !== FILE_IDENTIFIER[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+var KTXLoadStrategy = function (_super) {
+  __extends(KTXLoadStrategy, _super);
+
+  function KTXLoadStrategy() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+
+  KTXLoadStrategy.prototype._complete = function (type, data) {
+    _super.prototype._complete.call(this, type, new KTXTextureResource(data, this.config));
+  };
+
+  return KTXLoadStrategy;
+}(XhrLoadStrategy);
+
+var KTXLoadStrategy$1 = KTXLoadStrategy;
+var XhrResponseType = resourceLoader.XhrResponseType;
+
+function addPreProcessResourceHandler(resource, gl) {
+  resource.addPreProcessResourceHandler(function normalizeResource(resource) {
+    var _a, _b, _c;
+
+    var textures = (_b = (_a = resource.src) === null || _a === void 0 ? void 0 : _a.image) === null || _b === void 0 ? void 0 : _b.texture;
+    if (!textures) return;
+
+    if (!Array.isArray(textures)) {
+      textures = [textures];
+    }
+
+    var formats = (_c = getSuportCompressedTextureFormats(gl)) !== null && _c !== void 0 ? _c : {};
+    var target = textures.find(function (texture) {
+      return formats[texture.type];
+    });
+
+    if (target) {
+      _extends(resource.src.image, target);
+    }
+  });
+}
+
+function addKTXStragetyAndRegister() {
+  _extends(RESOURCE_TYPE_STRATEGY, {
+    astc: KTXLoadStrategy$1,
+    etc: KTXLoadStrategy$1,
+    pvrtc: KTXLoadStrategy$1,
+    s3tc: KTXLoadStrategy$1,
+    atc: KTXLoadStrategy$1
+  });
+
+  KTXLoadStrategy$1.setExtensionXhrType('ktx', XhrResponseType.Buffer);
+}
+
+var GLTexture = glCore.GLTexture;
+var GLTextureMixin = {
+  isCompressed: false,
+  uploadNotCompressed: GLTexture.prototype.upload,
+  upload: function upload(source) {
+    if (!(source instanceof CompressedTextureResource)) {
+      return this.uploadNotCompressed(source);
+    }
+
+    this.bind();
+    var gl = this.gl;
+    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, this.premultiplyAlpha);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST_MIPMAP_NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    this.isCompressed = true;
+    source.upload(gl);
+  },
+  enableMipmap: function enableMipmap() {
+    if (this.isCompressed) {
+      return;
+    }
+
+    var gl = this.gl;
+    this.bind();
+    this.mipmap = true;
+    gl.generateMipmap(gl.TEXTURE_2D);
+  }
+};
+var TextureMixin = {
+  oldFrom: Texture.from,
+  from: function from(source) {
+    if (!(source instanceof CompressedTextureResource)) {
+      return this.oldFrom(source);
+    }
+
+    return new Texture(BaseTexture.from(source));
+  }
+};
+var BaseTextureMixin = {
+  oldFrom: BaseTexture.from,
+  from: function from(source, scaleMode, sourceScale) {
+    if (!(source instanceof CompressedTextureResource)) {
+      return this.oldFrom(source, scaleMode, sourceScale);
+    }
+
+    var imageUrl = source.src;
+    var baseTexture = utils.BaseTextureCache[imageUrl];
+
+    if (!baseTexture) {
+      baseTexture = new BaseTexture(source, scaleMode);
+      baseTexture.imageUrl = imageUrl;
+
+      if (sourceScale) {
+        baseTexture.sourceScale = sourceScale;
+      }
+
+      BaseTexture.addToCache(baseTexture, imageUrl);
+    }
+
+    return baseTexture;
+  }
+};
+
+function registerCompressedTexture(gl) {
+  addPreProcessResourceHandler(resource, gl);
+  addKTXStragetyAndRegister();
+
+  _extends(glCore.GLTexture.prototype, GLTextureMixin);
+
+  _extends(Texture, TextureMixin);
+
+  _extends(BaseTexture, BaseTextureMixin);
+}
+
+var RENDERER_TYPE;
+
+(function (RENDERER_TYPE) {
+  RENDERER_TYPE[RENDERER_TYPE["UNKNOWN"] = 0] = "UNKNOWN";
+  RENDERER_TYPE[RENDERER_TYPE["WEBGL"] = 1] = "WEBGL";
+  RENDERER_TYPE[RENDERER_TYPE["CANVAS"] = 2] = "CANVAS";
+})(RENDERER_TYPE || (RENDERER_TYPE = {}));
+
+var disableScroll = function disableScroll(renderer) {
+  renderer.plugins.interaction.autoPreventDefault = true;
+  renderer.view.style.touchAction = 'none';
+};
+
+var enableScroll = function enableScroll(renderer) {
+  renderer.plugins.interaction.autoPreventDefault = false;
+  renderer.view.style.touchAction = 'auto';
+};
+
+var Renderer$2 = function (_super) {
+  __extends(Renderer, _super);
+
+  function Renderer() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+
+    _this.multiApps = [];
+    return _this;
+  }
+
+  Renderer.prototype.init = function (params) {
+    var _this = this;
+
+    this.params = params;
+    this.application = this.createApplication(params);
+    this.containerManager = new ContainerManager$1();
+    this.rendererManager = new RendererManager$1({
+      game: this.game,
+      rendererSystem: this
+    });
+    this.game.canvas = this.application.view;
+    this.transform = new Transform$1({
+      system: this,
+      containerManager: this.containerManager
+    });
+    this.game.on('sceneChanged', function (_a) {
+      var scene = _a.scene,
+          mode = _a.mode,
+          params = _a.params;
+      var application;
+
+      switch (mode) {
+        case LOAD_SCENE_MODE.SINGLE:
+          application = _this.application;
+          break;
+
+        case LOAD_SCENE_MODE.MULTI_CANVAS:
+          application = _this.createMultiApplication({
+            params: params
+          });
+          break;
+      }
+
+      scene.canvas = application.view;
+
+      _this.transform.emit('changeScene', {
+        scene: scene,
+        mode: mode,
+        application: application
+      });
+    });
+    var gl = this.application.renderer.gl;
+
+    if (gl) {
+      this.suportedCompressedTextureFormats = getSuportCompressedTextureFormats(gl);
+      registerCompressedTexture(gl);
+    }
+  };
+
+  Renderer.prototype.registerObserver = function (observerInfo) {
+    var _a;
+
+    var thisObserverInfo = this.constructor.observerInfo;
+
+    for (var key in observerInfo) {
+      if (!thisObserverInfo[key]) {
+        thisObserverInfo[key] = [];
+      }
+
+      (_a = thisObserverInfo[key]).push.apply(_a, __spread(observerInfo[key]));
+    }
+  };
+
+  Renderer.prototype.createMultiApplication = function (_a) {
+    var params = _a.params;
+    var app = this.createApplication(params);
+    this.multiApps.push(app);
+    return app;
+  };
+
+  Renderer.prototype.createApplication = function (params) {
+    params.view = params.canvas;
+
+    if (params.renderType === RENDERER_TYPE.CANVAS) {
+      params.forceCanvas = true;
+    }
+
+    var app;
+
+    try {
+      app = new Application(__assign({
+        sharedTicker: true
+      }, params));
+    } catch (e) {
+      if (e.message.match(/not support webgl/i) !== undefined) {
+        app = new Application(__assign(__assign({
+          sharedTicker: true
+        }, params), {
+          forceCanvas: true
+        }));
+      }
+    }
+
+    ticker.shared.stop();
+    ticker.shared.autoStart = false;
+
+    if (params.preventScroll !== undefined) {
+      console.warn('PreventScroll property will deprecate at next major version, please use enableScroll instead. https://eva.js.org/#/tutorials/game');
+      params.preventScroll ? enableScroll(app.renderer) : disableScroll(app.renderer);
+    }
+
+    if (params.enableScroll !== undefined) {
+      params.enableScroll ? enableScroll(app.renderer) : disableScroll(app.renderer);
+    }
+
+    if (params.preventScroll === undefined && params.enableScroll === undefined) {
+      enableScroll(app.renderer);
+    }
+
+    return app;
+  };
+
+  Renderer.prototype.update = function () {
+    var e_1, _a, e_2, _b;
+
+    var changes = this.componentObserver.clear();
+
+    try {
+      for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+        var changed = changes_1_1.value;
+        this.transform.componentChanged(changed);
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+
+    try {
+      for (var _c = __values(this.game.gameObjects), _d = _c.next(); !_d.done; _d = _c.next()) {
+        var gameObject = _d.value;
+        this.containerManager.updateTransform({
+          name: gameObject.id,
+          transform: gameObject.transform
+        });
+        this.rendererManager.update(gameObject);
+      }
+    } catch (e_2_1) {
+      e_2 = {
+        error: e_2_1
+      };
+    } finally {
+      try {
+        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+      } finally {
+        if (e_2) throw e_2.error;
+      }
+    }
+  };
+
+  Renderer.prototype.lateUpdate = function (e) {
+    this.transform.update();
+    this.application.ticker.update(e.time);
+  };
+
+  Renderer.prototype.onDestroy = function () {
+    var e_3, _a;
+
+    this.application.destroy();
+
+    try {
+      for (var _b = __values(this.multiApps), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var app = _c.value;
+        app && app.destroy();
+      }
+    } catch (e_3_1) {
+      e_3 = {
+        error: e_3_1
+      };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_3) throw e_3.error;
+      }
+    }
+
+    this.transform.destroy();
+    this.transform = null;
+    this.params = null;
+    this.rendererManager = null;
+    this.containerManager = null;
+    this.application = null;
+    this.game = null;
+    this.multiApps = null;
+  };
+
+  Renderer.prototype.resize = function (width, height) {
+    this.params.width = width;
+    this.params.height = height;
+    this.application.renderer.resize(width, height);
+  };
+
+  Renderer.systemName = 'Renderer';
+  Renderer = __decorate([decorators.componentObserver({
+    Transform: ['_parent']
+  })], Renderer);
+  return Renderer;
+}(System);
+
+var Renderer$3 = Renderer$2;
+
+var Renderer = function (_super) {
+  __extends(Renderer, _super);
+
+  function Renderer(params) {
+    var _this = _super.call(this, params) || this;
+
+    _this.asyncIdMap = {};
+    _this.observerInfo = _this.constructor.observerInfo;
+    return _this;
+  }
+
+  Renderer.prototype.componentChanged = function (_changed) {};
+
+  Renderer.prototype.rendererUpdate = function (_gameObject) {};
+
+  Renderer.prototype.update = function (e) {
+    var e_1, _a;
+
+    var changes = this.componentObserver.clear();
+
+    try {
+      for (var changes_1 = __values(changes), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+        var changed = changes_1_1.value;
+        this.componentChanged(changed);
+      }
+    } catch (e_1_1) {
+      e_1 = {
+        error: e_1_1
+      };
+    } finally {
+      try {
+        if (changes_1_1 && !changes_1_1.done && (_a = changes_1.return)) _a.call(changes_1);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+  };
+
+  Renderer.prototype.increaseAsyncId = function (id) {
+    this.asyncIdMap[id] = (this.asyncIdMap[id] || 0) + 1;
+    return this.asyncIdMap[id];
+  };
+
+  Renderer.prototype.validateAsyncId = function (id, asyncId) {
+    return this.asyncIdMap[id] === asyncId;
+  };
+
+  return Renderer;
+}(System);
+
+var Renderer$1 = Renderer;
+
+var mixinPIXI = function mixinPIXI() {
+  BaseTexture.prototype.destroy = function () {
+    if (this.imageUrl) {
+      delete utils.TextureCache[this.imageUrl];
+      this.imageUrl = null;
+    }
+
+    this.source = null;
+    this.dispose();
+    BaseTexture.removeFromCache(this);
+    this.textureCacheIds = null;
+    this._destroyed = true;
+  };
+};
+
+mixinPIXI();
+export { ContainerManager$1 as ContainerManager, RENDERER_TYPE, Renderer$1 as Renderer, RendererManager$1 as RendererManager, Renderer$3 as RendererSystem };