@galacean/engine 1.1.3 → 1.1.6

package/dist/browser.js

@@ -24592,7 +24592,21 @@
             mesh.uploadData(false);
         };
         _proto._initMesh = function _initMesh(engine) {
-            this._mesh = this._createPlane(engine);
+            var mesh = this._mesh = this._createPlane(engine);
+            engine.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+                var _class = function _class() {
+                    return ContentRestorer.call(this, mesh);
+                };
+                _inherits$2(_class, ContentRestorer);
+                var _proto = _class.prototype;
+                _proto.restoreContent = function restoreContent() {
+                    mesh.setPositions(mesh.getPositions());
+                    mesh.setUVs(mesh.getUVs());
+                    mesh.setIndices(mesh.getIndices());
+                    mesh.uploadData(false);
+                };
+                return _class;
+            }(ContentRestorer))());
             this._mesh._addReferCount(1);
         };
         _proto._initMaterial = function _initMaterial(engine) {
@@ -38300,11 +38314,199 @@
         ]);
         return FileHeader;
     }();
+    var ComponentMap = {
+        Transform: Transform,
+        Animator: Animator,
+        DirectLight: DirectLight,
+        Camera: exports.Camera,
+        MeshRenderer: MeshRenderer,
+        ParticleRenderer: ParticleRenderer,
+        PointLight: PointLight,
+        SpotLight: SpotLight,
+        Script: Script,
+        SpriteMask: SpriteMask,
+        SpriteRenderer: SpriteRenderer,
+        TextRenderer: TextRenderer
+    };
+    exports.InterpolableValueType = void 0;
+    (function(InterpolableValueType) {
+        InterpolableValueType[InterpolableValueType["Float"] = 0] = "Float";
+        InterpolableValueType[InterpolableValueType["FloatArray"] = 1] = "FloatArray";
+        InterpolableValueType[InterpolableValueType["Vector2"] = 2] = "Vector2";
+        InterpolableValueType[InterpolableValueType["Vector3"] = 3] = "Vector3";
+        InterpolableValueType[InterpolableValueType["Vector4"] = 4] = "Vector4";
+        InterpolableValueType[InterpolableValueType["Quaternion"] = 5] = "Quaternion";
+        InterpolableValueType[InterpolableValueType["Color"] = 6] = "Color";
+        InterpolableValueType[InterpolableValueType["Array"] = 7] = "Array";
+        InterpolableValueType[InterpolableValueType["Boolean"] = 8] = "Boolean";
+        InterpolableValueType[InterpolableValueType["Rect"] = 9] = "Rect";
+        InterpolableValueType[InterpolableValueType["ReferResource"] = 10] = "ReferResource";
+    })(exports.InterpolableValueType || (exports.InterpolableValueType = {}));
+    exports.AnimationClipDecoder = /*#__PURE__*/ function() {
+        var AnimationClipDecoder = function AnimationClipDecoder() {};
+        AnimationClipDecoder.decode = function decode(engine, bufferReader) {
+            return new Promise(function(resolve) {
+                var name = bufferReader.nextStr();
+                var clip = new AnimationClip(name);
+                var eventsLen = bufferReader.nextUint16();
+                for(var i = 0; i < eventsLen; ++i){
+                    var event = new AnimationEvent();
+                    event.time = bufferReader.nextFloat32();
+                    event.functionName = bufferReader.nextStr();
+                    event.parameter = JSON.parse(bufferReader.nextStr()).val;
+                    clip.addEvent(event);
+                }
+                var curveBindingsLen = bufferReader.nextUint16();
+                for(var i1 = 0; i1 < curveBindingsLen; ++i1){
+                    var relativePath = bufferReader.nextStr();
+                    var componentStr = bufferReader.nextStr();
+                    var componentType = ComponentMap[componentStr];
+                    var property = bufferReader.nextStr();
+                    var curve = void 0;
+                    var interpolation = bufferReader.nextUint8();
+                    var keysLen = bufferReader.nextUint16();
+                    var curveType = bufferReader.nextStr();
+                    switch(curveType){
+                        case "AnimationFloatCurve":
+                            {
+                                curve = new exports.AnimationFloatCurve();
+                                curve.interpolation = interpolation;
+                                for(var j = 0; j < keysLen; ++j){
+                                    var keyframe = new Keyframe();
+                                    keyframe.time = bufferReader.nextFloat32();
+                                    keyframe.value = bufferReader.nextFloat32();
+                                    keyframe.inTangent = bufferReader.nextFloat32();
+                                    keyframe.outTangent = bufferReader.nextFloat32();
+                                    curve.addKey(keyframe);
+                                }
+                                break;
+                            }
+                        case "AnimationArrayCurve":
+                            {
+                                curve = new exports.AnimationArrayCurve();
+                                curve.interpolation = interpolation;
+                                for(var j1 = 0; j1 < keysLen; ++j1){
+                                    var keyframe1 = new Keyframe();
+                                    keyframe1.time = bufferReader.nextFloat32();
+                                    var len = bufferReader.nextUint16();
+                                    keyframe1.value = Array.from(bufferReader.nextFloat32Array(len));
+                                    keyframe1.inTangent = Array.from(bufferReader.nextFloat32Array(len));
+                                    keyframe1.outTangent = Array.from(bufferReader.nextFloat32Array(len));
+                                    curve.addKey(keyframe1);
+                                }
+                                break;
+                            }
+                        case "AnimationFloatArrayCurve":
+                            {
+                                curve = new exports.AnimationFloatArrayCurve();
+                                curve.interpolation = interpolation;
+                                for(var j2 = 0; j2 < keysLen; ++j2){
+                                    var keyframe2 = new Keyframe();
+                                    keyframe2.time = bufferReader.nextFloat32();
+                                    var len1 = bufferReader.nextUint16();
+                                    keyframe2.value = bufferReader.nextFloat32Array(len1);
+                                    keyframe2.inTangent = Array.from(bufferReader.nextFloat32Array(len1));
+                                    keyframe2.outTangent = Array.from(bufferReader.nextFloat32Array(len1));
+                                    curve.addKey(keyframe2);
+                                }
+                                break;
+                            }
+                        case "AnimationVector2Curve":
+                            {
+                                curve = new exports.AnimationVector2Curve();
+                                curve.interpolation = interpolation;
+                                for(var j3 = 0; j3 < keysLen; ++j3){
+                                    var keyframe3 = new Keyframe();
+                                    keyframe3.time = bufferReader.nextFloat32();
+                                    keyframe3.value = new Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    keyframe3.inTangent = new Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    keyframe3.outTangent = new Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    curve.addKey(keyframe3);
+                                }
+                                break;
+                            }
+                        case "AnimationVector3Curve":
+                            {
+                                curve = new exports.AnimationVector3Curve();
+                                curve.interpolation = interpolation;
+                                for(var j4 = 0; j4 < keysLen; ++j4){
+                                    var keyframe4 = new Keyframe();
+                                    keyframe4.time = bufferReader.nextFloat32();
+                                    keyframe4.value = new Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    keyframe4.inTangent = new Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    keyframe4.outTangent = new Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    curve.addKey(keyframe4);
+                                }
+                                break;
+                            }
+                        case "AnimationVector4Curve":
+                            {
+                                curve = new exports.AnimationVector4Curve();
+                                curve.interpolation = interpolation;
+                                var keyframe5 = new Keyframe();
+                                keyframe5.time = bufferReader.nextFloat32();
+                                keyframe5.value = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe5.inTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe5.outTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                curve.addKey(keyframe5);
+                                break;
+                            }
+                        case "AnimationColorCurve":
+                            {
+                                curve = new exports.AnimationColorCurve();
+                                curve.interpolation = interpolation;
+                                for(var j5 = 0; j5 < keysLen; ++j5){
+                                    var keyframe6 = new Keyframe();
+                                    keyframe6.time = bufferReader.nextFloat32();
+                                    keyframe6.value = new Color$1(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    keyframe6.inTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    keyframe6.outTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    curve.addKey(keyframe6);
+                                }
+                                break;
+                            }
+                        case "AnimationQuaternionCurve":
+                            {
+                                curve = new exports.AnimationQuaternionCurve();
+                                curve.interpolation = interpolation;
+                                for(var j6 = 0; j6 < keysLen; ++j6){
+                                    var keyframe7 = new Keyframe();
+                                    keyframe7.time = bufferReader.nextFloat32();
+                                    keyframe7.value = new Quaternion(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    keyframe7.inTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    keyframe7.outTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                    curve.addKey(keyframe7);
+                                }
+                                break;
+                            }
+                        case "AnimationRefCurve":
+                            {
+                                curve = new exports.AnimationRefCurve();
+                                curve.interpolation = interpolation;
+                                for(var j7 = 0; j7 < keysLen; ++j7){
+                                    var keyframe8 = new Keyframe();
+                                    keyframe8.time = bufferReader.nextFloat32();
+                                    keyframe8.value = JSON.parse(bufferReader.nextStr());
+                                    curve.addKey(keyframe8);
+                                }
+                                break;
+                            }
+                    }
+                    clip.addCurveBinding(relativePath, componentType, property, curve);
+                }
+                resolve(clip);
+            });
+        };
+        return AnimationClipDecoder;
+    }();
+    exports.AnimationClipDecoder = __decorate([
+        decoder("AnimationClip")
+    ], exports.AnimationClipDecoder);
     exports.MeshDecoder = /*#__PURE__*/ function() {
         var MeshDecoder = function MeshDecoder() {};
-        MeshDecoder.decode = function decode(engine, bufferReader) {
+        MeshDecoder.decode = function decode(engine, bufferReader, restoredMesh) {
             return new Promise(function(resolve) {
-                var modelMesh = new ModelMesh(engine);
+                var modelMesh = restoredMesh || new ModelMesh(engine);
                 var jsonDataString = bufferReader.nextStr();
                 var encodedMeshData = JSON.parse(jsonDataString);
                 // @ts-ignore Vector3 is not compatible with {x: number, y: number, z: number}.
@@ -38433,80 +38635,22 @@
         }
         return array;
     }
-    exports.Texture2DDecoder = /*#__PURE__*/ function() {
-        var Texture2DDecoder = function Texture2DDecoder() {};
-        Texture2DDecoder.decode = function decode(engine, bufferReader) {
-            return new Promise(function(resolve, reject) {
-                var objectId = bufferReader.nextStr();
-                var mipmap = !!bufferReader.nextUint8();
-                var filterMode = bufferReader.nextUint8();
-                var anisoLevel = bufferReader.nextUint8();
-                var wrapModeU = bufferReader.nextUint8();
-                var wrapModeV = bufferReader.nextUint8();
-                var format = bufferReader.nextUint8();
-                var width = bufferReader.nextUint16();
-                var height = bufferReader.nextUint16();
-                var isPixelBuffer = bufferReader.nextUint8();
-                var mipCount = bufferReader.nextUint8();
-                var imagesData = bufferReader.nextImagesData(mipCount);
-                var texture2D = new Texture2D(engine, width, height, format, mipmap);
-                texture2D.filterMode = filterMode;
-                texture2D.anisoLevel = anisoLevel;
-                texture2D.wrapModeU = wrapModeU;
-                texture2D.wrapModeV = wrapModeV;
-                if (isPixelBuffer) {
-                    var pixelBuffer = imagesData[0];
-                    texture2D.setPixelBuffer(pixelBuffer);
-                    if (mipmap) {
-                        texture2D.generateMipmaps();
-                        for(var i = 1; i < mipCount; i++){
-                            var pixelBuffer1 = imagesData[i];
-                            texture2D.setPixelBuffer(pixelBuffer1, i);
-                        }
-                    }
-                    // @ts-ignore
-                    engine.resourceManager._objectPool[objectId] = texture2D;
-                    resolve(texture2D);
-                } else {
-                    var blob = new window.Blob([
-                        imagesData[0]
-                    ]);
-                    var img = new Image();
-                    img.onload = function() {
-                        texture2D.setImageSource(img);
-                        var completedCount = 0;
-                        var onComplete = function onComplete() {
-                            completedCount++;
-                            if (completedCount >= mipCount) {
-                                resolve(texture2D);
-                            }
-                        };
-                        onComplete();
-                        if (mipmap) {
-                            var _loop = function _loop(i) {
-                                var blob = new window.Blob([
-                                    imagesData[i]
-                                ]);
-                                var img = new Image();
-                                img.onload = function() {
-                                    texture2D.setImageSource(img, i);
-                                    onComplete();
-                                };
-                                img.src = URL.createObjectURL(blob);
-                            };
-                            texture2D.generateMipmaps();
-                            for(var i = 1; i < mipCount; i++)_loop(i);
-                        }
-                    };
-                    img.src = URL.createObjectURL(blob);
+    var PrefabParser = /*#__PURE__*/ function() {
+        var PrefabParser = function PrefabParser() {};
+        PrefabParser.parseChildren = function parseChildren(entitiesConfig, entities, parentId) {
+            var children = entitiesConfig.get(parentId).children;
+            if (children && children.length > 0) {
+                var parent = entities.get(parentId);
+                for(var i = 0; i < children.length; i++){
+                    var childId = children[i];
+                    var entity = entities.get(childId);
+                    parent.addChild(entity);
+                    this.parseChildren(entitiesConfig, entities, childId);
                 }
-            });
+            }
         };
-        return Texture2DDecoder;
+        return PrefabParser;
     }();
-    exports.Texture2DDecoder = __decorate([
-        decoder("Texture2D")
-    ], exports.Texture2DDecoder);
     function _is_native_reflect_construct() {
         if (typeof Reflect === "undefined" || !Reflect.construct) return false;
         if (Reflect.construct.sham) return false;
@@ -38681,215 +38825,146 @@
     (function() {
         ReflectionParser.customParseComponentHandles = new Map();
     })();
-    var PrefabParser = /*#__PURE__*/ function() {
-        var PrefabParser = function PrefabParser() {};
-        PrefabParser.parseChildren = function parseChildren(entitiesConfig, entities, parentId) {
-            var children = entitiesConfig.get(parentId).children;
-            if (children && children.length > 0) {
-                var parent = entities.get(parentId);
-                for(var i = 0; i < children.length; i++){
-                    var childId = children[i];
-                    var entity = entities.get(childId);
-                    parent.addChild(entity);
-                    this.parseChildren(entitiesConfig, entities, childId);
-                }
-            }
-        };
-        return PrefabParser;
-    }();
-    var ComponentMap = {
-        Transform: Transform,
-        Animator: Animator,
-        DirectLight: DirectLight,
-        Camera: exports.Camera,
-        MeshRenderer: MeshRenderer,
-        ParticleRenderer: ParticleRenderer,
-        PointLight: PointLight,
-        SpotLight: SpotLight,
-        Script: Script,
-        SpriteMask: SpriteMask,
-        SpriteRenderer: SpriteRenderer,
-        TextRenderer: TextRenderer
-    };
-    exports.InterpolableValueType = void 0;
-    (function(InterpolableValueType) {
-        InterpolableValueType[InterpolableValueType["Float"] = 0] = "Float";
-        InterpolableValueType[InterpolableValueType["FloatArray"] = 1] = "FloatArray";
-        InterpolableValueType[InterpolableValueType["Vector2"] = 2] = "Vector2";
-        InterpolableValueType[InterpolableValueType["Vector3"] = 3] = "Vector3";
-        InterpolableValueType[InterpolableValueType["Vector4"] = 4] = "Vector4";
-        InterpolableValueType[InterpolableValueType["Quaternion"] = 5] = "Quaternion";
-        InterpolableValueType[InterpolableValueType["Color"] = 6] = "Color";
-        InterpolableValueType[InterpolableValueType["Array"] = 7] = "Array";
-        InterpolableValueType[InterpolableValueType["Boolean"] = 8] = "Boolean";
-        InterpolableValueType[InterpolableValueType["Rect"] = 9] = "Rect";
-        InterpolableValueType[InterpolableValueType["ReferResource"] = 10] = "ReferResource";
-    })(exports.InterpolableValueType || (exports.InterpolableValueType = {}));
-    exports.AnimationClipDecoder = /*#__PURE__*/ function() {
-        var AnimationClipDecoder = function AnimationClipDecoder() {};
-        AnimationClipDecoder.decode = function decode(engine, bufferReader) {
-            return new Promise(function(resolve) {
-                var name = bufferReader.nextStr();
-                var clip = new AnimationClip(name);
-                var eventsLen = bufferReader.nextUint16();
-                for(var i = 0; i < eventsLen; ++i){
-                    var event = new AnimationEvent();
-                    event.time = bufferReader.nextFloat32();
-                    event.functionName = bufferReader.nextStr();
-                    event.parameter = JSON.parse(bufferReader.nextStr()).val;
-                    clip.addEvent(event);
-                }
-                var curveBindingsLen = bufferReader.nextUint16();
-                for(var i1 = 0; i1 < curveBindingsLen; ++i1){
-                    var relativePath = bufferReader.nextStr();
-                    var componentStr = bufferReader.nextStr();
-                    var componentType = ComponentMap[componentStr];
-                    var property = bufferReader.nextStr();
-                    var curve = void 0;
-                    var interpolation = bufferReader.nextUint8();
-                    var keysLen = bufferReader.nextUint16();
-                    var curveType = bufferReader.nextStr();
-                    switch(curveType){
-                        case "AnimationFloatCurve":
-                            {
-                                curve = new exports.AnimationFloatCurve();
-                                curve.interpolation = interpolation;
-                                for(var j = 0; j < keysLen; ++j){
-                                    var keyframe = new Keyframe();
-                                    keyframe.time = bufferReader.nextFloat32();
-                                    keyframe.value = bufferReader.nextFloat32();
-                                    keyframe.inTangent = bufferReader.nextFloat32();
-                                    keyframe.outTangent = bufferReader.nextFloat32();
-                                    curve.addKey(keyframe);
-                                }
-                                break;
-                            }
-                        case "AnimationArrayCurve":
-                            {
-                                curve = new exports.AnimationArrayCurve();
-                                curve.interpolation = interpolation;
-                                for(var j1 = 0; j1 < keysLen; ++j1){
-                                    var keyframe1 = new Keyframe();
-                                    keyframe1.time = bufferReader.nextFloat32();
-                                    var len = bufferReader.nextUint16();
-                                    keyframe1.value = Array.from(bufferReader.nextFloat32Array(len));
-                                    keyframe1.inTangent = Array.from(bufferReader.nextFloat32Array(len));
-                                    keyframe1.outTangent = Array.from(bufferReader.nextFloat32Array(len));
-                                    curve.addKey(keyframe1);
-                                }
-                                break;
-                            }
-                        case "AnimationFloatArrayCurve":
-                            {
-                                curve = new exports.AnimationFloatArrayCurve();
-                                curve.interpolation = interpolation;
-                                for(var j2 = 0; j2 < keysLen; ++j2){
-                                    var keyframe2 = new Keyframe();
-                                    keyframe2.time = bufferReader.nextFloat32();
-                                    var len1 = bufferReader.nextUint16();
-                                    keyframe2.value = bufferReader.nextFloat32Array(len1);
-                                    keyframe2.inTangent = Array.from(bufferReader.nextFloat32Array(len1));
-                                    keyframe2.outTangent = Array.from(bufferReader.nextFloat32Array(len1));
-                                    curve.addKey(keyframe2);
-                                }
-                                break;
-                            }
-                        case "AnimationVector2Curve":
-                            {
-                                curve = new exports.AnimationVector2Curve();
-                                curve.interpolation = interpolation;
-                                for(var j3 = 0; j3 < keysLen; ++j3){
-                                    var keyframe3 = new Keyframe();
-                                    keyframe3.time = bufferReader.nextFloat32();
-                                    keyframe3.value = new Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    keyframe3.inTangent = new Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    keyframe3.outTangent = new Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    curve.addKey(keyframe3);
-                                }
-                                break;
-                            }
-                        case "AnimationVector3Curve":
-                            {
-                                curve = new exports.AnimationVector3Curve();
-                                curve.interpolation = interpolation;
-                                for(var j4 = 0; j4 < keysLen; ++j4){
-                                    var keyframe4 = new Keyframe();
-                                    keyframe4.time = bufferReader.nextFloat32();
-                                    keyframe4.value = new Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    keyframe4.inTangent = new Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    keyframe4.outTangent = new Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    curve.addKey(keyframe4);
-                                }
-                                break;
-                            }
-                        case "AnimationVector4Curve":
-                            {
-                                curve = new exports.AnimationVector4Curve();
-                                curve.interpolation = interpolation;
-                                var keyframe5 = new Keyframe();
-                                keyframe5.time = bufferReader.nextFloat32();
-                                keyframe5.value = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe5.inTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe5.outTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                curve.addKey(keyframe5);
-                                break;
-                            }
-                        case "AnimationColorCurve":
-                            {
-                                curve = new exports.AnimationColorCurve();
-                                curve.interpolation = interpolation;
-                                for(var j5 = 0; j5 < keysLen; ++j5){
-                                    var keyframe6 = new Keyframe();
-                                    keyframe6.time = bufferReader.nextFloat32();
-                                    keyframe6.value = new Color$1(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    keyframe6.inTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    keyframe6.outTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    curve.addKey(keyframe6);
-                                }
-                                break;
-                            }
-                        case "AnimationQuaternionCurve":
-                            {
-                                curve = new exports.AnimationQuaternionCurve();
-                                curve.interpolation = interpolation;
-                                for(var j6 = 0; j6 < keysLen; ++j6){
-                                    var keyframe7 = new Keyframe();
-                                    keyframe7.time = bufferReader.nextFloat32();
-                                    keyframe7.value = new Quaternion(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    keyframe7.inTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    keyframe7.outTangent = new Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                    curve.addKey(keyframe7);
-                                }
-                                break;
-                            }
-                        case "AnimationRefCurve":
-                            {
-                                curve = new exports.AnimationRefCurve();
-                                curve.interpolation = interpolation;
-                                for(var j7 = 0; j7 < keysLen; ++j7){
-                                    var keyframe8 = new Keyframe();
-                                    keyframe8.time = bufferReader.nextFloat32();
-                                    keyframe8.value = JSON.parse(bufferReader.nextStr());
-                                    curve.addKey(keyframe8);
-                                }
-                                break;
-                            }
+    exports.Texture2DDecoder = /*#__PURE__*/ function() {
+        var Texture2DDecoder = function Texture2DDecoder() {};
+        Texture2DDecoder.decode = function decode(engine, bufferReader, restoredTexture) {
+            return new Promise(function(resolve, reject) {
+                var objectId = bufferReader.nextStr();
+                var mipmap = !!bufferReader.nextUint8();
+                var filterMode = bufferReader.nextUint8();
+                var anisoLevel = bufferReader.nextUint8();
+                var wrapModeU = bufferReader.nextUint8();
+                var wrapModeV = bufferReader.nextUint8();
+                var format = bufferReader.nextUint8();
+                var width = bufferReader.nextUint16();
+                var height = bufferReader.nextUint16();
+                var isPixelBuffer = bufferReader.nextUint8();
+                var mipCount = bufferReader.nextUint8();
+                var imagesData = bufferReader.nextImagesData(mipCount);
+                var texture2D = restoredTexture || new Texture2D(engine, width, height, format, mipmap);
+                texture2D.filterMode = filterMode;
+                texture2D.anisoLevel = anisoLevel;
+                texture2D.wrapModeU = wrapModeU;
+                texture2D.wrapModeV = wrapModeV;
+                if (isPixelBuffer) {
+                    var pixelBuffer = imagesData[0];
+                    texture2D.setPixelBuffer(pixelBuffer);
+                    if (mipmap) {
+                        texture2D.generateMipmaps();
+                        for(var i = 1; i < mipCount; i++){
+                            var pixelBuffer1 = imagesData[i];
+                            texture2D.setPixelBuffer(pixelBuffer1, i);
+                        }
                     }
-                    clip.addCurveBinding(relativePath, componentType, property, curve);
+                    // @ts-ignore
+                    engine.resourceManager._objectPool[objectId] = texture2D;
+                    resolve(texture2D);
+                } else {
+                    var blob = new window.Blob([
+                        imagesData[0]
+                    ]);
+                    var img = new Image();
+                    img.onload = function() {
+                        texture2D.setImageSource(img);
+                        var completedCount = 0;
+                        var onComplete = function onComplete() {
+                            completedCount++;
+                            if (completedCount >= mipCount) {
+                                resolve(texture2D);
+                            }
+                        };
+                        onComplete();
+                        if (mipmap) {
+                            var _loop = function _loop(i) {
+                                var blob = new window.Blob([
+                                    imagesData[i]
+                                ]);
+                                var img = new Image();
+                                img.onload = function() {
+                                    texture2D.setImageSource(img, i);
+                                    onComplete();
+                                };
+                                img.src = URL.createObjectURL(blob);
+                            };
+                            texture2D.generateMipmaps();
+                            for(var i = 1; i < mipCount; i++)_loop(i);
+                        }
+                    };
+                    img.src = URL.createObjectURL(blob);
                 }
-                resolve(clip);
             });
         };
-        return AnimationClipDecoder;
+        return Texture2DDecoder;
     }();
-    exports.AnimationClipDecoder = __decorate([
-        decoder("AnimationClip")
-    ], exports.AnimationClipDecoder);
-    exports.SpecularMode = void 0;
-    (function(SpecularMode) {
-        SpecularMode["Sky"] = "Sky";
-        SpecularMode["Custom"] = "Custom";
-    })(exports.SpecularMode || (exports.SpecularMode = {}));
+    exports.Texture2DDecoder = __decorate([
+        decoder("Texture2D")
+    ], exports.Texture2DDecoder);
+    exports.EditorTextureLoader = /*#__PURE__*/ function(Loader1) {
+        var EditorTextureLoader = function EditorTextureLoader() {
+            return Loader1.apply(this, arguments);
+        };
+        _inherits(EditorTextureLoader, Loader1);
+        var _proto = EditorTextureLoader.prototype;
+        _proto.load = function load(item, resourceManager) {
+            var _this = this;
+            return new AssetPromise(function(resolve, reject) {
+                var request = _this.request;
+                request(item.url, _extends({}, item, {
+                    type: "arraybuffer"
+                })).then(function(data) {
+                    decode(data, resourceManager.engine).then(function(texture) {
+                        resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+                            var _class = function _class() {
+                                return ContentRestorer.apply(this, arguments);
+                            };
+                            _inherits(_class, ContentRestorer);
+                            var _proto = _class.prototype;
+                            _proto.restoreContent = function restoreContent() {
+                                return request(item.url, _extends({}, item, {
+                                    type: "arraybuffer"
+                                })).then(function(data) {
+                                    return decode(data, resourceManager.engine, texture);
+                                });
+                            };
+                            return _class;
+                        }(ContentRestorer))(texture));
+                        resolve(texture);
+                    });
+                }).catch(reject);
+            });
+        };
+        return EditorTextureLoader;
+    }(Loader);
+    exports.EditorTextureLoader = __decorate([
+        resourceLoader("EditorTexture2D", [
+            "prefab"
+        ], true)
+    ], exports.EditorTextureLoader);
+    exports.MeshLoader = /*#__PURE__*/ function(Loader1) {
+        var MeshLoader = function MeshLoader() {
+            return Loader1.apply(this, arguments);
+        };
+        _inherits(MeshLoader, Loader1);
+        var _proto = MeshLoader.prototype;
+        _proto.load = function load(item, resourceManager) {
+            var _this = this;
+            return new AssetPromise(function(resolve, reject) {
+                _this.request(item.url, {
+                    type: "arraybuffer"
+                }).then(function(data) {
+                    decode(data, resourceManager.engine).then(function(mesh) {
+                        resolve(mesh);
+                    });
+                }).catch(reject);
+            });
+        };
+        return MeshLoader;
+    }(Loader);
+    exports.MeshLoader = __decorate([
+        resourceLoader("Mesh", [
+            "prefab"
+        ], true)
+    ], exports.MeshLoader);
     function _array_like_to_array(arr, len) {
         if (len == null || len > arr.length) len = arr.length;
         for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -39036,65 +39111,24 @@
         };
         return SceneParser;
     }();
-    exports.MeshLoader = /*#__PURE__*/ function(Loader1) {
-        var MeshLoader = function MeshLoader() {
-            return Loader1.apply(this, arguments);
-        };
-        _inherits(MeshLoader, Loader1);
-        var _proto = MeshLoader.prototype;
-        _proto.load = function load(item, resourceManager) {
-            var _this = this;
-            return new AssetPromise(function(resolve, reject) {
-                _this.request(item.url, {
-                    type: "arraybuffer"
-                }).then(function(data) {
-                    decode(data, resourceManager.engine).then(function(mesh) {
-                        resolve(mesh);
-                    });
-                }).catch(reject);
-            });
-        };
-        return MeshLoader;
-    }(Loader);
-    exports.MeshLoader = __decorate([
-        resourceLoader("Mesh", [
-            "prefab"
-        ], true)
-    ], exports.MeshLoader);
-    exports.EditorTextureLoader = /*#__PURE__*/ function(Loader1) {
-        var EditorTextureLoader = function EditorTextureLoader() {
-            return Loader1.apply(this, arguments);
-        };
-        _inherits(EditorTextureLoader, Loader1);
-        var _proto = EditorTextureLoader.prototype;
-        _proto.load = function load(item, resourceManager) {
-            var _this = this;
-            return new AssetPromise(function(resolve, reject) {
-                _this.request(item.url, {
-                    type: "arraybuffer"
-                }).then(function(data) {
-                    decode(data, resourceManager.engine).then(function(texture) {
-                        resolve(texture);
-                    });
-                }).catch(reject);
-            });
-        };
-        return EditorTextureLoader;
-    }(Loader);
-    exports.EditorTextureLoader = __decorate([
-        resourceLoader("EditorTexture2D", [
-            "prefab"
-        ], true)
-    ], exports.EditorTextureLoader);
+    exports.SpecularMode = void 0;
+    (function(SpecularMode) {
+        SpecularMode["Sky"] = "Sky";
+        SpecularMode["Custom"] = "Custom";
+    })(exports.SpecularMode || (exports.SpecularMode = {}));
     /**
      * Decode engine binary resource.
      * @param arrayBuffer - array buffer of decode binary file
      * @param engine - engine
      * @returns
      */ function decode(arrayBuffer, engine) {
+        for(var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+            args[_key - 2] = arguments[_key];
+        }
+        var _decoderMap_header_type;
         var header = FileHeader.decode(arrayBuffer);
         var bufferReader = new BufferReader(new Uint8Array(arrayBuffer), header.headerLength, header.dataLength);
-        return decoderMap[header.type].decode(engine, bufferReader).then(function(object) {
+        return (_decoderMap_header_type = decoderMap[header.type]).decode.apply(_decoderMap_header_type, [].concat(engine, bufferReader, args)).then(function(object) {
             object.name = header.name;
             return object;
         });
@@ -39258,39 +39292,42 @@
         ], false)
     ], BufferLoader);
     var EnvLoader = /*#__PURE__*/ function(Loader1) {
-        var EnvLoader = function EnvLoader() {
+        var EnvLoader1 = function EnvLoader1() {
             return Loader1.apply(this, arguments);
         };
-        _inherits(EnvLoader, Loader1);
-        var _proto = EnvLoader.prototype;
+        _inherits(EnvLoader1, Loader1);
+        var _proto = EnvLoader1.prototype;
         _proto.load = function load(item, resourceManager) {
             var _this = this;
             return new AssetPromise(function(resolve, reject) {
-                _this.request(item.url, {
+                var engine = resourceManager.engine;
+                var request = _this.request;
+                request(item.url, _extends({}, item, {
                     type: "arraybuffer"
-                }).then(function(arraybuffer) {
-                    var _this;
-                    var shArray = new Float32Array(arraybuffer, 0, 27);
-                    var shByteLength = 27 * 4;
-                    var size = (_this = new Uint16Array(arraybuffer, shByteLength, 1)) == null ? void 0 : _this[0];
-                    var engine = resourceManager.engine;
-                    var texture = new TextureCube(engine, size);
-                    texture.filterMode = exports.TextureFilterMode.Trilinear;
-                    var mipmapCount = texture.mipmapCount;
-                    var offset = shByteLength + 2;
-                    for(var mipLevel = 0; mipLevel < mipmapCount; mipLevel++){
-                        var mipSize = size >> mipLevel;
-                        for(var face = 0; face < 6; face++){
-                            var dataSize = mipSize * mipSize * 4;
-                            var data = new Uint8Array(arraybuffer, offset, dataSize);
-                            offset += dataSize;
-                            texture.setPixelBuffer(exports.TextureCubeFace.PositiveX + face, data, mipLevel);
-                        }
-                    }
+                })).then(function(arraybuffer) {
+                    var texture = EnvLoader._setTextureByBuffer(engine, arraybuffer);
+                    engine.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+                        var _class = function _class() {
+                            return ContentRestorer.apply(this, arguments);
+                        };
+                        _inherits(_class, ContentRestorer);
+                        var _proto = _class.prototype;
+                        _proto.restoreContent = function restoreContent() {
+                            return new AssetPromise(function(resolve, reject) {
+                                request(item.url, _extends({}, item, {
+                                    type: "arraybuffer"
+                                })).then(function(buffer) {
+                                    EnvLoader._setTextureByBuffer(engine, buffer, texture);
+                                    resolve(texture);
+                                }).catch(reject);
+                            });
+                        };
+                        return _class;
+                    }(ContentRestorer))(texture));
                     var ambientLight = new AmbientLight(engine);
                     var sh = new SphericalHarmonics3();
                     ambientLight.diffuseMode = exports.DiffuseMode.SphericalHarmonics;
-                    sh.copyFromArray(shArray);
+                    sh.copyFromArray(new Float32Array(arraybuffer, 0, 27));
                     ambientLight.diffuseSphericalHarmonics = sh;
                     ambientLight.specularTexture = texture;
                     ambientLight.specularTextureDecodeRGBM = true;
@@ -39300,7 +39337,28 @@
                 });
             });
         };
-        return EnvLoader;
+        /**
+       * @internal
+       */ EnvLoader1._setTextureByBuffer = function _setTextureByBuffer(engine, buffer, texture) {
+            var _this;
+            var shByteLength = 27 * 4;
+            var size = (_this = new Uint16Array(buffer, shByteLength, 1)) == null ? void 0 : _this[0];
+            texture || (texture = new TextureCube(engine, size));
+            texture.filterMode = exports.TextureFilterMode.Trilinear;
+            var mipmapCount = texture.mipmapCount;
+            var offset = shByteLength + 2;
+            for(var mipLevel = 0; mipLevel < mipmapCount; mipLevel++){
+                var mipSize = size >> mipLevel;
+                for(var face = 0; face < 6; face++){
+                    var dataSize = mipSize * mipSize * 4;
+                    var data = new Uint8Array(buffer, offset, dataSize);
+                    offset += dataSize;
+                    texture.setPixelBuffer(exports.TextureCubeFace.PositiveX + face, data, mipLevel);
+                }
+            }
+            return texture;
+        };
+        return EnvLoader1;
     }(Loader);
     EnvLoader = __decorate([
         resourceLoader(exports.AssetType.Env, [
@@ -40010,28 +40068,29 @@
                 BIN: 0x004e4942
             };
             var dataView = new DataView(originBuffer);
-            // read header
+            // Read header
             var header = {
                 magic: dataView.getUint32(0, true),
                 version: dataView.getUint32(UINT32_LENGTH, true),
                 length: dataView.getUint32(2 * UINT32_LENGTH, true)
             };
+            // Return the original buffer if it is not a glb
             if (header.magic !== GLB_HEADER_MAGIC) {
                 return {
                     originBuffer: originBuffer
                 };
             }
-            // read main data
+            // Read main data
             var chunkLength = dataView.getUint32(GLB_HEADER_LENGTH, true);
             var chunkType = dataView.getUint32(GLB_HEADER_LENGTH + UINT32_LENGTH, true);
-            // read glTF json
+            // Read glTF json
             if (chunkType !== GLB_CHUNK_TYPES.JSON) {
                 console.error("Invalid glb chunk type. Expected 0x4E4F534A, found 0x" + chunkType.toString(16));
                 return null;
             }
             var glTFData = new Uint8Array(originBuffer, GLB_HEADER_LENGTH + 2 * UINT32_LENGTH, chunkLength);
             var glTF = JSON.parse(Utils.decodeText(glTFData));
-            // read all buffers
+            // Read all buffers
             var buffers = [];
             var byteOffset = GLB_HEADER_LENGTH + 2 * UINT32_LENGTH + chunkLength;
             var restoreGLBBufferSlice = context.contentRestorer.glbBufferSlices;
@@ -40912,13 +40971,39 @@
         /**
        * @internal
        */ _proto.load = function load(item, resourceManager) {
-            return this.request(item.url, {
-                type: "arraybuffer"
-            }).then(function(buffer) {
-                return exports.KTX2Loader._parseBuffer(new Uint8Array(buffer), resourceManager.engine, item.params).then(function(param) {
-                    var engine = param.engine, result = param.result, targetFormat = param.targetFormat, params = param.params;
-                    return exports.KTX2Loader._createTextureByBuffer(engine, result, targetFormat, params);
-                });
+            var _this = this;
+            return new AssetPromise(function(resolve, reject) {
+                var request = _this.request;
+                request(item.url, _extends({}, item, {
+                    type: "arraybuffer"
+                })).then(function(buffer) {
+                    return exports.KTX2Loader._parseBuffer(new Uint8Array(buffer), resourceManager.engine, item.params).then(function(param) {
+                        var engine = param.engine, result = param.result, targetFormat = param.targetFormat, params = param.params;
+                        return exports.KTX2Loader._createTextureByBuffer(engine, result, targetFormat, params);
+                    }).then(function(texture) {
+                        resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+                            var _class = function _class() {
+                                return ContentRestorer.apply(this, arguments);
+                            };
+                            _inherits(_class, ContentRestorer);
+                            var _proto = _class.prototype;
+                            _proto.restoreContent = function restoreContent() {
+                                return new AssetPromise(function(resolve, reject) {
+                                    request(item.url, _extends({}, item, {
+                                        type: "arraybuffer"
+                                    })).then(function(buffer) {
+                                        return exports.KTX2Loader._parseBuffer(new Uint8Array(buffer), resourceManager.engine, item.params).then(function(param) {
+                                            var engine = param.engine, result = param.result, targetFormat = param.targetFormat, params = param.params;
+                                            return exports.KTX2Loader._createTextureByBuffer(engine, result, targetFormat, params, texture);
+                                        });
+                                    }).then(resolve).catch(reject);
+                                });
+                            };
+                            return _class;
+                        }(ContentRestorer))(texture));
+                        resolve(texture);
+                    });
+                }).catch(reject);
             });
         };
         /**
@@ -40957,7 +41042,7 @@
                 };
             });
         };
-        /** @internal */ KTX2Loader1._createTextureByBuffer = function _createTextureByBuffer(engine, transcodeResult, targetFormat, params) {
+        /** @internal */ KTX2Loader1._createTextureByBuffer = function _createTextureByBuffer(engine, transcodeResult, targetFormat, params, restoredTexture) {
             var width = transcodeResult.width, height = transcodeResult.height, faces = transcodeResult.faces;
             var faceCount = faces.length;
             var mipmaps = faces[0];
@@ -40965,13 +41050,13 @@
             var engineFormat = this._getEngineTextureFormat(targetFormat, transcodeResult);
             var texture;
             if (faceCount !== 6) {
-                texture = new Texture2D(engine, width, height, engineFormat, mipmap);
+                texture = restoredTexture || new Texture2D(engine, width, height, engineFormat, mipmap);
                 for(var mipLevel = 0; mipLevel < mipmaps.length; mipLevel++){
                     var data = mipmaps[mipLevel].data;
                     texture.setPixelBuffer(data, mipLevel);
                 }
             } else {
-                texture = new TextureCube(engine, height, engineFormat, mipmap);
+                texture = restoredTexture || new TextureCube(engine, height, engineFormat, mipmap);
                 for(var i = 0; i < faces.length; i++){
                     var faceData = faces[i];
                     for(var mipLevel1 = 0; mipLevel1 < mipmaps.length; mipLevel1++){
@@ -41446,8 +41531,13 @@
                 type: "arraybuffer"
             };
             return request(url, requestConfig).then(function(buffer) {
-                restoreBufferRequests.push(new BufferRequestInfo(url, requestConfig));
-                return GLTFUtils.parseGLB(context, buffer);
+                var _parseResult;
+                var parseResult = GLTFUtils.parseGLB(context, buffer);
+                // If the buffer is a GLB file, we need to restore the buffer data
+                if ((_parseResult = parseResult) == null ? void 0 : _parseResult.glTF) {
+                    restoreBufferRequests.push(new BufferRequestInfo(url, requestConfig));
+                }
+                return parseResult;
             }).then(function(result) {
                 var _result;
                 if ((_result = result) == null ? void 0 : _result.glTF) {
@@ -42466,23 +42556,48 @@
             var _this = this;
             return new AssetPromise(function(resolve, reject) {
                 var engine = resourceManager.engine;
-                _this.request(item.url, {
+                var request = _this.request;
+                _this.request(item.url, _extends({}, item, {
                     type: "arraybuffer"
-                }).then(function(buffer) {
-                    var uint8Array = new Uint8Array(buffer);
-                    var _HDRLoader__parseHeader = HDRLoader._parseHeader(uint8Array), width = _HDRLoader__parseHeader.width, height = _HDRLoader__parseHeader.height, dataPosition = _HDRLoader__parseHeader.dataPosition;
-                    var pixels = HDRLoader._readPixels(uint8Array.subarray(dataPosition), width, height);
-                    var cubeSize = height >> 1;
-                    var cubeMapData = HDRLoader._convertToCubemap(pixels, width, height, cubeSize);
-                    var texture = new TextureCube(engine, cubeSize);
-                    for(var faceIndex = 0; faceIndex < 6; faceIndex++){
-                        texture.setPixelBuffer(exports.TextureCubeFace.PositiveX + faceIndex, cubeMapData[faceIndex], 0);
-                    }
-                    texture.generateMipmaps();
+                })).then(function(buffer) {
+                    var texture = HDRLoader._setTextureByBuffer(engine, buffer);
+                    engine.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+                        var _class = function _class() {
+                            return ContentRestorer.apply(this, arguments);
+                        };
+                        _inherits(_class, ContentRestorer);
+                        var _proto = _class.prototype;
+                        _proto.restoreContent = function restoreContent() {
+                            return new AssetPromise(function(resolve, reject) {
+                                request(item.url, _extends({}, item, {
+                                    type: "arraybuffer"
+                                })).then(function(buffer) {
+                                    HDRLoader._setTextureByBuffer(engine, buffer, texture);
+                                    resolve(texture);
+                                }).catch(reject);
+                            });
+                        };
+                        return _class;
+                    }(ContentRestorer))(texture));
                     resolve(texture);
                 }).catch(reject);
             });
         };
+        /**
+       * @internal
+       */ HDRLoader1._setTextureByBuffer = function _setTextureByBuffer(engine, buffer, texture) {
+            var bufferArray = new Uint8Array(buffer);
+            var _HDRLoader__parseHeader = HDRLoader._parseHeader(bufferArray), width = _HDRLoader__parseHeader.width, height = _HDRLoader__parseHeader.height, dataPosition = _HDRLoader__parseHeader.dataPosition;
+            var cubeSize = height >> 1;
+            texture || (texture = new TextureCube(engine, cubeSize));
+            var pixels = HDRLoader._readPixels(bufferArray.subarray(dataPosition), width, height);
+            var cubeMapData = HDRLoader._convertToCubemap(pixels, width, height, cubeSize);
+            for(var faceIndex = 0; faceIndex < 6; faceIndex++){
+                texture.setPixelBuffer(exports.TextureCubeFace.PositiveX + faceIndex, cubeMapData[faceIndex], 0);
+            }
+            texture.generateMipmaps();
+            return texture;
+        };
         HDRLoader1._convertToCubemap = function _convertToCubemap(pixels, inputWidth, inputHeight, size) {
             if (!pixels) {
                 throw "ConvertPanoramaToCubemap: input cannot be null";
@@ -43015,7 +43130,8 @@
         _proto.load = function load(item, resourceManager) {
             var _this = this;
             return new AssetPromise(function(resolve, reject) {
-                _this.request(item.url, _extends({}, item, {
+                var request = _this.request;
+                request(item.url, _extends({}, item, {
                     type: "arraybuffer"
                 })).then(function(bin) {
                     var parsedData = parseSingleKTX(bin);
@@ -43026,6 +43142,32 @@
                         var _mipmaps_miplevel = mipmaps[miplevel], width1 = _mipmaps_miplevel.width, height1 = _mipmaps_miplevel.height, data = _mipmaps_miplevel.data;
                         texture.setPixelBuffer(data, miplevel, 0, 0, width1, height1);
                     }
+                    resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+                        var _class = function _class() {
+                            return ContentRestorer.apply(this, arguments);
+                        };
+                        _inherits(_class, ContentRestorer);
+                        var _proto = _class.prototype;
+                        _proto.restoreContent = function restoreContent() {
+                            var _this = this;
+                            return new AssetPromise(function(resolve, reject) {
+                                request(item.url, _extends({}, item, {
+                                    type: "arraybuffer"
+                                })).then(function(bin) {
+                                    var mipmaps = parseSingleKTX(bin).mipmaps;
+                                    var texture = _this.resource;
+                                    for(var miplevel = 0; miplevel < mipmaps.length; miplevel++){
+                                        var _mipmaps_miplevel = mipmaps[miplevel], width = _mipmaps_miplevel.width, height = _mipmaps_miplevel.height, data = _mipmaps_miplevel.data;
+                                        texture.setPixelBuffer(data, miplevel, 0, 0, width, height);
+                                    }
+                                    resolve(texture);
+                                }).catch(function(e) {
+                                    reject(e);
+                                });
+                            });
+                        };
+                        return _class;
+                    }(ContentRestorer))(texture));
                     resolve(texture);
                 }).catch(function(e) {
                     reject(e);
@@ -43129,11 +43271,32 @@
         _proto.load = function load(item, resourceManager) {
             var _this = this;
             return new AssetPromise(function(resolve, reject) {
-                _this.request(item.url, _extends({}, item, {
+                var request = _this.request;
+                var engine = resourceManager.engine;
+                request(item.url, _extends({}, item, {
                     type: "arraybuffer"
                 })).then(function(data) {
-                    return decode(data, resourceManager.engine);
+                    return decode(data, engine);
                 }).then(function(mesh) {
+                    resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+                        var _class = function _class() {
+                            return ContentRestorer.apply(this, arguments);
+                        };
+                        _inherits(_class, ContentRestorer);
+                        var _proto = _class.prototype;
+                        _proto.restoreContent = function restoreContent() {
+                            return new AssetPromise(function(resolve, reject) {
+                                request(item.url, _extends({}, item, {
+                                    type: "arraybuffer"
+                                })).then(function(data) {
+                                    return decode(data, engine, mesh);
+                                }).then(function(mesh) {
+                                    resolve(mesh);
+                                }).catch(reject);
+                            });
+                        };
+                        return _class;
+                    }(ContentRestorer))(mesh));
                     resolve(mesh);
                 }).catch(reject);
             });
@@ -44106,7 +44269,7 @@
     ], GALACEAN_animation_event);
 
     //@ts-ignore
-    var version = "1.1.3";
+    var version = "1.1.6";
     console.log("Galacean engine version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);