@eva/plugin-renderer 1.1.1-beta.0 → 1.1.1-fix.2

package/dist/plugin-renderer.esm.js

@@ -1,10 +1,8 @@
-import { OBSERVER_TYPE, decorators, LOAD_SCENE_MODE, System, STRATEGY, resource } from '@eva/eva.js';
+import { OBSERVER_TYPE, decorators, resourceLoader, resource, RESOURCE_TYPE_STRATEGY, LOAD_SCENE_MODE, System } from '@eva/eva.js';
 import { Container, Application } from '@eva/renderer-adapter';
 import isEqual from 'lodash-es/isEqual';
 import EventEmitter from 'eventemitter3';
-import { ticker, glCore, Texture, BaseTexture, utils } from 'pixi.js';
-import { XhrLoadStrategy, XhrResponseType } from 'resource-loader';
-import { TYPES, FORMATS } from '@pixi/constants';
+import { glCore, Texture, BaseTexture, utils, ticker } from 'pixi.js';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation. All rights reserved.
@@ -211,7 +209,8 @@ var RendererManager = (function () {
         }
     };
     return RendererManager;
-}());
+}());
+var RendererManager$1 = RendererManager;
 
 var ContainerManager = (function () {
     function ContainerManager() {
@@ -232,7 +231,7 @@ var ContainerManager = (function () {
     ContainerManager.prototype.updateTransform = function (_a) {
         var name = _a.name, transform = _a.transform;
         var container = this.containerMap[name];
-        if (!container)
+        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;
@@ -250,7 +249,8 @@ var ContainerManager = (function () {
         container.position = { x: x, y: y };
     };
     return ContainerManager;
-}());
+}());
+var ContainerManager$1 = ContainerManager;
 
 var Transform = (function (_super) {
     __extends(Transform, _super);
@@ -358,205 +358,44 @@ var Transform = (function (_super) {
         })
     ], Transform);
     return Transform;
-}(EventEmitter));
+}(EventEmitter));
+var Transform$1 = Transform;
 
-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 (renderer) {
-    renderer.plugins.interaction.autoPreventDefault = true;
-    renderer.view.style.touchAction = 'none';
-};
-var enableScroll = function (renderer) {
-    renderer.plugins.interaction.autoPreventDefault = false;
-    renderer.view.style.touchAction = 'auto';
-};
-var Renderer$1 = (function (_super) {
-    __extends(Renderer, _super);
-    function Renderer() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.multiApps = [];
-        return _this;
+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,
+        };
     }
-    Renderer.prototype.init = function (params) {
-        var _this = this;
-        this.params = params;
-        this.application = this.createApplication(params);
-        this.containerManager = new ContainerManager();
-        this.rendererManager = new RendererManager({
-            game: this.game,
-            rendererSystem: this,
-        });
-        this.game.canvas = this.application.view;
-        this.transform = new Transform({
-            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,
-            });
-        });
+    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')
     };
-    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;
-        }
-        ticker.shared.autoStart = false;
-        ticker.shared.stop();
-        var app = new Application(__assign({ sharedTicker: true }, params));
-        if (params.preventScroll !== undefined) {
-            console.warn('PreventScroll property will deprecate at next major version, please use enableEnable 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 = (function (_super) {
-    __extends(Renderer, _super);
-    function Renderer(params) {
-        var _this = _super.call(this, params) || this;
-        _this.observerInfo = _this.constructor.observerInfo;
-        return _this;
+    try {
+        console.log('Eva.js Supported Compressed Texture Format List: ' + Object.keys(result).filter(function (type) { return result[type]; }).join(', '));
     }
-    Renderer.prototype.componentChanged = function (_changed) { };
-    Renderer.prototype.rendererUpdate = function (_gameObject) { };
-    Renderer.prototype.update = function () {
-        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; }
-        }
-    };
-    return Renderer;
-}(System));
+    catch (e) { }
+    return result;
+}
+
+var XLS = resourceLoader.XhrLoadStrategy;
+var XhrLoadStrategy = XLS;
 
