@galacean/engine-loader 1.1.3 → 1.1.6

package/dist/miniprogram.js

@@ -285,11 +285,201 @@ var FileHeader = /*#__PURE__*/ function() {
     return FileHeader;
 }();
 
+var ComponentMap = {
+    Transform: miniprogram.Transform,
+    Animator: miniprogram.Animator,
+    DirectLight: miniprogram.DirectLight,
+    Camera: miniprogram.Camera,
+    MeshRenderer: miniprogram.MeshRenderer,
+    ParticleRenderer: miniprogram.ParticleRenderer,
+    PointLight: miniprogram.PointLight,
+    SpotLight: miniprogram.SpotLight,
+    Script: miniprogram.Script,
+    SpriteMask: miniprogram.SpriteMask,
+    SpriteRenderer: miniprogram.SpriteRenderer,
+    TextRenderer: miniprogram.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() {
+    function AnimationClipDecoder() {}
+    AnimationClipDecoder.decode = function decode(engine, bufferReader) {
+        return new Promise(function(resolve) {
+            var name = bufferReader.nextStr();
+            var clip = new miniprogram.AnimationClip(name);
+            var eventsLen = bufferReader.nextUint16();
+            for(var i = 0; i < eventsLen; ++i){
+                var event = new miniprogram.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 miniprogram.AnimationFloatCurve();
+                            curve.interpolation = interpolation;
+                            for(var j = 0; j < keysLen; ++j){
+                                var keyframe = new miniprogram.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 miniprogram.AnimationArrayCurve();
+                            curve.interpolation = interpolation;
+                            for(var j1 = 0; j1 < keysLen; ++j1){
+                                var keyframe1 = new miniprogram.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 miniprogram.AnimationFloatArrayCurve();
+                            curve.interpolation = interpolation;
+                            for(var j2 = 0; j2 < keysLen; ++j2){
+                                var keyframe2 = new miniprogram.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 miniprogram.AnimationVector2Curve();
+                            curve.interpolation = interpolation;
+                            for(var j3 = 0; j3 < keysLen; ++j3){
+                                var keyframe3 = new miniprogram.Keyframe();
+                                keyframe3.time = bufferReader.nextFloat32();
+                                keyframe3.value = new miniprogram$1.Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe3.inTangent = new miniprogram$1.Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe3.outTangent = new miniprogram$1.Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                curve.addKey(keyframe3);
+                            }
+                            break;
+                        }
+                    case "AnimationVector3Curve":
+                        {
+                            curve = new miniprogram.AnimationVector3Curve();
+                            curve.interpolation = interpolation;
+                            for(var j4 = 0; j4 < keysLen; ++j4){
+                                var keyframe4 = new miniprogram.Keyframe();
+                                keyframe4.time = bufferReader.nextFloat32();
+                                keyframe4.value = new miniprogram$1.Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe4.inTangent = new miniprogram$1.Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe4.outTangent = new miniprogram$1.Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                curve.addKey(keyframe4);
+                            }
+                            break;
+                        }
+                    case "AnimationVector4Curve":
+                        {
+                            curve = new miniprogram.AnimationVector4Curve();
+                            curve.interpolation = interpolation;
+                            var keyframe5 = new miniprogram.Keyframe();
+                            keyframe5.time = bufferReader.nextFloat32();
+                            keyframe5.value = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                            keyframe5.inTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                            keyframe5.outTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                            curve.addKey(keyframe5);
+                            break;
+                        }
+                    case "AnimationColorCurve":
+                        {
+                            curve = new miniprogram.AnimationColorCurve();
+                            curve.interpolation = interpolation;
+                            for(var j5 = 0; j5 < keysLen; ++j5){
+                                var keyframe6 = new miniprogram.Keyframe();
+                                keyframe6.time = bufferReader.nextFloat32();
+                                keyframe6.value = new miniprogram$1.Color(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe6.inTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe6.outTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                curve.addKey(keyframe6);
+                            }
+                            break;
+                        }
+                    case "AnimationQuaternionCurve":
+                        {
+                            curve = new miniprogram.AnimationQuaternionCurve();
+                            curve.interpolation = interpolation;
+                            for(var j6 = 0; j6 < keysLen; ++j6){
+                                var keyframe7 = new miniprogram.Keyframe();
+                                keyframe7.time = bufferReader.nextFloat32();
+                                keyframe7.value = new miniprogram$1.Quaternion(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe7.inTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                keyframe7.outTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
+                                curve.addKey(keyframe7);
+                            }
+                            break;
+                        }
+                    case "AnimationRefCurve":
+                        {
+                            curve = new miniprogram.AnimationRefCurve();
+                            curve.interpolation = interpolation;
+                            for(var j7 = 0; j7 < keysLen; ++j7){
+                                var keyframe8 = new miniprogram.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() {
     function MeshDecoder() {}
-    MeshDecoder.decode = function decode(engine, bufferReader) {
+    MeshDecoder.decode = function decode(engine, bufferReader, restoredMesh) {
         return new Promise(function(resolve) {
-            var modelMesh = new miniprogram.ModelMesh(engine);
+            var modelMesh = restoredMesh || new miniprogram.ModelMesh(engine);
             var jsonDataString = bufferReader.nextStr();
             var encodedMeshData = JSON.parse(jsonDataString);
             // @ts-ignore Vector3 is not compatible with {x: number, y: number, z: number}.
@@ -419,80 +609,22 @@ function float32ArrayToVector2(float32Array, vertexCount) {
     return array;
 }
 
-exports.Texture2DDecoder = /*#__PURE__*/ function() {
-    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 miniprogram.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 engineMiniprogramAdapter.window.Blob([
-                    imagesData[0]
-                ]);
-                var img = new engineMiniprogramAdapter.Image();
-                img.onload = function() {
-                    texture2D.setImageSource(img);
-                    var completedCount = 0;
-                    var onComplete = function() {
-                        completedCount++;
-                        if (completedCount >= mipCount) {
-                            resolve(texture2D);
-                        }
-                    };
-                    onComplete();
-                    if (mipmap) {
-                        var _loop = function(i) {
-                            var blob = new engineMiniprogramAdapter.window.Blob([
-                                imagesData[i]
-                            ]);
-                            var img = new engineMiniprogramAdapter.Image();
-                            img.onload = function() {
-                                texture2D.setImageSource(img, i);
-                                onComplete();
-                            };
-                            img.src = engineMiniprogramAdapter.URL.createObjectURL(blob);
-                        };
-                        texture2D.generateMipmaps();
-                        for(var i = 1; i < mipCount; i++)_loop(i);
-                    }
-                };
-                img.src = engineMiniprogramAdapter.URL.createObjectURL(blob);
+var PrefabParser = /*#__PURE__*/ function() {
+    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;
@@ -656,236 +788,166 @@ var ReflectionParser = /*#__PURE__*/ function() {
             return Promise.resolve(entity);
         }
     };
-    ReflectionParser.registerCustomParseComponent = function registerCustomParseComponent(componentType, handle) {
-        this.customParseComponentHandles[componentType] = handle;
-    };
-    ReflectionParser._isClass = function _isClass(value) {
-        return value["class"] != undefined;
-    };
-    ReflectionParser._isAssetRef = function _isAssetRef(value) {
-        return value["refId"] != undefined;
-    };
-    ReflectionParser._isEntityRef = function _isEntityRef(value) {
-        return value["entityId"] != undefined;
-    };
-    return ReflectionParser;
-}();
-(function() {
-    ReflectionParser.customParseComponentHandles = new Map();
-})();
-
-var PrefabParser = /*#__PURE__*/ function() {
-    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: miniprogram.Transform,
-    Animator: miniprogram.Animator,
-    DirectLight: miniprogram.DirectLight,
-    Camera: miniprogram.Camera,
-    MeshRenderer: miniprogram.MeshRenderer,
-    ParticleRenderer: miniprogram.ParticleRenderer,
-    PointLight: miniprogram.PointLight,
-    SpotLight: miniprogram.SpotLight,
-    Script: miniprogram.Script,
-    SpriteMask: miniprogram.SpriteMask,
-    SpriteRenderer: miniprogram.SpriteRenderer,
-    TextRenderer: miniprogram.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() {
-    function AnimationClipDecoder() {}
-    AnimationClipDecoder.decode = function decode(engine, bufferReader) {
-        return new Promise(function(resolve) {
-            var name = bufferReader.nextStr();
-            var clip = new miniprogram.AnimationClip(name);
-            var eventsLen = bufferReader.nextUint16();
-            for(var i = 0; i < eventsLen; ++i){
-                var event = new miniprogram.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 miniprogram.AnimationFloatCurve();
-                            curve.interpolation = interpolation;
-                            for(var j = 0; j < keysLen; ++j){
-                                var keyframe = new miniprogram.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 miniprogram.AnimationArrayCurve();
-                            curve.interpolation = interpolation;
-                            for(var j1 = 0; j1 < keysLen; ++j1){
-                                var keyframe1 = new miniprogram.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 miniprogram.AnimationFloatArrayCurve();
-                            curve.interpolation = interpolation;
-                            for(var j2 = 0; j2 < keysLen; ++j2){
-                                var keyframe2 = new miniprogram.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 miniprogram.AnimationVector2Curve();
-                            curve.interpolation = interpolation;
-                            for(var j3 = 0; j3 < keysLen; ++j3){
-                                var keyframe3 = new miniprogram.Keyframe();
-                                keyframe3.time = bufferReader.nextFloat32();
-                                keyframe3.value = new miniprogram$1.Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe3.inTangent = new miniprogram$1.Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe3.outTangent = new miniprogram$1.Vector2(bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                curve.addKey(keyframe3);
-                            }
-                            break;
-                        }
-                    case "AnimationVector3Curve":
-                        {
-                            curve = new miniprogram.AnimationVector3Curve();
-                            curve.interpolation = interpolation;
-                            for(var j4 = 0; j4 < keysLen; ++j4){
-                                var keyframe4 = new miniprogram.Keyframe();
-                                keyframe4.time = bufferReader.nextFloat32();
-                                keyframe4.value = new miniprogram$1.Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe4.inTangent = new miniprogram$1.Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe4.outTangent = new miniprogram$1.Vector3(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                curve.addKey(keyframe4);
-                            }
-                            break;
-                        }
-                    case "AnimationVector4Curve":
-                        {
-                            curve = new miniprogram.AnimationVector4Curve();
-                            curve.interpolation = interpolation;
-                            var keyframe5 = new miniprogram.Keyframe();
-                            keyframe5.time = bufferReader.nextFloat32();
-                            keyframe5.value = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                            keyframe5.inTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                            keyframe5.outTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                            curve.addKey(keyframe5);
-                            break;
-                        }
-                    case "AnimationColorCurve":
-                        {
-                            curve = new miniprogram.AnimationColorCurve();
-                            curve.interpolation = interpolation;
-                            for(var j5 = 0; j5 < keysLen; ++j5){
-                                var keyframe6 = new miniprogram.Keyframe();
-                                keyframe6.time = bufferReader.nextFloat32();
-                                keyframe6.value = new miniprogram$1.Color(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe6.inTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe6.outTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                curve.addKey(keyframe6);
-                            }
-                            break;
-                        }
-                    case "AnimationQuaternionCurve":
-                        {
-                            curve = new miniprogram.AnimationQuaternionCurve();
-                            curve.interpolation = interpolation;
-                            for(var j6 = 0; j6 < keysLen; ++j6){
-                                var keyframe7 = new miniprogram.Keyframe();
-                                keyframe7.time = bufferReader.nextFloat32();
-                                keyframe7.value = new miniprogram$1.Quaternion(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe7.inTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                keyframe7.outTangent = new miniprogram$1.Vector4(bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32(), bufferReader.nextFloat32());
-                                curve.addKey(keyframe7);
-                            }
-                            break;
-                        }
-                    case "AnimationRefCurve":
-                        {
-                            curve = new miniprogram.AnimationRefCurve();
-                            curve.interpolation = interpolation;
-                            for(var j7 = 0; j7 < keysLen; ++j7){
-                                var keyframe8 = new miniprogram.Keyframe();
-                                keyframe8.time = bufferReader.nextFloat32();
-                                keyframe8.value = JSON.parse(bufferReader.nextStr());
-                                curve.addKey(keyframe8);
-                            }
-                            break;
-                        }
+    ReflectionParser.registerCustomParseComponent = function registerCustomParseComponent(componentType, handle) {
+        this.customParseComponentHandles[componentType] = handle;
+    };
+    ReflectionParser._isClass = function _isClass(value) {
+        return value["class"] != undefined;
+    };
+    ReflectionParser._isAssetRef = function _isAssetRef(value) {
+        return value["refId"] != undefined;
+    };
+    ReflectionParser._isEntityRef = function _isEntityRef(value) {
+        return value["entityId"] != undefined;
+    };
+    return ReflectionParser;
+}();
+(function() {
+    ReflectionParser.customParseComponentHandles = new Map();
+})();
+
+exports.Texture2DDecoder = /*#__PURE__*/ function() {
+    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 miniprogram.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 engineMiniprogramAdapter.window.Blob([
+                    imagesData[0]
+                ]);
+                var img = new engineMiniprogramAdapter.Image();
+                img.onload = function() {
+                    texture2D.setImageSource(img);
+                    var completedCount = 0;
+                    var onComplete = function() {
+                        completedCount++;
+                        if (completedCount >= mipCount) {
+                            resolve(texture2D);
+                        }
+                    };
+                    onComplete();
+                    if (mipmap) {
+                        var _loop = function(i) {
+                            var blob = new engineMiniprogramAdapter.window.Blob([
+                                imagesData[i]
+                            ]);
+                            var img = new engineMiniprogramAdapter.Image();
+                            img.onload = function() {
+                                texture2D.setImageSource(img, i);
+                                onComplete();
+                            };
+                            img.src = engineMiniprogramAdapter.URL.createObjectURL(blob);
+                        };
+                        texture2D.generateMipmaps();
+                        for(var i = 1; i < mipCount; i++)_loop(i);
+                    }
+                };
+                img.src = engineMiniprogramAdapter.URL.createObjectURL(blob);
             }
-            resolve(clip);
         });
     };
-    return AnimationClipDecoder;
+    return Texture2DDecoder;
 }();
-exports.AnimationClipDecoder = __decorate([
-    decoder("AnimationClip")
-], exports.AnimationClipDecoder);
+exports.Texture2DDecoder = __decorate([
+    decoder("Texture2D")
+], exports.Texture2DDecoder);
 
-exports.SpecularMode = void 0;
-(function(SpecularMode) {
-    SpecularMode["Sky"] = "Sky";
-    SpecularMode["Custom"] = "Custom";
-})(exports.SpecularMode || (exports.SpecularMode = {}));
+exports.EditorTextureLoader = /*#__PURE__*/ function(Loader1) {
+    _inherits(EditorTextureLoader, Loader1);
+    function EditorTextureLoader() {
+        return Loader1.apply(this, arguments);
+    }
+    var _proto = EditorTextureLoader.prototype;
+    _proto.load = function load(item, resourceManager) {
+        var _this = this;
+        return new miniprogram.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) {
+                        _inherits(_class, ContentRestorer);
+                        function _class() {
+                            return ContentRestorer.apply(this, arguments);
+                        }
+                        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;
+                    }(miniprogram.ContentRestorer))(texture));
+                    resolve(texture);
+                });
+            }).catch(reject);
+        });
+    };
+    return EditorTextureLoader;
+}(miniprogram.Loader);
+exports.EditorTextureLoader = __decorate([
+    miniprogram.resourceLoader("EditorTexture2D", [
+        "prefab"
+    ], true)
+], exports.EditorTextureLoader);
+
+exports.MeshLoader = /*#__PURE__*/ function(Loader1) {
+    _inherits(MeshLoader, Loader1);
+    function MeshLoader() {
+        return Loader1.apply(this, arguments);
+    }
+    var _proto = MeshLoader.prototype;
+    _proto.load = function load(item, resourceManager) {
+        var _this = this;
+        return new miniprogram.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;
+}(miniprogram.Loader);
+exports.MeshLoader = __decorate([
+    miniprogram.resourceLoader("Mesh", [
+        "prefab"
+    ], true)
+], exports.MeshLoader);
 
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -1042,57 +1104,11 @@ var SceneParserContext = /*#__PURE__*/ function() {
     return SceneParser;
 }();
 
-exports.MeshLoader = /*#__PURE__*/ function(Loader1) {
-    _inherits(MeshLoader, Loader1);
-    function MeshLoader() {
-        return Loader1.apply(this, arguments);
-    }
-    var _proto = MeshLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        var _this = this;
-        return new miniprogram.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;
-}(miniprogram.Loader);
-exports.MeshLoader = __decorate([
-    miniprogram.resourceLoader("Mesh", [
-        "prefab"
-    ], true)
-], exports.MeshLoader);
-
-exports.EditorTextureLoader = /*#__PURE__*/ function(Loader1) {
-    _inherits(EditorTextureLoader, Loader1);
-    function EditorTextureLoader() {
-        return Loader1.apply(this, arguments);
-    }
-    var _proto = EditorTextureLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        var _this = this;
-        return new miniprogram.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;
-}(miniprogram.Loader);
-exports.EditorTextureLoader = __decorate([
-    miniprogram.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.
@@ -1100,9 +1116,13 @@ exports.EditorTextureLoader = __decorate([
  * @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;
     });
@@ -1270,39 +1290,42 @@ BufferLoader = __decorate([
 ], BufferLoader);
 
 var EnvLoader = /*#__PURE__*/ function(Loader1) {
-    _inherits(EnvLoader, Loader1);
-    function EnvLoader() {
+    _inherits(EnvLoader1, Loader1);
+    function EnvLoader1() {
         return Loader1.apply(this, arguments);
     }
-    var _proto = EnvLoader.prototype;
+    var _proto = EnvLoader1.prototype;
     _proto.load = function load(item, resourceManager) {
         var _this = this;
         return new miniprogram.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 miniprogram.TextureCube(engine, size);
-                texture.filterMode = miniprogram.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(miniprogram.TextureCubeFace.PositiveX + face, data, mipLevel);
+            })).then(function(arraybuffer) {
+                var texture = EnvLoader._setTextureByBuffer(engine, arraybuffer);
+                engine.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+                    _inherits(_class, ContentRestorer);
+                    function _class() {
+                        return ContentRestorer.apply(this, arguments);
                     }
-                }
+                    var _proto = _class.prototype;
+                    _proto.restoreContent = function restoreContent() {
+                        return new miniprogram.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;
+                }(miniprogram.ContentRestorer))(texture));
                 var ambientLight = new miniprogram.AmbientLight(engine);
                 var sh = new miniprogram$1.SphericalHarmonics3();
                 ambientLight.diffuseMode = miniprogram.DiffuseMode.SphericalHarmonics;
-                sh.copyFromArray(shArray);
+                sh.copyFromArray(new Float32Array(arraybuffer, 0, 27));
                 ambientLight.diffuseSphericalHarmonics = sh;
                 ambientLight.specularTexture = texture;
                 ambientLight.specularTextureDecodeRGBM = true;
@@ -1312,7 +1335,28 @@ var EnvLoader = /*#__PURE__*/ function(Loader1) {
             });
         });
     };
-    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 miniprogram.TextureCube(engine, size));
+        texture.filterMode = miniprogram.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(miniprogram.TextureCubeFace.PositiveX + face, data, mipLevel);
+            }
+        }
+        return texture;
+    };
+    return EnvLoader1;
 }(miniprogram.Loader);
 EnvLoader = __decorate([
     miniprogram.resourceLoader(miniprogram.AssetType.Env, [
@@ -2032,28 +2076,29 @@ function registerGLTFParser(pipeline) {
             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(miniprogram.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;
@@ -2944,13 +2989,39 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
     /**
    * @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 miniprogram.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) {
+                        _inherits(_class, ContentRestorer);
+                        function _class() {
+                            return ContentRestorer.apply(this, arguments);
+                        }
+                        var _proto = _class.prototype;
+                        _proto.restoreContent = function restoreContent() {
+                            return new miniprogram.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;
+                    }(miniprogram.ContentRestorer))(texture));
+                    resolve(texture);
+                });
+            }).catch(reject);
         });
     };
     /**
@@ -2989,7 +3060,7 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
             };
         });
     };
-    /** @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];
@@ -2997,13 +3068,13 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
         var engineFormat = this._getEngineTextureFormat(targetFormat, transcodeResult);
         var texture;
         if (faceCount !== 6) {
-            texture = new miniprogram.Texture2D(engine, width, height, engineFormat, mipmap);
+            texture = restoredTexture || new miniprogram.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 miniprogram.TextureCube(engine, height, engineFormat, mipmap);
+            texture = restoredTexture || new miniprogram.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++){
@@ -3482,8 +3553,13 @@ exports.GLTFSchemaParser = /*#__PURE__*/ function(GLTFParser1) {
             type: "arraybuffer"
         };
         return miniprogram.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) {
@@ -4515,23 +4591,48 @@ var HDRLoader = (_HDRLoader = /*#__PURE__*/ function(Loader1) {
         var _this = this;
         return new miniprogram.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 miniprogram.TextureCube(engine, cubeSize);
-                for(var faceIndex = 0; faceIndex < 6; faceIndex++){
-                    texture.setPixelBuffer(miniprogram.TextureCubeFace.PositiveX + faceIndex, cubeMapData[faceIndex], 0);
-                }
-                texture.generateMipmaps();
+            })).then(function(buffer) {
+                var texture = HDRLoader._setTextureByBuffer(engine, buffer);
+                engine.resourceManager.addContentRestorer(new /*#__PURE__*/ (function(ContentRestorer) {
+                    _inherits(_class, ContentRestorer);
+                    function _class() {
+                        return ContentRestorer.apply(this, arguments);
+                    }
+                    var _proto = _class.prototype;
+                    _proto.restoreContent = function restoreContent() {
+                        return new miniprogram.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;
+                }(miniprogram.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 miniprogram.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(miniprogram.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";
@@ -5069,7 +5170,8 @@ var KTXLoader = /*#__PURE__*/ function(Loader1) {
     _proto.load = function load(item, resourceManager) {
         var _this = this;
         return new miniprogram.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);
@@ -5080,6 +5182,32 @@ var KTXLoader = /*#__PURE__*/ function(Loader1) {
                     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) {
+                    _inherits(_class, ContentRestorer);
+                    function _class() {
+                        return ContentRestorer.apply(this, arguments);
+                    }
+                    var _proto = _class.prototype;
+                    _proto.restoreContent = function restoreContent() {
+                        var _this = this;
+                        return new miniprogram.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;
+                }(miniprogram.ContentRestorer))(texture));
                 resolve(texture);
             }).catch(function(e) {
                 reject(e);
@@ -5186,11 +5314,32 @@ var MeshLoader = /*#__PURE__*/ function(Loader1) {
     _proto.load = function load(item, resourceManager) {
         var _this = this;
         return new miniprogram.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) {
+                    _inherits(_class, ContentRestorer);
+                    function _class() {
+                        return ContentRestorer.apply(this, arguments);
+                    }
+                    var _proto = _class.prototype;
+                    _proto.restoreContent = function restoreContent() {
+                        return new miniprogram.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;
+                }(miniprogram.ContentRestorer))(mesh));
                 resolve(mesh);
             }).catch(reject);
         });