-var _a$3, _b$1;
+var _a, _b;
 var INTERNAL_FORMATS;
 (function (INTERNAL_FORMATS) {
     INTERNAL_FORMATS[INTERNAL_FORMATS["COMPRESSED_RGB_S3TC_DXT1_EXT"] = 33776] = "COMPRESSED_RGB_S3TC_DXT1_EXT";
@@ -614,114 +453,86 @@ var INTERNAL_FORMATS;
     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_BYTES_PER_PIXEL = (_a$3 = {},
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGB_S3TC_DXT1_EXT] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_SRGB_S3TC_DXT1_EXT] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_R11_EAC] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_SIGNED_R11_EAC] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RG11_EAC] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_SIGNED_RG11_EAC] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGB8_ETC2] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA8_ETC2_EAC] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_SRGB8_ETC2] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG] = 0.25,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG] = 0.25,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGB_ETC1_WEBGL] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGB_ATC_WEBGL] = 0.5,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_4x4_KHR] = 1,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_5x5_KHR] = 5.12 * 0.125,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_6x6_KHR] = 3.56 * 0.125,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_8x8_KHR] = 2 * 0.125,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_10x10_KHR] = 1.28 * 0.125,
-    _a$3[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_12x12_KHR] = 0.89 * 0.125,
-    _a$3);
-var INTERNAL_FORMATS_TO_EXTENSION_NAME = (_b$1 = {},
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGB_S3TC_DXT1_EXT] = 'WEBGL_compressed_texture_s3tc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT] = 'WEBGL_compressed_texture_s3tc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT] = 'WEBGL_compressed_texture_s3tc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT] = 'WEBGL_compressed_texture_s3tc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_SRGB_S3TC_DXT1_EXT] = 'WEBGL_compressed_texture_s3tc_srgb',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT] = 'WEBGL_compressed_texture_s3tc_srgb',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT] = 'WEBGL_compressed_texture_s3tc_srgb',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT] = 'WEBGL_compressed_texture_s3tc_srgb',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_R11_EAC] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_SIGNED_R11_EAC] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RG11_EAC] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_SIGNED_RG11_EAC] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGB8_ETC2] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA8_ETC2_EAC] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_SRGB8_ETC2] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2] = 'WEBGL_compressed_texture_etc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG] = 'WEBGL_compressed_texture_pvrtc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG] = 'WEBGL_compressed_texture_pvrtc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG] = 'WEBGL_compressed_texture_pvrtc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG] = 'WEBGL_compressed_texture_pvrtc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGB_ETC1_WEBGL] = 'WEBGL_compressed_texture_etc1',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGB_ATC_WEBGL] = 'WEBGL_compressed_texture_atc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL] = 'WEBGL_compressed_texture_atc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL] = 'WEBGL_compressed_texture_atc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_4x4_KHR] = 'WEBGL_compressed_texture_astc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_5x5_KHR] = 'WEBGL_compressed_texture_astc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_6x6_KHR] = 'WEBGL_compressed_texture_astc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_8x8_KHR] = 'WEBGL_compressed_texture_astc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_10x10_KHR] = 'WEBGL_compressed_texture_astc',
-    _b$1[INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_12x12_KHR] = 'WEBGL_compressed_texture_astc',
-    _b$1);
-
-var res = undefined;
-function getAbilities() {
-    if (res)
-        return res;
-    var canvas = document.createElement('canvas');
-    var gl = canvas.getContext('webgl');
-    if (!gl) {
-        console.warn('WebGL not available for compressed textures. Silently failing.');
-        return;
-    }
-    var extensions = {
-        s3tc: gl.getExtension('WEBGL_compressed_texture_s3tc'),
-        s3tc_sRGB: gl.getExtension('WEBGL_compressed_texture_s3tc_srgb'),
-        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')
-    };
-    var textureFormats = {};
-    for (var extensionName in extensions) {
-        var extension = extensions[extensionName];
-        if (!extension) {
-            continue;
-        }
-        Object.assign(textureFormats, Object.getPrototypeOf(extension));
-    }
-    var formats = Object.values(textureFormats);
-    res = {
-        extensions: extensions,
-        textureFormats: textureFormats,
-        formats: formats
-    };
-    return res;
-}
+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;
@@ -751,26 +562,7 @@ var CompressedTextureResource = (function () {
     return CompressedTextureResource;
 }());
 
-var _a$2, _b, _c;
 var FILE_HEADER_SIZE = 64;
-var TYPES_TO_BYTES_PER_COMPONENT = (_a$2 = {},
-    _a$2[TYPES.UNSIGNED_BYTE] = 1,
-    _a$2[TYPES.UNSIGNED_SHORT] = 2,
-    _a$2[TYPES.FLOAT] = 4,
-    _a$2[TYPES.HALF_FLOAT] = 8,
-    _a$2);
-var FORMATS_TO_COMPONENTS = (_b = {},
-    _b[FORMATS.RGBA] = 4,
-    _b[FORMATS.RGB] = 3,
-    _b[FORMATS.LUMINANCE] = 1,
-    _b[FORMATS.LUMINANCE_ALPHA] = 2,
-    _b[FORMATS.ALPHA] = 1,
-    _b);
-var TYPES_TO_BYTES_PER_PIXEL = (_c = {},
-    _c[TYPES.UNSIGNED_SHORT_4_4_4_4] = 2,
-    _c[TYPES.UNSIGNED_SHORT_5_5_5_1] = 2,
-    _c[TYPES.UNSIGNED_SHORT_5_6_5] = 2,
-    _c);
 var KTX_FIELDS = {
     FILE_IDENTIFIER: 0,
     ENDIANNESS: 12,
@@ -791,93 +583,63 @@ var FILE_IDENTIFIER = [0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0
 var ENDIANNESS = 0x04030201;
 var KTXTextureResource = (function (_super) {
     __extends(KTXTextureResource, _super);
-    function KTXTextureResource(source, src) {
+    function KTXTextureResource(source, config) {
+        var _a;
         var _this = _super.call(this) || this;
-        _this.src = src;
         _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;
-        var glType = dataView.getUint32(KTX_FIELDS.GL_TYPE, littleEndian);
-        var glFormat = dataView.getUint32(KTX_FIELDS.GL_FORMAT, littleEndian);
-        var glInternalFormat = _this.internalFormat = dataView.getUint32(KTX_FIELDS.GL_INTERNAL_FORMAT, littleEndian);
-        var pixelWidth = _this.width = dataView.getUint32(KTX_FIELDS.PIXEL_WIDTH, littleEndian);
-        var pixelHeight = _this.height = dataView.getUint32(KTX_FIELDS.PIXEL_HEIGHT, littleEndian) || 1;
+        _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');
+            throw new Error('Only 2D textures are supported!');
         }
         if (numberOfFaces !== 1) {
-            throw new Error('CubeTextures are not supported by KTXLoader yet!');
+            throw new Error('CubeTextures are not supported!');
         }
         if (numberOfArrayElements !== 1) {
-            throw new Error('WebGL does not support array textures');
-        }
-        var blockWidth = 4;
-        var blockHeight = 4;
-        var alignedWidth = (pixelWidth + 3) & ~3;
-        var alignedHeight = (pixelHeight + 3) & ~3;
-        var imageBuffers = new Array(numberOfArrayElements);
-        var imagePixels = pixelWidth * pixelHeight;
-        if (glType === 0) {
-            imagePixels = alignedWidth * alignedHeight;
-        }
-        var imagePixelByteSize;
-        if (glType !== 0) {
-            if (TYPES_TO_BYTES_PER_COMPONENT[glType]) {
-                imagePixelByteSize = TYPES_TO_BYTES_PER_COMPONENT[glType] * FORMATS_TO_COMPONENTS[glFormat];
-            }
-            else {
-                imagePixelByteSize = TYPES_TO_BYTES_PER_PIXEL[glType];
-            }
-        }
-        else {
-            imagePixelByteSize = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[glInternalFormat];
+            throw new Error('It does not support array textures!');
         }
-        if (imagePixelByteSize === undefined) {
-            throw new Error('Unable to resolve the pixel format stored in the *.ktx file!');
-        }
-        var imageByteSize = imagePixels * imagePixelByteSize;
-        var mipByteSize = imageByteSize;
         var mipWidth = pixelWidth;
         var mipHeight = pixelHeight;
-        var alignedMipWidth = alignedWidth;
-        var alignedMipHeight = alignedHeight;
         var imageOffset = FILE_HEADER_SIZE + bytesOfKeyValueData;
         for (var mipmapLevel = 0; mipmapLevel < numberOfMipmapLevels; mipmapLevel++) {
             var imageSize = dataView.getUint32(imageOffset, littleEndian);
-            var elementOffset = imageOffset + 4;
-            for (var arrayElement = 0; arrayElement < numberOfArrayElements; arrayElement++) {
-                var mips = imageBuffers[arrayElement];
-                if (!mips) {
-                    mips = imageBuffers[arrayElement] = new Array(numberOfMipmapLevels);
-                }
-                mips[mipmapLevel] = {
-                    levelID: mipmapLevel,
-                    levelWidth: numberOfMipmapLevels > 1 ? mipWidth : alignedMipWidth,
-                    levelHeight: numberOfMipmapLevels > 1 ? mipHeight : alignedMipHeight,
-                    levelBuffer: new Uint8Array(source, elementOffset, mipByteSize)
-                };
-                elementOffset += mipByteSize;
-            }
-            imageOffset += imageSize + 4;
-            imageOffset = imageOffset % 4 !== 0 ? imageOffset + 4 - (imageOffset % 4) : imageOffset;
+            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;
-            alignedMipWidth = (mipWidth + blockWidth - 1) & ~(blockWidth - 1);
-            alignedMipHeight = (mipHeight + blockHeight - 1) & ~(blockHeight - 1);
-            mipByteSize = alignedMipWidth * alignedMipHeight * imagePixelByteSize;
-        }
-        if (glType !== 0) {
-            throw new Error('TODO: Uncompressed');
         }
-        _this.levelBuffers = imageBuffers[0];
         return _this;
     }
     return KTXTextureResource;
@@ -897,37 +659,38 @@ var KTXLoadStrategy = (function (_super) {
         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.url));
+        _super.prototype._complete.call(this, type, new KTXTextureResource(data, this.config));
     };
     return KTXLoadStrategy;
-}(XhrLoadStrategy));
+}(XhrLoadStrategy));
+var KTXLoadStrategy$1 = KTXLoadStrategy;
 
-function addPreProcessResourceHandler(resource) {
+var XhrResponseType = resourceLoader.XhrResponseType;
+function addPreProcessResourceHandler(resource, gl) {
     resource.addPreProcessResourceHandler(function normalizeResource(resource) {
-        var _a, _b;
+        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 extensions = getAbilities().extensions;
-        var target = textures.find(function (texture) { return extensions[texture.type]; });
+        var formats = (_c = getSuportCompressedTextureFormats(gl)) !== null && _c !== void 0 ? _c : {};
+        var target = textures.find(function (texture) { return formats[texture.type]; });
         if (target) {
-            resource.src.image.url = target.url;
-            resource.src.image.type = target.type;
+            Object.assign(resource.src.image, target);
         }
     });
 }
 function addKTXStragetyAndRegister() {
-    Object.assign(STRATEGY, {
-        astc: KTXLoadStrategy,
-        etc: KTXLoadStrategy,
-        pvrtc: KTXLoadStrategy,
-        s3tc: KTXLoadStrategy,
-        atc: KTXLoadStrategy,
+    Object.assign(RESOURCE_TYPE_STRATEGY, {
+        astc: KTXLoadStrategy$1,
+        etc: KTXLoadStrategy$1,
+        pvrtc: KTXLoadStrategy$1,
+        s3tc: KTXLoadStrategy$1,
+        atc: KTXLoadStrategy$1,
     });
-    KTXLoadStrategy.setExtensionXhrType('ktx', XhrResponseType.Buffer);
+    KTXLoadStrategy$1.setExtensionXhrType('ktx', XhrResponseType.Buffer);
 }
 
 var GLTexture = glCore.GLTexture;
@@ -957,25 +720,21 @@ var GLTextureMixin = {
     }
 };
 
-var _a$1;
-var oldFrom$1 = Symbol();
-var TextureMixin = (_a$1 = {},
-    _a$1[oldFrom$1] = Texture.from,
-    _a$1.from = function (source) {
+var TextureMixin = {
+    oldFrom: Texture.from,
+    from: function (source) {
         if (!(source instanceof CompressedTextureResource)) {
-            return this[oldFrom$1](source);
+            return this.oldFrom(source);
         }
         return new Texture(BaseTexture.from(source));
-    },
-    _a$1);
+    }
+};
 
-var _a;
-var oldFrom = Symbol();
-var BaseTextureMixin = (_a = {},
-    _a[oldFrom] = BaseTexture.from,
-    _a.from = function (source, scaleMode, sourceScale) {
+var BaseTextureMixin = {
+    oldFrom: BaseTexture.from,
+    from: function (source, scaleMode, sourceScale) {
         if (!(source instanceof CompressedTextureResource)) {
-            return this[oldFrom](source, scaleMode, sourceScale);
+            return this.oldFrom(source, scaleMode, sourceScale);
         }
         var imageUrl = source.src;
         var baseTexture = utils.BaseTextureCache[imageUrl];
@@ -988,17 +747,250 @@ var BaseTextureMixin = (_a = {},
             BaseTexture.addToCache(baseTexture, imageUrl);
         }
         return baseTexture;
-    },
-    _a);
+    }
+};
 
-function registerCompressedTexture() {
-    addPreProcessResourceHandler(resource);
+function registerCompressedTexture(gl) {
+    addPreProcessResourceHandler(resource, gl);
     addKTXStragetyAndRegister();
     Object.assign(glCore.GLTexture.prototype, GLTextureMixin);
     Object.assign(Texture, TextureMixin);
     Object.assign(BaseTexture, BaseTextureMixin);
 }
 
-registerCompressedTexture();
+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 (renderer) {
+    renderer.plugins.interaction.autoPreventDefault = true;
+    renderer.view.style.touchAction = 'none';
+};
+var enableScroll = function (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 enableEnable 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 () {
+    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, INTERNAL_FORMATS, INTERNAL_FORMATS_TO_EXTENSION_NAME, INTERNAL_FORMAT_TO_BYTES_PER_PIXEL, RENDERER_TYPE, Renderer, RendererManager, Renderer$1 as RendererSystem };
+export { ContainerManager$1 as ContainerManager, RENDERER_TYPE, Renderer$1 as Renderer, RendererManager$1 as RendererManager, Renderer$3 as RendererSystem };