@galacean/engine-loader 1.0.0 → 1.0.1

package/dist/miniprogram.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var miniprogram = require('@galacean/engine-core/dist/miniprogram');
 var engineMiniprogramAdapter = require('@galacean/engine-miniprogram-adapter');
 var miniprogram$1 = require('@galacean/engine-math/dist/miniprogram');
-var miniprogram$2 = require('@galacean/engine-draco/dist/miniprogram');
-var miniprogram$3 = require('@galacean/engine-rhi-webgl/dist/miniprogram');
+var miniprogram$2 = require('@galacean/engine-rhi-webgl/dist/miniprogram');
+var miniprogram$3 = require('@galacean/engine-draco/dist/miniprogram');
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -91,10 +91,10 @@ function __generator(thisArg, body) {
     }
 }
 
-var AnimatorControllerLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(AnimatorControllerLoader, Loader);
+var AnimatorControllerLoader = /*#__PURE__*/ function(Loader1) {
+    _inherits(AnimatorControllerLoader, Loader1);
     function AnimatorControllerLoader() {
-        return Loader.apply(this, arguments);
+        return Loader1.apply(this, arguments);
     }
     var _proto = AnimatorControllerLoader.prototype;
     _proto.load = function load(item, resourceManager) {
@@ -115,13 +115,17 @@ var AnimatorControllerLoader = /*#__PURE__*/ function(Loader) {
                         var states = stateMachineData.states;
                         var stateMachine = layer.stateMachine = new miniprogram.AnimatorStateMachine();
                         states.forEach(function(stateData, stateIndex) {
-                            var name = stateData.name, speed = stateData.speed, wrapMode = stateData.wrapMode, clipStartNormalizedTime = stateData.clipStartNormalizedTime, clipEndNormalizedTime = stateData.clipEndNormalizedTime, isDefaultState = stateData.isDefaultState, clipData = stateData.clip;
+                            var name = stateData.name, speed = stateData.speed, wrapMode = stateData.wrapMode, clipStartNormalizedTime = stateData.clipStartNormalizedTime, clipEndNormalizedTime = stateData.clipEndNormalizedTime, isDefaultState = stateData.isDefaultState, clipData = stateData.clip, scripts = stateData.scripts;
                             var state = stateMachine.addState(name);
                             isDefaultState && (stateMachine.defaultState = state);
                             state.speed = speed;
                             state.wrapMode = wrapMode;
                             state.clipStartTime = clipStartNormalizedTime;
                             state.clipEndTime = clipEndNormalizedTime;
+                            var scriptsObject = JSON.parse(scripts);
+                            scriptsObject == null ? void 0 : scriptsObject.forEach(function(script) {
+                                state.addStateMachineScript(miniprogram.Loader.getClass(script));
+                            });
                             if (clipData) {
                                 promises.push(new Promise(function(resolve) {
                                     //@ts-ignore
@@ -219,7 +223,8 @@ var EnvLoader = /*#__PURE__*/ function(Loader) {
                 var shArray = new Float32Array(arraybuffer, 0, 27);
                 var shByteLength = 27 * 4;
                 var size = (_ref = new Uint16Array(arraybuffer, shByteLength, 1)) == null ? void 0 : _ref[0];
-                var texture = new miniprogram.TextureCube(resourceManager.engine, size);
+                var engine = resourceManager.engine;
+                var texture = new miniprogram.TextureCube(engine, size);
                 texture.filterMode = miniprogram.TextureFilterMode.Trilinear;
                 var mipmapCount = texture.mipmapCount;
                 var offset = shByteLength + 2;
@@ -232,7 +237,7 @@ var EnvLoader = /*#__PURE__*/ function(Loader) {
                         texture.setPixelBuffer(miniprogram.TextureCubeFace.PositiveX + face, data, mipLevel);
                     }
                 }
-                var ambientLight = new miniprogram.AmbientLight();
+                var ambientLight = new miniprogram.AmbientLight(engine);
                 var sh = new miniprogram$1.SphericalHarmonics3();
                 ambientLight.diffuseMode = miniprogram.DiffuseMode.SphericalHarmonics;
                 sh.copyFromArray(shArray);
@@ -342,52 +347,205 @@ FontLoader = __decorate([
     ], false)
 ], FontLoader);
 
+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];
+
+    return arr2;
+}
+
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+
+        var i = 0;
+
+        return function() {
+            if (i >= o.length) return { done: true };
+
+            return { done: false, value: o[i++] };
+        };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
 /**
  * @internal
- */ var ParserContext = /*#__PURE__*/ function() {
-    function ParserContext(url) {
-        this.hasSkinned = false;
-        /** chain asset promise */ this.chainPromises = [];
-        this.accessorBufferCache = {};
-        this.texturesPromiseInfo = new PromiseInfo();
-        this.materialsPromiseInfo = new PromiseInfo();
-        this.meshesPromiseInfo = new PromiseInfo();
-        this.animationClipsPromiseInfo = new PromiseInfo();
-        this.defaultSceneRootPromiseInfo = new PromiseInfo();
-        this.masterPromiseInfo = new PromiseInfo();
-        this.promiseMap = {};
-        var promiseMap = this.promiseMap;
-        promiseMap["" + url + "?q=textures"] = this._initPromiseInfo(this.texturesPromiseInfo);
-        promiseMap["" + url + "?q=materials"] = this._initPromiseInfo(this.materialsPromiseInfo);
-        promiseMap["" + url + "?q=meshes"] = this._initPromiseInfo(this.meshesPromiseInfo);
-        promiseMap["" + url + "?q=animations"] = this._initPromiseInfo(this.animationClipsPromiseInfo);
-        promiseMap["" + url + "?q=defaultSceneRoot"] = this._initPromiseInfo(this.defaultSceneRootPromiseInfo);
-        promiseMap["" + url] = this._initPromiseInfo(this.masterPromiseInfo);
+ */ var GLTFContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
+    _inherits(GLTFContentRestorer, ContentRestorer);
+    function GLTFContentRestorer() {
+        var _this;
+        _this = ContentRestorer.apply(this, arguments) || this;
+        _this.bufferRequests = [];
+        _this.glbBufferSlices = [];
+        _this.bufferTextures = [];
+        _this.meshes = [];
+        return _this;
     }
-    var _proto = ParserContext.prototype;
-    _proto._initPromiseInfo = function _initPromiseInfo(promiseInfo) {
-        var promise = new miniprogram.AssetPromise(function(resolve, reject, setProgress, onCancel) {
-            promiseInfo.resolve = resolve;
-            promiseInfo.reject = reject;
-            promiseInfo.setProgress = setProgress;
-            promiseInfo.onCancel = onCancel;
+    var _proto = GLTFContentRestorer.prototype;
+    _proto.restoreContent = function restoreContent() {
+        var _this = this;
+        return new miniprogram.AssetPromise(function(resolve, reject) {
+            Promise.all(_this.bufferRequests.map(function(bufferRequestInfo) {
+                return miniprogram.request(bufferRequestInfo.url, bufferRequestInfo.config);
+            })).then(function(buffers) {
+                // Buffer parse
+                if (_this.isGLB) {
+                    var glbBufferSlice = _this.glbBufferSlices;
+                    var bigBuffer = buffers[0];
+                    var bufferCount = glbBufferSlice.length;
+                    buffers.length = bufferCount;
+                    for(var i = 0; i < bufferCount; i++){
+                        var slice = glbBufferSlice[i];
+                        buffers[i] = bigBuffer.slice(slice.x, slice.x + slice.y);
+                    }
+                }
+                // Restore texture
+                miniprogram.AssetPromise.all(_this.bufferTextures.map(function(textureRestoreInfo) {
+                    var bufferView = textureRestoreInfo.bufferView;
+                    var buffer = buffers[bufferView.buffer];
+                    var _bufferView_byteOffset;
+                    var bufferData = new Uint8Array(buffer, (_bufferView_byteOffset = bufferView.byteOffset) != null ? _bufferView_byteOffset : 0, bufferView.byteLength);
+                    return GLTFUtils.loadImageBuffer(bufferData, textureRestoreInfo.mimeType).then(function(image) {
+                        textureRestoreInfo.texture.setImageSource(image);
+                        textureRestoreInfo.texture.generateMipmaps();
+                    });
+                })).then(function() {
+                    // Restore mesh
+                    for(var _iterator = _create_for_of_iterator_helper_loose(_this.meshes), _step; !(_step = _iterator()).done;){
+                        var meshInfo = _step.value;
+                        var mesh = meshInfo.mesh;
+                        for(var _iterator1 = _create_for_of_iterator_helper_loose(meshInfo.vertexBuffers), _step1; !(_step1 = _iterator1()).done;){
+                            var bufferRestoreInfo = _step1.value;
+                            var vertexData = _this._getBufferData(buffers, bufferRestoreInfo.data);
+                            bufferRestoreInfo.buffer.setData(vertexData);
+                        }
+                        if (meshInfo.indexBuffer) {
+                            var indexData = _this._getBufferData(buffers, meshInfo.indexBuffer);
+                            mesh.setIndices(indexData);
+                        }
+                        for(var _iterator2 = _create_for_of_iterator_helper_loose(meshInfo.blendShapes), _step2; !(_step2 = _iterator2()).done;){
+                            var restoreInfo = _step2.value;
+                            var frame = restoreInfo.blendShape.frames[0];
+                            var position = restoreInfo.position;
+                            var positionData = _this._getBufferData(buffers, position.buffer);
+                            frame.deltaPositions = GLTFUtils.bufferToVector3Array(positionData, position.stride, position.byteOffset, position.count);
+                            if (restoreInfo.normal) {
+                                var normal = restoreInfo.normal;
+                                var normalData = _this._getBufferData(buffers, normal.buffer);
+                                frame.deltaNormals = GLTFUtils.bufferToVector3Array(normalData, normal.stride, normal.byteOffset, normal.count);
+                            }
+                            if (restoreInfo.tangent) {
+                                var tangent = restoreInfo.tangent;
+                                var tangentData = _this._getBufferData(buffers, tangent.buffer);
+                                frame.deltaTangents = GLTFUtils.bufferToVector3Array(tangentData, tangent.stride, tangent.byteOffset, tangent.count);
+                            }
+                        }
+                        mesh.uploadData(true);
+                    }
+                    resolve(_this.resource);
+                }).catch(reject);
+            }).catch(reject);
         });
-        promiseInfo.promise = promise;
-        return promise;
     };
-    return ParserContext;
-}();
+    _proto._getBufferData = function _getBufferData(buffers, restoreInfo) {
+        var main = restoreInfo.main;
+        var buffer = buffers[main.bufferIndex];
+        var data = new main.TypedArray(buffer, main.byteOffset, main.length);
+        var sparseCount = restoreInfo.sparseCount;
+        if (sparseCount) {
+            var sparseIndex = restoreInfo.sparseIndices;
+            var sparseIndexBuffer = buffers[sparseIndex.bufferIndex];
+            var sparseIndexData = new sparseIndex.TypedArray(sparseIndexBuffer, sparseIndex.byteOffset, sparseIndex.length);
+            var sparseValue = restoreInfo.sparseValues;
+            var sparseValueBuffer = buffers[sparseValue.bufferIndex];
+            var sparseValueData = new sparseValue.TypedArray(sparseValueBuffer, sparseValue.byteOffset, sparseValue.length);
+            var typeSize = restoreInfo.typeSize;
+            for(var i = 0; i < sparseCount; i++){
+                var replaceIndex = sparseIndexData[i];
+                for(var j = 0; j < typeSize; j++){
+                    data[replaceIndex * typeSize + j] = sparseValueData[i * typeSize + j];
+                }
+            }
+        }
+        return data;
+    };
+    return GLTFContentRestorer;
+}(miniprogram.ContentRestorer);
 /**
  * @internal
- */ var BufferInfo = function BufferInfo(data, interleaved, stride) {
+ */ var BufferRequestInfo = function BufferRequestInfo(url, config) {
+    this.url = url;
+    this.config = config;
+};
+/**
+ * @internal
+ */ var BufferTextureRestoreInfo = function BufferTextureRestoreInfo(texture, bufferView, mimeType) {
+    this.texture = texture;
+    this.bufferView = bufferView;
+    this.mimeType = mimeType;
+};
+/**
+ * @internal
+ */ var ModelMeshRestoreInfo = function ModelMeshRestoreInfo() {
+    this.vertexBuffers = [];
+    this.blendShapes = [];
+};
+/**
+ * @internal
+ */ var BufferRestoreInfo = function BufferRestoreInfo(buffer, data) {
+    this.buffer = buffer;
     this.data = data;
-    this.interleaved = interleaved;
-    this.stride = stride;
-    this.vertexBindingInfos = {};
 };
 /**
  * @internal
- */ var PromiseInfo = function PromiseInfo() {
+ */ var BufferDataRestoreInfo = function BufferDataRestoreInfo(main, typeSize, sparseCount, sparseIndices, sparseValues) {
+    this.main = main;
+    this.typeSize = typeSize;
+    this.sparseCount = sparseCount;
+    this.sparseIndices = sparseIndices;
+    this.sparseValues = sparseValues;
+};
+/**
+ * @internal
+ */ var RestoreDataAccessor = function RestoreDataAccessor(bufferIndex, TypedArray, byteOffset, length) {
+    this.bufferIndex = bufferIndex;
+    this.TypedArray = TypedArray;
+    this.byteOffset = byteOffset;
+    this.length = length;
+};
+/**
+ * @internal
+ */ var BlendShapeRestoreInfo = function BlendShapeRestoreInfo(blendShape, position, normal, tangent) {
+    this.blendShape = blendShape;
+    this.position = position;
+    this.normal = normal;
+    this.tangent = tangent;
+};
+/**
+ * @internal
+ */ var BlendShapeDataRestoreInfo = function BlendShapeDataRestoreInfo(buffer, stride, byteOffset, count) {
+    this.buffer = buffer;
+    this.stride = stride;
+    this.byteOffset = byteOffset;
+    this.count = count;
 };
 
 /**
@@ -539,9 +697,62 @@ var TextureWrapMode;
 
 /**
  * @internal
- */ var GLTFUtil = /*#__PURE__*/ function() {
-    function GLTFUtil() {}
-    GLTFUtil.floatBufferToVector2Array = function floatBufferToVector2Array(buffer) {
+ */ var GLTFParserContext = /*#__PURE__*/ function() {
+    function GLTFParserContext(url) {
+        this.hasSkinned = false;
+        this.chainPromises = [];
+        this.accessorBufferCache = {};
+        this.texturesPromiseInfo = new PromiseInfo();
+        this.materialsPromiseInfo = new PromiseInfo();
+        this.meshesPromiseInfo = new PromiseInfo();
+        this.animationClipsPromiseInfo = new PromiseInfo();
+        this.defaultSceneRootPromiseInfo = new PromiseInfo();
+        this.masterPromiseInfo = new PromiseInfo();
+        this.promiseMap = {};
+        var promiseMap = this.promiseMap;
+        promiseMap["" + url + "?q=textures"] = this._initPromiseInfo(this.texturesPromiseInfo);
+        promiseMap["" + url + "?q=materials"] = this._initPromiseInfo(this.materialsPromiseInfo);
+        promiseMap["" + url + "?q=meshes"] = this._initPromiseInfo(this.meshesPromiseInfo);
+        promiseMap["" + url + "?q=animations"] = this._initPromiseInfo(this.animationClipsPromiseInfo);
+        promiseMap["" + url + "?q=defaultSceneRoot"] = this._initPromiseInfo(this.defaultSceneRootPromiseInfo);
+        promiseMap["" + url] = this._initPromiseInfo(this.masterPromiseInfo);
+    }
+    var _proto = GLTFParserContext.prototype;
+    /**
+   * Get all the buffer data.
+   */ _proto.getBuffers = function getBuffers() {
+        return Promise.resolve(this._buffers);
+    };
+    _proto._initPromiseInfo = function _initPromiseInfo(promiseInfo) {
+        var promise = new miniprogram.AssetPromise(function(resolve, reject, setProgress, onCancel) {
+            promiseInfo.resolve = resolve;
+            promiseInfo.reject = reject;
+            promiseInfo.setProgress = setProgress;
+            promiseInfo.onCancel = onCancel;
+        });
+        promiseInfo.promise = promise;
+        return promise;
+    };
+    return GLTFParserContext;
+}();
+/**
+ * @internal
+ */ var BufferInfo = function BufferInfo(data, interleaved, stride) {
+    this.data = data;
+    this.interleaved = interleaved;
+    this.stride = stride;
+    this.vertexBindingInfos = {};
+};
+/**
+ * @internal
+ */ var PromiseInfo = function PromiseInfo() {
+};
+
+/**
+ * @internal
+ */ var GLTFUtils = /*#__PURE__*/ function() {
+    function GLTFUtils() {}
+    GLTFUtils.floatBufferToVector2Array = function floatBufferToVector2Array(buffer) {
         var bufferLen = buffer.length;
         var array = new Array(bufferLen / 2);
         for(var i = 0; i < bufferLen; i += 2){
@@ -549,7 +760,7 @@ var TextureWrapMode;
         }
         return array;
     };
-    GLTFUtil.floatBufferToVector3Array = function floatBufferToVector3Array(buffer) {
+    GLTFUtils.floatBufferToVector3Array = function floatBufferToVector3Array(buffer) {
         var bufferLen = buffer.length;
         var array = new Array(bufferLen / 3);
         for(var i = 0; i < bufferLen; i += 3){
@@ -557,7 +768,7 @@ var TextureWrapMode;
         }
         return array;
     };
-    GLTFUtil.floatBufferToVector4Array = function floatBufferToVector4Array(buffer) {
+    GLTFUtils.floatBufferToVector4Array = function floatBufferToVector4Array(buffer) {
         var bufferLen = buffer.length;
         var array = new Array(bufferLen / 4);
         for(var i = 0; i < bufferLen; i += 4){
@@ -565,7 +776,7 @@ var TextureWrapMode;
         }
         return array;
     };
-    GLTFUtil.floatBufferToColorArray = function floatBufferToColorArray(buffer, isColor3) {
+    GLTFUtils.floatBufferToColorArray = function floatBufferToColorArray(buffer, isColor3) {
         var bufferLen = buffer.length;
         var colors = new Array(bufferLen / (isColor3 ? 3 : 4));
         if (isColor3) {
@@ -580,21 +791,8 @@ var TextureWrapMode;
         return colors;
     };
     /**
-   * Parse binary text for glb loader.
-   */ GLTFUtil.decodeText = function decodeText(array) {
-        if (typeof TextDecoder !== "undefined") {
-            return new TextDecoder().decode(array);
-        }
-        // TextDecoder polyfill
-        var s = "";
-        for(var i = 0, il = array.length; i < il; i++){
-            s += String.fromCharCode(array[i]);
-        }
-        return decodeURIComponent(encodeURIComponent(s));
-    };
-    /**
    * Get the number of bytes occupied by accessor type.
-   */ GLTFUtil.getAccessorTypeSize = function getAccessorTypeSize(accessorType) {
+   */ GLTFUtils.getAccessorTypeSize = function getAccessorTypeSize(accessorType) {
         switch(accessorType){
             case AccessorType.SCALAR:
                 return 1;
@@ -614,7 +812,7 @@ var TextureWrapMode;
     };
     /**
    * Get the TypedArray corresponding to the component type.
-   */ GLTFUtil.getComponentType = function getComponentType(componentType) {
+   */ GLTFUtils.getComponentType = function getComponentType(componentType) {
         switch(componentType){
             case AccessorComponentType.BYTE:
                 return Int8Array;
@@ -630,7 +828,7 @@ var TextureWrapMode;
                 return Float32Array;
         }
     };
-    GLTFUtil.getNormalizedComponentScale = function getNormalizedComponentScale(componentType) {
+    GLTFUtils.getNormalizedComponentScale = function getNormalizedComponentScale(componentType) {
         // Reference: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization#encoding-quantized-data
         switch(componentType){
             case AccessorComponentType.BYTE:
@@ -645,60 +843,75 @@ var TextureWrapMode;
                 throw new Error("Galacean.GLTFLoader: Unsupported normalized accessor component type.");
         }
     };
-    GLTFUtil.getAccessorBuffer = function getAccessorBuffer(context, gltf, accessor) {
-        var buffers = context.buffers;
-        var bufferViews = gltf.bufferViews;
+    GLTFUtils.getAccessorBuffer = function getAccessorBuffer(context, bufferViews, accessor) {
         var componentType = accessor.componentType;
         var bufferView = bufferViews[accessor.bufferView];
-        var buffer = buffers[bufferView.buffer];
-        var bufferByteOffset = bufferView.byteOffset || 0;
-        var byteOffset = accessor.byteOffset || 0;
-        var TypedArray = GLTFUtil.getComponentType(componentType);
-        var dataElmentSize = GLTFUtil.getAccessorTypeSize(accessor.type);
-        var dataElementBytes = TypedArray.BYTES_PER_ELEMENT;
-        var elementStride = dataElmentSize * dataElementBytes;
-        var accessorCount = accessor.count;
-        var bufferStride = bufferView.byteStride;
-        var bufferInfo;
-        // According to the glTF official documentation only byteStride not undefined is allowed
-        if (bufferStride !== undefined && bufferStride !== elementStride) {
-            var bufferSlice = Math.floor(byteOffset / bufferStride);
-            var bufferCacheKey = accessor.bufferView + ":" + componentType + ":" + bufferSlice + ":" + accessorCount;
-            var accessorBufferCache = context.accessorBufferCache;
-            bufferInfo = accessorBufferCache[bufferCacheKey];
-            if (!bufferInfo) {
-                var offset = bufferByteOffset + bufferSlice * bufferStride;
-                var count = accessorCount * (bufferStride / dataElementBytes);
-                var data = new TypedArray(buffer, offset, count);
-                accessorBufferCache[bufferCacheKey] = bufferInfo = new BufferInfo(data, true, bufferStride);
+        return context.getBuffers().then(function(buffers) {
+            var bufferIndex = bufferView.buffer;
+            var buffer = buffers[bufferIndex];
+            var _bufferView_byteOffset;
+            var bufferByteOffset = (_bufferView_byteOffset = bufferView.byteOffset) != null ? _bufferView_byteOffset : 0;
+            var _accessor_byteOffset;
+            var byteOffset = (_accessor_byteOffset = accessor.byteOffset) != null ? _accessor_byteOffset : 0;
+            var TypedArray = GLTFUtils.getComponentType(componentType);
+            var dataElementSize = GLTFUtils.getAccessorTypeSize(accessor.type);
+            var dataElementBytes = TypedArray.BYTES_PER_ELEMENT;
+            var elementStride = dataElementSize * dataElementBytes;
+            var accessorCount = accessor.count;
+            var bufferStride = bufferView.byteStride;
+            var bufferInfo;
+            // According to the glTF official documentation only byteStride not undefined is allowed
+            if (bufferStride !== undefined && bufferStride !== elementStride) {
+                var bufferSlice = Math.floor(byteOffset / bufferStride);
+                var bufferCacheKey = accessor.bufferView + ":" + componentType + ":" + bufferSlice + ":" + accessorCount;
+                var accessorBufferCache = context.accessorBufferCache;
+                bufferInfo = accessorBufferCache[bufferCacheKey];
+                if (!bufferInfo) {
+                    var offset = bufferByteOffset + bufferSlice * bufferStride;
+                    var count = accessorCount * (bufferStride / dataElementBytes);
+                    var data = new TypedArray(buffer, offset, count);
+                    accessorBufferCache[bufferCacheKey] = bufferInfo = new BufferInfo(data, true, bufferStride);
+                    bufferInfo.restoreInfo = new BufferDataRestoreInfo(new RestoreDataAccessor(bufferIndex, TypedArray, offset, count));
+                }
+            } else {
+                var offset1 = bufferByteOffset + byteOffset;
+                var count1 = accessorCount * dataElementSize;
+                var data1 = new TypedArray(buffer, offset1, count1);
+                bufferInfo = new BufferInfo(data1, false, elementStride);
+                bufferInfo.restoreInfo = new BufferDataRestoreInfo(new RestoreDataAccessor(bufferIndex, TypedArray, offset1, count1));
             }
-        } else {
-            var offset1 = bufferByteOffset + byteOffset;
-            var count1 = accessorCount * dataElmentSize;
-            var data1 = new TypedArray(buffer, offset1, count1);
-            bufferInfo = new BufferInfo(data1, false, elementStride);
-        }
-        if (accessor.sparse) {
-            var data2 = GLTFUtil.processingSparseData(gltf, accessor, buffers, bufferInfo.data);
-            bufferInfo = new BufferInfo(data2, false, bufferInfo.stride);
+            if (accessor.sparse) {
+                GLTFUtils.processingSparseData(bufferViews, accessor, buffers, bufferInfo);
+            }
+            return bufferInfo;
+        });
+    };
+    GLTFUtils.bufferToVector3Array = function bufferToVector3Array(data, byteStride, accessorByteOffset, count) {
+        var bytesPerElement = data.BYTES_PER_ELEMENT;
+        var offset = accessorByteOffset % byteStride / bytesPerElement;
+        var stride = byteStride / bytesPerElement;
+        var vector3s = new Array(count);
+        for(var i = 0; i < count; i++){
+            var index = offset + i * stride;
+            vector3s[i] = new miniprogram$1.Vector3(data[index], data[index + 1], data[index + 2]);
         }
-        return bufferInfo;
+        return vector3s;
     };
     /**
    * @deprecated
    * Get accessor data.
-   */ GLTFUtil.getAccessorData = function getAccessorData(gltf, accessor, buffers) {
-        var bufferViews = gltf.bufferViews;
+   */ GLTFUtils.getAccessorData = function getAccessorData(glTF, accessor, buffers) {
+        var bufferViews = glTF.bufferViews;
         var bufferView = bufferViews[accessor.bufferView];
         var arrayBuffer = buffers[bufferView.buffer];
         var accessorByteOffset = accessor.hasOwnProperty("byteOffset") ? accessor.byteOffset : 0;
         var bufferViewByteOffset = bufferView.hasOwnProperty("byteOffset") ? bufferView.byteOffset : 0;
         var byteOffset = accessorByteOffset + bufferViewByteOffset;
-        var accessorTypeSize = GLTFUtil.getAccessorTypeSize(accessor.type);
+        var accessorTypeSize = GLTFUtils.getAccessorTypeSize(accessor.type);
         var length = accessorTypeSize * accessor.count;
         var _bufferView_byteStride;
         var byteStride = (_bufferView_byteStride = bufferView.byteStride) != null ? _bufferView_byteStride : 0;
-        var arrayType = GLTFUtil.getComponentType(accessor.componentType);
+        var arrayType = GLTFUtils.getComponentType(accessor.componentType);
         var uint8Array;
         if (byteStride) {
             var accessorByteSize = accessorTypeSize * arrayType.BYTES_PER_ELEMENT;
@@ -725,7 +938,7 @@ var TextureWrapMode;
             var _values_byteOffset, _valuesBufferView_byteOffset;
             var valuesByteOffset = ((_values_byteOffset = values.byteOffset) != null ? _values_byteOffset : 0) + ((_valuesBufferView_byteOffset = valuesBufferView.byteOffset) != null ? _valuesBufferView_byteOffset : 0);
             var valuesByteLength = valuesBufferView.byteLength;
-            var indicesType = GLTFUtil.getComponentType(indices.componentType);
+            var indicesType = GLTFUtils.getComponentType(indices.componentType);
             var indicesArray = new indicesType(indicesArrayBuffer, indicesByteOffset, indicesByteLength / indicesType.BYTES_PER_ELEMENT);
             var valuesArray = new arrayType(valuesArrayBuffer, valuesByteOffset, valuesByteLength / arrayType.BYTES_PER_ELEMENT);
             for(var i1 = 0; i1 < count; i1++){
@@ -737,41 +950,49 @@ var TextureWrapMode;
         }
         return typedArray;
     };
-    GLTFUtil.getBufferViewData = function getBufferViewData(bufferView, buffers) {
-        var buffer = bufferView.buffer, _bufferView_byteOffset = bufferView.byteOffset, byteOffset = _bufferView_byteOffset === void 0 ? 0 : _bufferView_byteOffset, byteLength = bufferView.byteLength;
-        var arrayBuffer = buffers[buffer];
-        return arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+    GLTFUtils.getBufferViewData = function getBufferViewData(bufferView, buffers) {
+        var _bufferView_byteOffset = bufferView.byteOffset, byteOffset = _bufferView_byteOffset === void 0 ? 0 : _bufferView_byteOffset;
+        var arrayBuffer = buffers[bufferView.buffer];
+        return arrayBuffer.slice(byteOffset, byteOffset + bufferView.byteLength);
     };
     /**
    * Get accessor data.
-   */ GLTFUtil.processingSparseData = function processingSparseData(gltf, accessor, buffers, originData) {
-        var bufferViews = gltf.bufferViews;
-        var accessorTypeSize = GLTFUtil.getAccessorTypeSize(accessor.type);
-        var TypedArray = GLTFUtil.getComponentType(accessor.componentType);
-        var data = originData.slice();
+   */ GLTFUtils.processingSparseData = function processingSparseData(bufferViews, accessor, buffers, bufferInfo) {
+        var restoreInfo = bufferInfo.restoreInfo;
+        var accessorTypeSize = GLTFUtils.getAccessorTypeSize(accessor.type);
+        var TypedArray = GLTFUtils.getComponentType(accessor.componentType);
+        var data = bufferInfo.data.slice();
         var _accessor_sparse = accessor.sparse, count = _accessor_sparse.count, indices = _accessor_sparse.indices, values = _accessor_sparse.values;
         var indicesBufferView = bufferViews[indices.bufferView];
         var valuesBufferView = bufferViews[values.bufferView];
-        var indicesArrayBuffer = buffers[indicesBufferView.buffer];
-        var valuesArrayBuffer = buffers[valuesBufferView.buffer];
+        var indicesBufferIndex = indicesBufferView.buffer;
+        var valuesBufferIndex = valuesBufferView.buffer;
+        var indicesArrayBuffer = buffers[indicesBufferIndex];
+        var valuesArrayBuffer = buffers[valuesBufferIndex];
         var _indices_byteOffset, _indicesBufferView_byteOffset;
         var indicesByteOffset = ((_indices_byteOffset = indices.byteOffset) != null ? _indices_byteOffset : 0) + ((_indicesBufferView_byteOffset = indicesBufferView.byteOffset) != null ? _indicesBufferView_byteOffset : 0);
         var indicesByteLength = indicesBufferView.byteLength;
         var _values_byteOffset, _valuesBufferView_byteOffset;
         var valuesByteOffset = ((_values_byteOffset = values.byteOffset) != null ? _values_byteOffset : 0) + ((_valuesBufferView_byteOffset = valuesBufferView.byteOffset) != null ? _valuesBufferView_byteOffset : 0);
         var valuesByteLength = valuesBufferView.byteLength;
-        var IndexTypeArray = GLTFUtil.getComponentType(indices.componentType);
-        var indicesArray = new IndexTypeArray(indicesArrayBuffer, indicesByteOffset, indicesByteLength / IndexTypeArray.BYTES_PER_ELEMENT);
-        var valuesArray = new TypedArray(valuesArrayBuffer, valuesByteOffset, valuesByteLength / TypedArray.BYTES_PER_ELEMENT);
+        restoreInfo.typeSize = accessorTypeSize;
+        restoreInfo.sparseCount = count;
+        var IndexTypeArray = GLTFUtils.getComponentType(indices.componentType);
+        var indexLength = indicesByteLength / IndexTypeArray.BYTES_PER_ELEMENT;
+        var indicesArray = new IndexTypeArray(indicesArrayBuffer, indicesByteOffset, indexLength);
+        restoreInfo.sparseIndices = new RestoreDataAccessor(indicesBufferIndex, IndexTypeArray, indicesByteOffset, indexLength);
+        var valueLength = valuesByteLength / TypedArray.BYTES_PER_ELEMENT;
+        var valuesArray = new TypedArray(valuesArrayBuffer, valuesByteOffset, valueLength);
+        restoreInfo.sparseValues = new RestoreDataAccessor(valuesBufferIndex, TypedArray, valuesByteOffset, valueLength);
         for(var i = 0; i < count; i++){
             var replaceIndex = indicesArray[i];
             for(var j = 0; j < accessorTypeSize; j++){
                 data[replaceIndex * accessorTypeSize + j] = valuesArray[i * accessorTypeSize + j];
             }
         }
-        return data;
+        bufferInfo.data = data;
     };
-    GLTFUtil.getIndexFormat = function getIndexFormat(type) {
+    GLTFUtils.getIndexFormat = function getIndexFormat(type) {
         switch(type){
             case AccessorComponentType.UNSIGNED_BYTE:
                 return miniprogram.IndexFormat.UInt8;
@@ -781,7 +1002,7 @@ var TextureWrapMode;
                 return miniprogram.IndexFormat.UInt32;
         }
     };
-    GLTFUtil.getElementFormat = function getElementFormat(type, size, normalized) {
+    GLTFUtils.getElementFormat = function getElementFormat(type, size, normalized) {
         if (normalized === void 0) normalized = false;
         if (type == AccessorComponentType.FLOAT) {
             switch(size){
@@ -832,7 +1053,7 @@ var TextureWrapMode;
     };
     /**
    * Load image buffer
-   */ GLTFUtil.loadImageBuffer = function loadImageBuffer(imageBuffer, type) {
+   */ GLTFUtils.loadImageBuffer = function loadImageBuffer(imageBuffer, type) {
         return new Promise(function(resolve, reject) {
             var blob = new engineMiniprogramAdapter.window.Blob([
                 imageBuffer
@@ -856,18 +1077,9 @@ var TextureWrapMode;
             img.src = engineMiniprogramAdapter.URL.createObjectURL(blob);
         });
     };
-    GLTFUtil.isAbsoluteUrl = function isAbsoluteUrl(url) {
-        return /^(?:http|blob|data:|\/)/.test(url);
-    };
-    GLTFUtil.parseRelativeUrl = function parseRelativeUrl(baseUrl, relativeUrl) {
-        if (GLTFUtil.isAbsoluteUrl(relativeUrl)) {
-            return relativeUrl;
-        }
-        return baseUrl.substring(0, baseUrl.lastIndexOf("/") + 1) + GLTFUtil._formatRelativePath(relativeUrl);
-    };
     /**
    * Parse the glb format.
-   */ GLTFUtil.parseGLB = function parseGLB(glb) {
+   */ GLTFUtils.parseGLB = function parseGLB(context, glb) {
         var UINT32_LENGTH = 4;
         var GLB_HEADER_MAGIC = 0x46546c67; // 'glTF'
         var GLB_HEADER_LENGTH = 12;
@@ -895,10 +1107,11 @@ var TextureWrapMode;
             return null;
         }
         var glTFData = new Uint8Array(glb, GLB_HEADER_LENGTH + 2 * UINT32_LENGTH, chunkLength);
-        var gltf = JSON.parse(GLTFUtil.decodeText(glTFData));
+        var glTF = JSON.parse(miniprogram.Utils.decodeText(glTFData));
         // read all buffers
         var buffers = [];
         var byteOffset = GLB_HEADER_LENGTH + 2 * UINT32_LENGTH + chunkLength;
+        var restoreGLBBufferSlice = context.contentRestorer.glbBufferSlices;
         while(byteOffset < header.length){
             chunkLength = dataView.getUint32(byteOffset, true);
             chunkType = dataView.getUint32(byteOffset + UINT32_LENGTH, true);
@@ -909,14 +1122,15 @@ var TextureWrapMode;
             var currentOffset = byteOffset + 2 * UINT32_LENGTH;
             var buffer = glb.slice(currentOffset, currentOffset + chunkLength);
             buffers.push(buffer);
+            restoreGLBBufferSlice.push(new miniprogram$1.Vector2(currentOffset, chunkLength));
             byteOffset += chunkLength + 2 * UINT32_LENGTH;
         }
         return {
-            gltf: gltf,
+            glTF: glTF,
             buffers: buffers
         };
     };
-    GLTFUtil._formatRelativePath = function _formatRelativePath(path) {
+    GLTFUtils._formatRelativePath = function _formatRelativePath(path) {
         // For example input is "a/b", "/a/b", "./a/b", "./a/./b", "./a/../a/b", output is "a/b"
         return path.split("/").filter(Boolean).reduce(function(acc, cur) {
             if (cur === "..") acc.pop();
@@ -924,17 +1138,9 @@ var TextureWrapMode;
             return acc;
         }, []).join("/");
     };
-    return GLTFUtil;
+    return GLTFUtils;
 }();
 
-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];
-
-    return arr2;
-}
-
 function _array_without_holes(arr) {
     if (Array.isArray(arr)) return _array_like_to_array(arr);
 }
@@ -949,527 +1155,260 @@ function _non_iterable_spread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
 
-var Parser = /*#__PURE__*/ function() {
-    function Parser() {}
-    Parser.parseEngineResource = function parseEngineResource(extensionName, extensionSchema, parseResource, context) {
+/**
+ * Base class of glTF extension parser.
+ */ var GLTFExtensionParser = /*#__PURE__*/ function() {
+    function GLTFExtensionParser() {}
+    var _proto = GLTFExtensionParser.prototype;
+    /**
+   * Initialize the parser.
+   * @remarks Some plugins require initialization.
+   * @returns The void or promise
+   */ _proto.initialize = function initialize() {};
+    /**
+   * Create and parse the resource.
+   * @remarks This method overrides the default resource creation.
+   * @param context - The parser context
+   * @param extensionSchema - The extension schema
+   * @param extensionOwnerSchema - The extension owner schema
+   * @returns The resource or promise
+   */ _proto.createAndParse = function createAndParse(context, extensionSchema, extensionOwnerSchema) {
+        for(var _len = arguments.length, extra = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
+            extra[_key - 3] = arguments[_key];
+        }
+        throw "Not implemented.";
+    };
+    /**
+   * Additive parse to the resource.
+   * @param context - The parser context
+   * @param parseResource - The parsed resource
+   * @param extensionSchema - The extension schema
+   * @param extensionOwnerSchema - The extension owner schema
+   * @returns The void or promise
+   */ _proto.additiveParse = function additiveParse(context, parseResource, extensionSchema, extensionOwnerSchema) {
         for(var _len = arguments.length, extra = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++){
             extra[_key - 4] = arguments[_key];
         }
-        var parsers = Parser._extensionParsers[extensionName];
-        if (parsers == null ? void 0 : parsers.length) {
-            for(var i = 0; i < parsers.length; i++){
-                var _parsers_i;
-                (_parsers_i = parsers[i]).parseEngineResource.apply(_parsers_i, [
-                    extensionSchema,
-                    parseResource,
-                    context
-                ].concat(_to_consumable_array(extra)));
-            }
+        throw "Not implemented.";
+    };
+    return GLTFExtensionParser;
+}();
+exports.GLTFExtensionMode = void 0;
+(function(GLTFExtensionMode) {
+    GLTFExtensionMode[GLTFExtensionMode[/**
+   * Cerate instance and parse mode.
+   * @remarks
+   * If the glTF property has multiple extensions of `CreateAndParse` mode, only execute the last one.
+   * If this method is registered, the default pipeline processing will be ignored.
+   */ "CreateAndParse"] = 0] = "CreateAndParse";
+    GLTFExtensionMode[GLTFExtensionMode[/** Additive parse mode. */ "AdditiveParse"] = 1] = "AdditiveParse";
+})(exports.GLTFExtensionMode || (exports.GLTFExtensionMode = {}));
+
+/**
+ * Base class of glTF parser.
+ */ var GLTFParser = /*#__PURE__*/ function() {
+    function GLTFParser() {}
+    /**
+   * Execute all parses of extension to initialize plugin.
+   * @remarks Some plugins require initialization.
+   * @returns The void or promise
+   */ GLTFParser.executeExtensionsInitialize = function executeExtensionsInitialize(extensionName) {
+        var parsers = GLTFParser._extensionParsers[extensionName];
+        var length = parsers == null ? void 0 : parsers.length;
+        if (length) {
+            return parsers[length - 1].initialize();
         }
     };
-    Parser.createEngineResource = function createEngineResource(extensionName, extensionSchema, context) {
+    /**
+   * Execute all parses of extension to create resource.
+   * @param extensions - Related extensions field
+   * @param context - The parser context
+   * @param ownerSchema - The extension owner schema
+   * @param extra - Extra params
+   * @returns
+   */ GLTFParser.executeExtensionsCreateAndParse = function executeExtensionsCreateAndParse(extensions, context, ownerSchema) {
+        if (extensions === void 0) extensions = {};
         for(var _len = arguments.length, extra = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
             extra[_key - 3] = arguments[_key];
         }
-        var parsers = Parser._extensionParsers[extensionName];
-        if (parsers == null ? void 0 : parsers.length) {
-            var _parsers_;
-            return (_parsers_ = parsers[0]).createEngineResource.apply(_parsers_, [
+        var resource = null;
+        var extensionArray = Object.keys(extensions);
+        for(var i = extensionArray.length - 1; i >= 0; --i){
+            var _GLTFParser;
+            var extensionName = extensionArray[i];
+            var extensionSchema = extensions[extensionName];
+            resource = (_GLTFParser = GLTFParser)._createAndParse.apply(_GLTFParser, [
+                extensionName,
+                context,
+                extensionSchema,
+                ownerSchema
+            ].concat(_to_consumable_array(extra)));
+            if (resource) {
+                return resource;
+            }
+        }
+    };
+    /**
+   * Execute all parses of extension to parse resource.
+   * @param extensions - Related extensions field
+   * @param context - The parser context
+   * @param parseResource -  The parsed resource
+   * @param ownerSchema - The extension owner schema
+   * @param extra - Extra params
+   */ GLTFParser.executeExtensionsAdditiveAndParse = function executeExtensionsAdditiveAndParse(extensions, context, parseResource, ownerSchema) {
+        for(var _len = arguments.length, extra = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++){
+            extra[_key - 4] = arguments[_key];
+        }
+        for(var extensionName in extensions){
+            var _GLTFParser;
+            var extensionSchema = extensions[extensionName];
+            (_GLTFParser = GLTFParser)._additiveParse.apply(_GLTFParser, [
+                extensionName,
+                context,
+                parseResource,
                 extensionSchema,
-                context
+                ownerSchema
             ].concat(_to_consumable_array(extra)));
         }
     };
-    Parser.hasExtensionParser = function hasExtensionParser(extensionName) {
-        var parsers = Parser._extensionParsers[extensionName];
-        return !!(parsers == null ? void 0 : parsers.length);
+    /**
+   * Whether the plugin is registered.
+   * @param extensionName - Extension name
+   * @returns Boolean
+   */ GLTFParser.hasExtensionParser = function hasExtensionParser(extensionName) {
+        var _GLTFParser__extensionParsers_extensionName;
+        return !!((_GLTFParser__extensionParsers_extensionName = GLTFParser._extensionParsers[extensionName]) == null ? void 0 : _GLTFParser__extensionParsers_extensionName.length);
     };
-    Parser.initialize = function initialize(extensionName) {
-        var parsers = Parser._extensionParsers[extensionName];
-        if (parsers == null ? void 0 : parsers.length) {
-            for(var i = 0; i < parsers.length; i++){
-                parsers[i].initialize();
+    /**
+   * Get the last plugin by glTF extension mode.
+   * @param extensionName - Extension name
+   * @param mode - GLTF extension mode
+   * @returns GLTF extension parser
+   */ GLTFParser.getExtensionParser = function getExtensionParser(extensionName, mode) {
+        var parsers = GLTFParser._extensionParsers[extensionName];
+        var length = parsers == null ? void 0 : parsers.length;
+        if (length) {
+            // only use the last parser.
+            for(var i = length - 1; i >= 0; --i){
+                var currentParser = parsers[i];
+                if (currentParser._mode === mode) {
+                    return currentParser;
+                }
             }
         }
     };
     /**
    * @internal
-   */ Parser._addExtensionParser = function _addExtensionParser(extensionName, extensionParser) {
-        if (!Parser._extensionParsers[extensionName]) {
-            Parser._extensionParsers[extensionName] = [];
+   */ GLTFParser._addExtensionParser = function _addExtensionParser(extensionName, extensionParser) {
+        if (!GLTFParser._extensionParsers[extensionName]) {
+            GLTFParser._extensionParsers[extensionName] = [];
+        }
+        GLTFParser._extensionParsers[extensionName].push(extensionParser);
+    };
+    GLTFParser._createAndParse = function _createAndParse(extensionName, context, extensionSchema, ownerSchema) {
+        for(var _len = arguments.length, extra = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++){
+            extra[_key - 4] = arguments[_key];
+        }
+        var parser = GLTFParser.getExtensionParser(extensionName, exports.GLTFExtensionMode.CreateAndParse);
+        if (parser) {
+            var _parser;
+            return (_parser = parser).createAndParse.apply(_parser, [
+                context,
+                extensionSchema,
+                ownerSchema
+            ].concat(_to_consumable_array(extra)));
+        }
+    };
+    GLTFParser._additiveParse = function _additiveParse(extensionName, context, parseResource, extensionSchema, ownerSchema) {
+        for(var _len = arguments.length, extra = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++){
+            extra[_key - 5] = arguments[_key];
+        }
+        var parser = GLTFParser.getExtensionParser(extensionName, exports.GLTFExtensionMode.AdditiveParse);
+        if (parser) {
+            var _parser;
+            (_parser = parser).additiveParse.apply(_parser, [
+                context,
+                parseResource,
+                extensionSchema,
+                ownerSchema
+            ].concat(_to_consumable_array(extra)));
         }
-        Parser._extensionParsers[extensionName].push(extensionParser);
     };
-    return Parser;
+    return GLTFParser;
 }();
 (function() {
-    Parser._extensionParsers = {};
+    GLTFParser._extensionParsers = {};
 })();
 /**
  * Declare ExtensionParser's decorator.
  * @param extensionName - Extension name
- */ function registerExtension(extensionName) {
+ */ function registerGLTFExtension(extensionName, mode) {
     return function(parser) {
         var extensionParser = new parser();
-        Parser._addExtensionParser(extensionName, extensionParser);
+        extensionParser._mode = mode;
+        GLTFParser._addExtensionParser(extensionName, extensionParser);
     };
 }
 
-var ExtensionParser = /*#__PURE__*/ function() {
-    function ExtensionParser() {}
-    var _proto = ExtensionParser.prototype;
-    _proto.initialize = function initialize() {};
-    _proto.parseEngineResource = function parseEngineResource(schema, parseResource, context) {
-        for(var _len = arguments.length, extra = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
-            extra[_key - 3] = arguments[_key];
+var GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFAnimationParser, GLTFParser1);
+    function GLTFAnimationParser() {
+        return GLTFParser1.apply(this, arguments);
+    }
+    var _proto = GLTFAnimationParser.prototype;
+    _proto.parse = function parse(context) {
+        var glTF = context.glTF, glTFResource = context.glTFResource;
+        glTFResource.entities;
+        var animations = glTF.animations; glTF.accessors; glTF.bufferViews;
+        if (!animations) {
+            return;
         }
-    };
-    _proto.createEngineResource = function createEngineResource(schema, context) {
-        for(var _len = arguments.length, extra = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
-            extra[_key - 2] = arguments[_key];
+        var animationClipsPromiseInfo = context.animationClipsPromiseInfo;
+        var animationClipCount = animations.length;
+        var animationClipPromises = [];
+        new Array(animationClipCount);
+        var parseStandardPropertyPromises = new Array();
+        for(var i = 0; i < animationClipCount; i++){
+            var animationInfo = animations[i];
+            var _animationInfo_name = animationInfo.name, name = _animationInfo_name === void 0 ? "AnimationClip" + i : _animationInfo_name;
+            var animationClip = GLTFParser.executeExtensionsCreateAndParse(animationInfo.extensions, context, animationInfo);
+            if (!animationClip) {
+                animationClip = new miniprogram.AnimationClip(name);
+                parseStandardPropertyPromises.push(GLTFAnimationParser._parseStandardProperty(context, animationClip, animationInfo));
+            }
+            animationClipPromises.push(animationClip);
         }
-        return null;
+        return miniprogram.AssetPromise.all(parseStandardPropertyPromises).then(function() {
+            return miniprogram.AssetPromise.all(animationClipPromises).then(function(animationClips) {
+                glTFResource.animations = animationClips;
+                for(var i = 0; i < glTF.animations.length; i++){
+                    var animationInfo = glTF.animations[i];
+                    GLTFParser.executeExtensionsAdditiveAndParse(animationInfo.extensions, context, animationClips[i], animationInfo);
+                }
+                animationClipsPromiseInfo.resolve(animationClips);
+                return animationClipsPromiseInfo.promise;
+            });
+        });
     };
-    return ExtensionParser;
-}();
-
-var KHR_draco_mesh_compression = /*#__PURE__*/ function(ExtensionParser) {
-    _inherits(KHR_draco_mesh_compression1, ExtensionParser);
-    function KHR_draco_mesh_compression1() {
-        return ExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_draco_mesh_compression1.prototype;
-    _proto.initialize = function initialize() {
-        if (!KHR_draco_mesh_compression._decoder) {
-            KHR_draco_mesh_compression._decoder = new miniprogram$2.DRACODecoder();
-        }
-    };
-    _proto.createEngineResource = function createEngineResource(schema, context, gltfPrimitive) {
-        var gltf = context.gltf, buffers = context.buffers;
-        var bufferViews = gltf.bufferViews, accessors = gltf.accessors;
-        var bufferViewIndex = schema.bufferView, gltfAttributeMap = schema.attributes;
-        var attributeMap = {};
-        var attributeTypeMap = {};
-        for(var attributeName in gltfAttributeMap){
-            attributeMap[attributeName] = gltfAttributeMap[attributeName];
-        }
-        for(var attributeName1 in gltfPrimitive.attributes){
-            if (gltfAttributeMap[attributeName1] !== undefined) {
-                var accessorDef = accessors[gltfPrimitive.attributes[attributeName1]];
-                attributeTypeMap[attributeName1] = GLTFUtil.getComponentType(accessorDef.componentType).name;
-            }
-        }
-        var indexAccessor = accessors[gltfPrimitive.indices];
-        var indexType = GLTFUtil.getComponentType(indexAccessor.componentType).name;
-        var taskConfig = {
-            attributeIDs: attributeMap,
-            attributeTypes: attributeTypeMap,
-            useUniqueIDs: true,
-            indexType: indexType
-        };
-        var buffer = GLTFUtil.getBufferViewData(bufferViews[bufferViewIndex], buffers);
-        return KHR_draco_mesh_compression._decoder.decode(buffer, taskConfig).then(function(parsedGeometry) {
-            return parsedGeometry;
-        });
-    };
-    return KHR_draco_mesh_compression1;
-}(ExtensionParser);
-KHR_draco_mesh_compression = __decorate([
-    registerExtension("KHR_draco_mesh_compression")
-], KHR_draco_mesh_compression);
-
-function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else return left instanceof right;
-}
-
-var KHR_lights_punctual = /*#__PURE__*/ function(ExtensionParser) {
-    _inherits(KHR_lights_punctual, ExtensionParser);
-    function KHR_lights_punctual() {
-        return ExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_lights_punctual.prototype;
-    _proto.parseEngineResource = function parseEngineResource(schema, entity, context) {
-        var color = schema.color, _schema_intensity = schema.intensity, intensity = _schema_intensity === void 0 ? 1 : _schema_intensity, type = schema.type, range = schema.range, spot = schema.spot;
-        var glTFResource = context.glTFResource;
-        var light;
-        if (type === "directional") {
-            light = entity.addComponent(miniprogram.DirectLight);
-        } else if (type === "point") {
-            light = entity.addComponent(miniprogram.PointLight);
-        } else if (type === "spot") {
-            light = entity.addComponent(miniprogram.SpotLight);
-        }
-        if (color) {
-            light.color.set(color[0], color[1], color[2], 1);
-        }
-        light.intensity = intensity;
-        if (range && !_instanceof(light, miniprogram.DirectLight)) {
-            light.distance = range;
-        }
-        if (spot && _instanceof(light, miniprogram.SpotLight)) {
-            var _spot_innerConeAngle = spot.innerConeAngle, innerConeAngle = _spot_innerConeAngle === void 0 ? 0 : _spot_innerConeAngle, _spot_outerConeAngle = spot.outerConeAngle, outerConeAngle = _spot_outerConeAngle === void 0 ? Math.PI / 4 : _spot_outerConeAngle;
-            light.angle = innerConeAngle;
-            light.penumbra = outerConeAngle - innerConeAngle;
-        }
-        if (!glTFResource.lights) glTFResource.lights = [];
-        glTFResource.lights.push(light);
-    };
-    return KHR_lights_punctual;
-}(ExtensionParser);
-KHR_lights_punctual = __decorate([
-    registerExtension("KHR_lights_punctual")
-], KHR_lights_punctual);
-
-var MaterialParser = /*#__PURE__*/ function(Parser1) {
-    _inherits(MaterialParser, Parser1);
-    function MaterialParser() {
-        return Parser1.apply(this, arguments);
-    }
-    var _proto = MaterialParser.prototype;
-    _proto.parse = function parse(context) {
-        var gltf = context.gltf, glTFResource = context.glTFResource;
-        var engine = glTFResource.engine, textures = glTFResource.textures;
-        if (!gltf.materials) return;
-        var materialsPromiseInfo = context.materialsPromiseInfo;
-        var materials = [];
-        for(var i = 0; i < gltf.materials.length; i++){
-            var _gltf_materials_i = gltf.materials[i], _gltf_materials_i_extensions = _gltf_materials_i.extensions, extensions = _gltf_materials_i_extensions === void 0 ? {} : _gltf_materials_i_extensions, pbrMetallicRoughness = _gltf_materials_i.pbrMetallicRoughness, normalTexture = _gltf_materials_i.normalTexture, occlusionTexture = _gltf_materials_i.occlusionTexture, emissiveTexture = _gltf_materials_i.emissiveTexture, emissiveFactor = _gltf_materials_i.emissiveFactor, alphaMode = _gltf_materials_i.alphaMode, alphaCutoff = _gltf_materials_i.alphaCutoff, doubleSided = _gltf_materials_i.doubleSided, _gltf_materials_i_name = _gltf_materials_i.name, name = _gltf_materials_i_name === void 0 ? "" : _gltf_materials_i_name;
-            var KHR_materials_unlit = extensions.KHR_materials_unlit, KHR_materials_pbrSpecularGlossiness = extensions.KHR_materials_pbrSpecularGlossiness, KHR_materials_clearcoat = extensions.KHR_materials_clearcoat, OASIS_materials_remap = extensions.OASIS_materials_remap;
-            var material = null;
-            if (KHR_materials_unlit) {
-                material = Parser.createEngineResource("KHR_materials_unlit", KHR_materials_unlit, context);
-            } else if (KHR_materials_pbrSpecularGlossiness) {
-                material = Parser.createEngineResource("KHR_materials_pbrSpecularGlossiness", KHR_materials_pbrSpecularGlossiness, context);
-            } else {
-                material = new miniprogram.PBRMaterial(engine);
-            }
-            material.name = name;
-            if (KHR_materials_clearcoat) {
-                Parser.parseEngineResource("KHR_materials_clearcoat", KHR_materials_clearcoat, material, context);
-            }
-            if (pbrMetallicRoughness) {
-                var baseColorFactor = pbrMetallicRoughness.baseColorFactor, baseColorTexture = pbrMetallicRoughness.baseColorTexture, metallicFactor = pbrMetallicRoughness.metallicFactor, roughnessFactor = pbrMetallicRoughness.roughnessFactor, metallicRoughnessTexture = pbrMetallicRoughness.metallicRoughnessTexture;
-                if (baseColorFactor) {
-                    material.baseColor = new miniprogram$1.Color(miniprogram$1.Color.linearToGammaSpace(baseColorFactor[0]), miniprogram$1.Color.linearToGammaSpace(baseColorFactor[1]), miniprogram$1.Color.linearToGammaSpace(baseColorFactor[2]), baseColorFactor[3]);
-                }
-                if (baseColorTexture) {
-                    material.baseTexture = textures[baseColorTexture.index];
-                    MaterialParser._parseTextureTransform(material, baseColorTexture.extensions, context);
-                }
-                if (!KHR_materials_unlit && !KHR_materials_pbrSpecularGlossiness) {
-                    var m = material;
-                    m.metallic = metallicFactor != null ? metallicFactor : 1;
-                    m.roughness = roughnessFactor != null ? roughnessFactor : 1;
-                    if (metallicRoughnessTexture) {
-                        m.roughnessMetallicTexture = textures[metallicRoughnessTexture.index];
-                        MaterialParser._parseTextureTransform(material, metallicRoughnessTexture.extensions, context);
-                    }
-                }
-            }
-            if (!KHR_materials_unlit) {
-                var m1 = material;
-                if (emissiveTexture) {
-                    m1.emissiveTexture = textures[emissiveTexture.index];
-                    MaterialParser._parseTextureTransform(material, emissiveTexture.extensions, context);
-                }
-                if (emissiveFactor) {
-                    m1.emissiveColor = new miniprogram$1.Color(miniprogram$1.Color.linearToGammaSpace(emissiveFactor[0]), miniprogram$1.Color.linearToGammaSpace(emissiveFactor[1]), miniprogram$1.Color.linearToGammaSpace(emissiveFactor[2]));
-                }
-                if (normalTexture) {
-                    var index = normalTexture.index, scale = normalTexture.scale;
-                    m1.normalTexture = textures[index];
-                    MaterialParser._parseTextureTransform(material, normalTexture.extensions, context);
-                    if (scale !== undefined) {
-                        m1.normalTextureIntensity = scale;
-                    }
-                }
-                if (occlusionTexture) {
-                    var index1 = occlusionTexture.index, strength = occlusionTexture.strength, texCoord = occlusionTexture.texCoord;
-                    m1.occlusionTexture = textures[index1];
-                    MaterialParser._parseTextureTransform(material, occlusionTexture.extensions, context);
-                    if (strength !== undefined) {
-                        m1.occlusionTextureIntensity = strength;
-                    }
-                    if (texCoord === miniprogram.TextureCoordinate.UV1) {
-                        m1.occlusionTextureCoord = miniprogram.TextureCoordinate.UV1;
-                    } else if (texCoord > miniprogram.TextureCoordinate.UV1) {
-                        miniprogram.Logger.warn("Occlusion texture uv coordinate must be UV0 or UV1.");
-                    }
-                }
-            }
-            if (OASIS_materials_remap) {
-                var _gltf_extensions;
-                gltf.extensions = (_gltf_extensions = gltf.extensions) != null ? _gltf_extensions : {};
-                var _gltf_extensions_OASIS_materials_remap;
-                gltf.extensions["OASIS_materials_remap"] = (_gltf_extensions_OASIS_materials_remap = gltf.extensions["OASIS_materials_remap"]) != null ? _gltf_extensions_OASIS_materials_remap : {};
-                gltf.extensions["OASIS_materials_remap"][i] = Parser.createEngineResource("OASIS_materials_remap", OASIS_materials_remap, context);
-            }
-            if (doubleSided) {
-                material.renderFace = miniprogram.RenderFace.Double;
-            } else {
-                material.renderFace = miniprogram.RenderFace.Front;
-            }
-            switch(alphaMode){
-                case MaterialAlphaMode.OPAQUE:
-                    material.isTransparent = false;
-                    break;
-                case MaterialAlphaMode.BLEND:
-                    material.isTransparent = true;
-                    break;
-                case MaterialAlphaMode.MASK:
-                    material.alphaCutoff = alphaCutoff != null ? alphaCutoff : 0.5;
-                    break;
-            }
-            materials[i] = material;
-        }
-        glTFResource.materials = materials;
-        materialsPromiseInfo.resolve(materials);
-        return materialsPromiseInfo.promise;
-    };
-    /** @internal */ MaterialParser._parseTextureTransform = function _parseTextureTransform(material, extensions, context) {
-        if (extensions === void 0) extensions = {};
-        var schema = extensions.KHR_texture_transform;
-        if (schema) {
-            Parser.parseEngineResource("KHR_texture_transform", schema, material, context);
-        }
-    };
-    return MaterialParser;
-}(Parser);
-
-var KHR_materials_clearcoat = /*#__PURE__*/ function(ExtensionParser) {
-    _inherits(KHR_materials_clearcoat, ExtensionParser);
-    function KHR_materials_clearcoat() {
-        return ExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_materials_clearcoat.prototype;
-    _proto.parseEngineResource = function parseEngineResource(schema, material, context) {
-        var textures = context.glTFResource.textures;
-        var _schema_clearcoatFactor = schema.clearcoatFactor, clearcoatFactor = _schema_clearcoatFactor === void 0 ? 0 : _schema_clearcoatFactor, clearcoatTexture = schema.clearcoatTexture, _schema_clearcoatRoughnessFactor = schema.clearcoatRoughnessFactor, clearcoatRoughnessFactor = _schema_clearcoatRoughnessFactor === void 0 ? 0 : _schema_clearcoatRoughnessFactor, clearcoatRoughnessTexture = schema.clearcoatRoughnessTexture, clearcoatNormalTexture = schema.clearcoatNormalTexture;
-        material.clearCoat = clearcoatFactor;
-        material.clearCoatRoughness = clearcoatRoughnessFactor;
-        if (clearcoatTexture) {
-            material.clearCoatTexture = textures[clearcoatTexture.index];
-            MaterialParser._parseTextureTransform(material, clearcoatTexture.extensions, context);
-        }
-        if (clearcoatRoughnessTexture) {
-            material.clearCoatRoughnessTexture = textures[clearcoatRoughnessTexture.index];
-            MaterialParser._parseTextureTransform(material, clearcoatRoughnessTexture.extensions, context);
-        }
-        if (clearcoatNormalTexture) {
-            material.clearCoatNormalTexture = textures[clearcoatNormalTexture.index];
-            MaterialParser._parseTextureTransform(material, clearcoatNormalTexture.extensions, context);
-        }
-    };
-    return KHR_materials_clearcoat;
-}(ExtensionParser);
-KHR_materials_clearcoat = __decorate([
-    registerExtension("KHR_materials_clearcoat")
-], KHR_materials_clearcoat);
-
-var KHR_materials_pbrSpecularGlossiness = /*#__PURE__*/ function(ExtensionParser) {
-    _inherits(KHR_materials_pbrSpecularGlossiness, ExtensionParser);
-    function KHR_materials_pbrSpecularGlossiness() {
-        return ExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_materials_pbrSpecularGlossiness.prototype;
-    _proto.createEngineResource = function createEngineResource(schema, context) {
-        var _context_glTFResource = context.glTFResource, engine = _context_glTFResource.engine, textures = _context_glTFResource.textures;
-        var material = new miniprogram.PBRSpecularMaterial(engine);
-        var diffuseFactor = schema.diffuseFactor, diffuseTexture = schema.diffuseTexture, specularFactor = schema.specularFactor, glossinessFactor = schema.glossinessFactor, specularGlossinessTexture = schema.specularGlossinessTexture;
-        if (diffuseFactor) {
-            material.baseColor = new miniprogram$1.Color(miniprogram$1.Color.linearToGammaSpace(diffuseFactor[0]), miniprogram$1.Color.linearToGammaSpace(diffuseFactor[1]), miniprogram$1.Color.linearToGammaSpace(diffuseFactor[2]), diffuseFactor[3]);
-        }
-        if (diffuseTexture) {
-            material.baseTexture = textures[diffuseTexture.index];
-            MaterialParser._parseTextureTransform(material, diffuseTexture.extensions, context);
-        }
-        if (specularFactor) {
-            material.specularColor = new miniprogram$1.Color(miniprogram$1.Color.linearToGammaSpace(specularFactor[0]), miniprogram$1.Color.linearToGammaSpace(specularFactor[1]), miniprogram$1.Color.linearToGammaSpace(specularFactor[2]));
-        }
-        if (glossinessFactor !== undefined) {
-            material.glossiness = glossinessFactor;
-        }
-        if (specularGlossinessTexture) {
-            material.specularGlossinessTexture = textures[specularGlossinessTexture.index];
-            MaterialParser._parseTextureTransform(material, specularGlossinessTexture.extensions, context);
-        }
-        return material;
-    };
-    return KHR_materials_pbrSpecularGlossiness;
-}(ExtensionParser);
-KHR_materials_pbrSpecularGlossiness = __decorate([
-    registerExtension("KHR_materials_pbrSpecularGlossiness")
-], KHR_materials_pbrSpecularGlossiness);
-
-var KHR_materials_unlit = /*#__PURE__*/ function(ExtensionParser) {
-    _inherits(KHR_materials_unlit, ExtensionParser);
-    function KHR_materials_unlit() {
-        return ExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_materials_unlit.prototype;
-    _proto.createEngineResource = function createEngineResource(schema, context) {
-        var engine = context.glTFResource.engine;
-        var material = new miniprogram.UnlitMaterial(engine);
-        return material;
-    };
-    return KHR_materials_unlit;
-}(ExtensionParser);
-KHR_materials_unlit = __decorate([
-    registerExtension("KHR_materials_unlit")
-], KHR_materials_unlit);
-
-var KHR_materials_variants = /*#__PURE__*/ function(ExtensionParser) {
-    _inherits(KHR_materials_variants, ExtensionParser);
-    function KHR_materials_variants() {
-        return ExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_materials_variants.prototype;
-    _proto.parseEngineResource = function parseEngineResource(schema, renderer, context) {
-        var _context_gltf = context.gltf, _context_gltf_extensions = _context_gltf.extensions, _context_gltf_extensions_KHR_materials_variants = _context_gltf_extensions.KHR_materials_variants, variantNames = _context_gltf_extensions_KHR_materials_variants.variants, glTFResource = context.glTFResource;
-        var mappings = schema.mappings;
-        for(var i = 0; i < mappings.length; i++){
-            var _mappings_i = mappings[i], material = _mappings_i.material, variants = _mappings_i.variants;
-            if (!glTFResource.variants) glTFResource.variants = [];
-            glTFResource.variants.push({
-                renderer: renderer,
-                material: glTFResource.materials[material],
-                variants: variants.map(function(index) {
-                    return variantNames[index].name;
-                })
-            });
-        }
-    };
-    return KHR_materials_variants;
-}(ExtensionParser);
-KHR_materials_variants = __decorate([
-    registerExtension("KHR_materials_variants")
-], KHR_materials_variants);
-
-var KHR_mesh_quantization = /*#__PURE__*/ function(ExtensionParser) {
-    _inherits(KHR_mesh_quantization, ExtensionParser);
-    function KHR_mesh_quantization() {
-        return ExtensionParser.apply(this, arguments);
-    }
-    return KHR_mesh_quantization;
-}(ExtensionParser);
-KHR_mesh_quantization = __decorate([
-    registerExtension("KHR_mesh_quantization")
-], KHR_mesh_quantization);
-
-var KHR_texture_transform = /*#__PURE__*/ function(ExtensionParser) {
-    _inherits(KHR_texture_transform, ExtensionParser);
-    function KHR_texture_transform() {
-        return ExtensionParser.apply(this, arguments);
-    }
-    var _proto = KHR_texture_transform.prototype;
-    _proto.parseEngineResource = function parseEngineResource(schema, material, context) {
-        var offset = schema.offset, rotation = schema.rotation, scale = schema.scale, texCoord = schema.texCoord;
-        if (offset) {
-            material.tilingOffset.z = offset[0];
-            material.tilingOffset.w = offset[1];
-        }
-        if (scale) {
-            material.tilingOffset.x = scale[0];
-            material.tilingOffset.y = scale[1];
-        }
-        if (rotation) {
-            miniprogram.Logger.warn("rotation in KHR_texture_transform is not supported now");
-        }
-        if (texCoord) {
-            miniprogram.Logger.warn("texCoord in KHR_texture_transform is not supported now");
-        }
-    };
-    return KHR_texture_transform;
-}(ExtensionParser);
-KHR_texture_transform = __decorate([
-    registerExtension("KHR_texture_transform")
-], KHR_texture_transform);
-
-var GalaceanMaterialsRemap = /*#__PURE__*/ function(ExtensionParser) {
-    _inherits(GalaceanMaterialsRemap, ExtensionParser);
-    function GalaceanMaterialsRemap() {
-        return ExtensionParser.apply(this, arguments);
-    }
-    var _proto = GalaceanMaterialsRemap.prototype;
-    _proto.createEngineResource = function createEngineResource(schema, context) {
-        var engine = context.glTFResource.engine;
-        // @ts-ignore
-        return engine.resourceManager.getResourceByRef(schema);
-    };
-    return GalaceanMaterialsRemap;
-}(ExtensionParser);
-GalaceanMaterialsRemap = __decorate([
-    registerExtension("OASIS_materials_remap")
-], GalaceanMaterialsRemap);
-
-function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
-    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-
-    if (it) return (it = it.call(o)).next.bind(it);
-    // Fallback for engines without symbol support
-    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
-        if (it) o = it;
-
-        var i = 0;
-
-        return function() {
-            if (i >= o.length) return { done: true };
-
-            return { done: false, value: o[i++] };
-        };
-    }
-
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-var AnimationParser = /*#__PURE__*/ function(Parser) {
-    _inherits(AnimationParser, Parser);
-    function AnimationParser() {
-        return Parser.apply(this, arguments);
-    }
-    var _proto = AnimationParser.prototype;
-    _proto.parse = function parse(context) {
-        var gltf = context.gltf; context.buffers; var glTFResource = context.glTFResource;
-        var entities = glTFResource.entities;
-        var animations = gltf.animations, accessors = gltf.accessors;
-        if (!animations) {
-            return;
-        }
-        var animationClipsPromiseInfo = context.animationClipsPromiseInfo;
-        var animationClipCount = animations.length;
-        var animationClips = new Array(animationClipCount);
-        var animationsIndices = new Array(animationClipCount);
-        for(var i = 0; i < animationClipCount; i++){
-            var gltfAnimation = animations[i];
-            var channels = gltfAnimation.channels, samplers = gltfAnimation.samplers, _gltfAnimation_name = gltfAnimation.name, name = _gltfAnimation_name === void 0 ? "AnimationClip" + i : _gltfAnimation_name;
-            var animationClip = new miniprogram.AnimationClip(name);
-            var sampleDataCollection = new Array();
-            // parse samplers
-            for(var j = 0, m = samplers.length; j < m; j++){
-                var gltfSampler = samplers[j];
-                var inputAccessor = accessors[gltfSampler.input];
-                var outputAccessor = accessors[gltfSampler.output];
-                var input = GLTFUtil.getAccessorBuffer(context, gltf, inputAccessor).data;
-                var output = GLTFUtil.getAccessorBuffer(context, gltf, outputAccessor).data;
+    /**
+   * @internal
+   */ GLTFAnimationParser._parseStandardProperty = function _parseStandardProperty(context, animationClip, animationInfo) {
+        var _loop = function(j, m) {
+            var gltfSampler = samplers[j];
+            var inputAccessor = accessors[gltfSampler.input];
+            var outputAccessor = accessors[gltfSampler.output];
+            var promise = Promise.all([
+                GLTFUtils.getAccessorBuffer(context, bufferViews, inputAccessor),
+                GLTFUtils.getAccessorBuffer(context, bufferViews, outputAccessor)
+            ]).then(function(bufferInfos) {
+                var input = bufferInfos[0].data;
+                var output = bufferInfos[1].data;
                 if (outputAccessor.normalized) {
-                    var scale = GLTFUtil.getNormalizedComponentScale(outputAccessor.componentType);
+                    var scale = GLTFUtils.getNormalizedComponentScale(outputAccessor.componentType);
                     var scaled = new Float32Array(output.length);
                     for(var k = 0, v = output.length; k < v; k++){
                         scaled[k] = output[k] * scale;
@@ -1479,7 +1418,7 @@ var AnimationParser = /*#__PURE__*/ function(Parser) {
                 var outputStride = output.length / input.length;
                 var _gltfSampler_interpolation;
                 var interpolation = (_gltfSampler_interpolation = gltfSampler.interpolation) != null ? _gltfSampler_interpolation : AnimationSamplerInterpolation.Linear;
-                var samplerInterpolation = void 0;
+                var samplerInterpolation;
                 switch(interpolation){
                     case AnimationSamplerInterpolation.CubicSpine:
                         samplerInterpolation = miniprogram.InterpolationType.CubicSpine;
@@ -1499,9 +1438,21 @@ var AnimationParser = /*#__PURE__*/ function(Parser) {
                     output: output,
                     outputSize: outputStride
                 });
-            }
-            for(var j1 = 0, m1 = channels.length; j1 < m1; j1++){
-                var gltfChannel = channels[j1];
+            });
+            promises.push(promise);
+        };
+        var _this = this;
+        var glTF = context.glTF, glTFResource = context.glTFResource;
+        var entities = glTFResource.entities;
+        var accessors = glTF.accessors, bufferViews = glTF.bufferViews;
+        var channels = animationInfo.channels, samplers = animationInfo.samplers;
+        var sampleDataCollection = new Array();
+        var promises = new Array();
+        // parse samplers
+        for(var j = 0, m = samplers.length; j < m; j++)_loop(j);
+        return Promise.all(promises).then(function() {
+            for(var j = 0, m = channels.length; j < m; j++){
+                var gltfChannel = channels[j];
                 var target = gltfChannel.target;
                 var channelTargetEntity = entities[target.node];
                 var relativePath = "";
@@ -1530,25 +1481,15 @@ var AnimationParser = /*#__PURE__*/ function(Parser) {
                         propertyName = "blendShapeWeights";
                         break;
                 }
-                var curve = this._addCurve(target.path, gltfChannel, sampleDataCollection);
+                var curve = _this._addCurve(target.path, gltfChannel, sampleDataCollection);
                 animationClip.addCurveBinding(relativePath, ComponentType, propertyName, curve);
             }
-            animationClips[i] = animationClip;
-            animationsIndices[i] = {
-                name: name,
-                index: i
-            };
-        }
-        glTFResource.animations = animationClips;
-        // @ts-ignore for editor
-        glTFResource._animationsIndices = animationsIndices;
-        animationClipsPromiseInfo.resolve(animationClips);
-        return animationClipsPromiseInfo.promise;
+        });
     };
-    _proto._addCurve = function _addCurve(animationchannelTargetPath, gltfChannel, sampleDataCollection) {
+    GLTFAnimationParser._addCurve = function _addCurve(animationChannelTargetPath, gltfChannel, sampleDataCollection) {
         var sampleData = sampleDataCollection[gltfChannel.sampler];
         var input = sampleData.input, output = sampleData.output, outputSize = sampleData.outputSize;
-        switch(animationchannelTargetPath){
+        switch(animationChannelTargetPath){
             case AnimationChannelTargetPath.TRANSLATION:
             case AnimationChannelTargetPath.SCALE:
                 {
@@ -1613,38 +1554,43 @@ var AnimationParser = /*#__PURE__*/ function(Parser) {
                 }
         }
     };
-    return AnimationParser;
-}(Parser);
+    return GLTFAnimationParser;
+}(GLTFParser);
 
-var BufferParser = /*#__PURE__*/ function(Parser) {
-    _inherits(BufferParser, Parser);
-    function BufferParser() {
-        return Parser.apply(this, arguments);
+var GLTFBufferParser = /*#__PURE__*/ function(GLTFParser) {
+    _inherits(GLTFBufferParser, GLTFParser);
+    function GLTFBufferParser() {
+        return GLTFParser.apply(this, arguments);
     }
-    var _proto = BufferParser.prototype;
+    var _proto = GLTFBufferParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource;
+        var glTFResource = context.glTFResource, contentRestorer = context.contentRestorer;
         var url = glTFResource.url;
-        if (this._isGLB(url)) {
-            return miniprogram.request(url, {
-                type: "arraybuffer"
-            }).then(GLTFUtil.parseGLB).then(function(param) {
-                var gltf = param.gltf, buffers = param.buffers;
-                context.gltf = gltf;
-                context.buffers = buffers;
+        var restoreBufferRequests = contentRestorer.bufferRequests;
+        var requestConfig = {
+            type: "arraybuffer"
+        };
+        var isGLB = this._isGLB(url);
+        contentRestorer.isGLB = isGLB;
+        if (isGLB) {
+            return miniprogram.request(url, requestConfig).then(function(glb) {
+                restoreBufferRequests.push(new BufferRequestInfo(url, requestConfig));
+                return GLTFUtils.parseGLB(context, glb);
+            }).then(function(param) {
+                var glTF = param.glTF, buffers = param.buffers;
+                context.glTF = glTF;
+                context._buffers = buffers;
             });
         } else {
             return miniprogram.request(url, {
                 type: "json"
-            }).then(function(gltf) {
-                context.gltf = gltf;
-                return Promise.all(gltf.buffers.map(function(buffer) {
-                    return miniprogram.request(GLTFUtil.parseRelativeUrl(url, buffer.uri), {
-                        type: "arraybuffer"
-                    });
-                })).then(function(buffers) {
-                    context.buffers = buffers;
-                });
+            }).then(function(glTF) {
+                context.glTF = glTF;
+                context._buffers = Promise.all(glTF.buffers.map(function(buffer) {
+                    var absoluteUrl = miniprogram.Utils.resolveAbsoluteUrl(url, buffer.uri);
+                    restoreBufferRequests.push(new BufferRequestInfo(absoluteUrl, requestConfig));
+                    return miniprogram.request(absoluteUrl, requestConfig);
+                }));
             });
         }
     };
@@ -1652,24 +1598,24 @@ var BufferParser = /*#__PURE__*/ function(Parser) {
         var index = url.lastIndexOf(".");
         return url.substring(index + 1, index + 4) === "glb";
     };
-    return BufferParser;
-}(Parser);
+    return GLTFBufferParser;
+}(GLTFParser);
 
-var EntityParser = /*#__PURE__*/ function(Parser) {
-    _inherits(EntityParser, Parser);
-    function EntityParser() {
-        return Parser.apply(this, arguments);
+var GLTFEntityParser = /*#__PURE__*/ function(GLTFParser) {
+    _inherits(GLTFEntityParser, GLTFParser);
+    function GLTFEntityParser() {
+        return GLTFParser.apply(this, arguments);
     }
-    var _proto = EntityParser.prototype;
+    var _proto = GLTFEntityParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource, nodes = context.gltf.nodes;
+        var glTFResource = context.glTFResource, nodes = context.glTF.nodes;
         var engine = glTFResource.engine;
         if (!nodes) return;
         var entities = [];
         for(var i = 0; i < nodes.length; i++){
             var gltfNode = nodes[i];
             var matrix = gltfNode.matrix, translation = gltfNode.translation, rotation = gltfNode.rotation, scale = gltfNode.scale;
-            var entity = new miniprogram.Entity(engine, gltfNode.name || "" + EntityParser._defaultName + i);
+            var entity = new miniprogram.Entity(engine, gltfNode.name || "" + GLTFEntityParser._defaultName + i);
             var transform = entity.transform;
             if (matrix) {
                 var localMatrix = transform.localMatrix;
@@ -1693,7 +1639,7 @@ var EntityParser = /*#__PURE__*/ function(Parser) {
         this._createSceneRoots(context, glTFResource);
     };
     _proto._buildEntityTree = function _buildEntityTree(context, glTFResource) {
-        var nodes = context.gltf.nodes;
+        var nodes = context.glTF.nodes;
         var entities = glTFResource.entities;
         for(var i = 0; i < nodes.length; i++){
             var children = nodes[i].children;
@@ -1707,7 +1653,7 @@ var EntityParser = /*#__PURE__*/ function(Parser) {
         }
     };
     _proto._createSceneRoots = function _createSceneRoots(context, glTFResource) {
-        var _context_gltf = context.gltf, tmp = _context_gltf.scene, sceneID = tmp === void 0 ? 0 : tmp, scenes = _context_gltf.scenes;
+        var _context_glTF = context.glTF, tmp = _context_glTF.scene, sceneID = tmp === void 0 ? 0 : tmp, scenes = _context_glTF.scenes;
         var engine = glTFResource.engine, entities = glTFResource.entities;
         if (!scenes) return;
         var sceneRoots = [];
@@ -1723,337 +1669,433 @@ var EntityParser = /*#__PURE__*/ function(Parser) {
                 }
                 sceneRoots[i] = rootEntity;
             }
+            // @ts-ignore
+            sceneRoots[i]._hookResource = glTFResource;
+            // @ts-ignore
+            glTFResource._addReferCount(1);
         }
         glTFResource.sceneRoots = sceneRoots;
         glTFResource.defaultSceneRoot = sceneRoots[sceneID];
     };
-    return EntityParser;
-}(Parser);
+    return GLTFEntityParser;
+}(GLTFParser);
 (function() {
-    /** @internal */ EntityParser._defaultName = "_GLTF_ENTITY_";
+    /** @internal */ GLTFEntityParser._defaultName = "_GLTF_ENTITY_";
 })();
 
-var MeshParser = /*#__PURE__*/ function(Parser1) {
-    _inherits(MeshParser, Parser1);
-    function MeshParser() {
-        return Parser1.apply(this, arguments);
+var GLTFMaterialParser = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFMaterialParser, GLTFParser1);
+    function GLTFMaterialParser() {
+        return GLTFParser1.apply(this, arguments);
     }
-    var _proto = MeshParser.prototype;
+    var _proto = GLTFMaterialParser.prototype;
     _proto.parse = function parse(context) {
-        var _loop = function(i) {
-            var _loop = function(j) {
-                var gltfPrimitive = gltfMesh.primitives[j];
-                var _gltfPrimitive_extensions = gltfPrimitive.extensions, extensions = _gltfPrimitive_extensions === void 0 ? {} : _gltfPrimitive_extensions;
-                var KHR_draco_mesh_compression = extensions.KHR_draco_mesh_compression;
-                primitivePromises[j] = new Promise(function(resolve) {
-                    var mesh = new miniprogram.ModelMesh(engine, gltfMesh.name || j + "");
-                    if (KHR_draco_mesh_compression) {
-                        Parser.createEngineResource("KHR_draco_mesh_compression", KHR_draco_mesh_compression, context, gltfPrimitive).then(function(decodedGeometry) {
-                            return _this._parseMeshFromGLTFPrimitiveDraco(mesh, gltfMesh, gltfPrimitive, gltf, function(attributeSemantic) {
-                                for(var j = 0; j < decodedGeometry.attributes.length; j++){
-                                    if (decodedGeometry.attributes[j].name === attributeSemantic) {
-                                        return decodedGeometry.attributes[j].array;
-                                    }
-                                }
-                                return null;
-                            }, function(attributeSemantic, shapeIndex) {
-                                throw "BlendShape animation is not supported when using draco.";
-                            }, function() {
-                                return decodedGeometry.index.array;
-                            }, context.keepMeshData);
-                        }).then(resolve);
-                    } else {
-                        _this._parseMeshFromGLTFPrimitive(context, mesh, gltfMesh, gltfPrimitive, gltf, function(attributeSemantic) {
-                            return null;
-                        }, function(attributeName, shapeIndex) {
-                            var shapeAccessorIdx = gltfPrimitive.targets[shapeIndex];
-                            var attributeAccessorIdx = shapeAccessorIdx[attributeName];
-                            if (attributeAccessorIdx) {
-                                var accessor = gltf.accessors[attributeAccessorIdx];
-                                return GLTFUtil.getAccessorData(gltf, accessor, buffers);
-                            } else {
-                                return null;
-                            }
-                        }, function() {
-                            var indexAccessor = gltf.accessors[gltfPrimitive.indices];
-                            return GLTFUtil.getAccessorData(gltf, indexAccessor, buffers);
-                        }, context.keepMeshData).then(resolve);
+        var glTF = context.glTF, glTFResource = context.glTFResource, materialsPromiseInfo = context.materialsPromiseInfo;
+        if (!glTF.materials) return;
+        var engine = glTFResource.engine;
+        var materialPromises = [];
+        for(var i = 0; i < glTF.materials.length; i++){
+            var materialInfo = glTF.materials[i];
+            var material = GLTFParser.executeExtensionsCreateAndParse(materialInfo.extensions, context, materialInfo);
+            if (!material) {
+                material = new miniprogram.PBRMaterial(engine);
+                material.name = materialInfo.name;
+                GLTFMaterialParser._parseStandardProperty(context, material, materialInfo);
+            }
+            materialPromises.push(material);
+        }
+        return miniprogram.AssetPromise.all(materialPromises).then(function(materials) {
+            glTFResource.materials = materials;
+            for(var i = 0; i < glTF.materials.length; i++){
+                var materialInfo = glTF.materials[i];
+                GLTFParser.executeExtensionsAdditiveAndParse(materialInfo.extensions, context, materials[i], materialInfo);
+            }
+            materialsPromiseInfo.resolve(materials);
+            return materialsPromiseInfo.promise;
+        });
+    };
+    /**
+   * @internal
+   */ GLTFMaterialParser._checkOtherTextureTransform = function _checkOtherTextureTransform(texture, textureName) {
+        var _texture_extensions;
+        if ((_texture_extensions = texture.extensions) == null ? void 0 : _texture_extensions.KHR_texture_transform) {
+            miniprogram.Logger.warn("" + textureName + " texture always use the KHR_texture_transform of the base texture.");
+        }
+    };
+    /**
+   * @internal
+   */ GLTFMaterialParser._parseStandardProperty = function _parseStandardProperty(context, material, materialInfo) {
+        var textures = context.glTFResource.textures;
+        var pbrMetallicRoughness = materialInfo.pbrMetallicRoughness, normalTexture = materialInfo.normalTexture, occlusionTexture = materialInfo.occlusionTexture, emissiveTexture = materialInfo.emissiveTexture, emissiveFactor = materialInfo.emissiveFactor, alphaMode = materialInfo.alphaMode, alphaCutoff = materialInfo.alphaCutoff, doubleSided = materialInfo.doubleSided;
+        if (pbrMetallicRoughness) {
+            var baseColorFactor = pbrMetallicRoughness.baseColorFactor, baseColorTexture = pbrMetallicRoughness.baseColorTexture, metallicFactor = pbrMetallicRoughness.metallicFactor, roughnessFactor = pbrMetallicRoughness.roughnessFactor, metallicRoughnessTexture = pbrMetallicRoughness.metallicRoughnessTexture;
+            if (baseColorFactor) {
+                material.baseColor = new miniprogram$1.Color(miniprogram$1.Color.linearToGammaSpace(baseColorFactor[0]), miniprogram$1.Color.linearToGammaSpace(baseColorFactor[1]), miniprogram$1.Color.linearToGammaSpace(baseColorFactor[2]), baseColorFactor[3]);
+            }
+            if (baseColorTexture) {
+                material.baseTexture = textures[baseColorTexture.index];
+                GLTFParser.executeExtensionsAdditiveAndParse(baseColorTexture.extensions, context, material, baseColorTexture);
+            }
+            if (material.constructor === miniprogram.PBRMaterial) {
+                material.metallic = metallicFactor != null ? metallicFactor : 1;
+                material.roughness = roughnessFactor != null ? roughnessFactor : 1;
+                if (metallicRoughnessTexture) {
+                    material.roughnessMetallicTexture = textures[metallicRoughnessTexture.index];
+                    GLTFMaterialParser._checkOtherTextureTransform(metallicRoughnessTexture, "Roughness metallic");
+                }
+            }
+        }
+        if (material.constructor === miniprogram.PBRMaterial || material.constructor === miniprogram.PBRSpecularMaterial) {
+            if (emissiveTexture) {
+                material.emissiveTexture = textures[emissiveTexture.index];
+                GLTFMaterialParser._checkOtherTextureTransform(emissiveTexture, "Emissive");
+            }
+            if (emissiveFactor) {
+                material.emissiveColor = new miniprogram$1.Color(miniprogram$1.Color.linearToGammaSpace(emissiveFactor[0]), miniprogram$1.Color.linearToGammaSpace(emissiveFactor[1]), miniprogram$1.Color.linearToGammaSpace(emissiveFactor[2]));
+            }
+            if (normalTexture) {
+                var index = normalTexture.index, scale = normalTexture.scale;
+                material.normalTexture = textures[index];
+                GLTFMaterialParser._checkOtherTextureTransform(normalTexture, "Normal");
+                if (scale !== undefined) {
+                    material.normalTextureIntensity = scale;
+                }
+            }
+            if (occlusionTexture) {
+                var index1 = occlusionTexture.index, strength = occlusionTexture.strength, texCoord = occlusionTexture.texCoord;
+                material.occlusionTexture = textures[index1];
+                GLTFMaterialParser._checkOtherTextureTransform(occlusionTexture, "Occlusion");
+                if (strength !== undefined) {
+                    material.occlusionTextureIntensity = strength;
+                }
+                if (texCoord === miniprogram.TextureCoordinate.UV1) {
+                    material.occlusionTextureCoord = miniprogram.TextureCoordinate.UV1;
+                } else if (texCoord > miniprogram.TextureCoordinate.UV1) {
+                    miniprogram.Logger.warn("Occlusion texture uv coordinate must be UV0 or UV1.");
+                }
+            }
+        }
+        if (doubleSided) {
+            material.renderFace = miniprogram.RenderFace.Double;
+        } else {
+            material.renderFace = miniprogram.RenderFace.Front;
+        }
+        switch(alphaMode){
+            case MaterialAlphaMode.OPAQUE:
+                material.isTransparent = false;
+                break;
+            case MaterialAlphaMode.BLEND:
+                material.isTransparent = true;
+                break;
+            case MaterialAlphaMode.MASK:
+                material.alphaCutoff = alphaCutoff != null ? alphaCutoff : 0.5;
+                break;
+        }
+    };
+    return GLTFMaterialParser;
+}(GLTFParser);
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+
+var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFMeshParser, GLTFParser1);
+    function GLTFMeshParser() {
+        return GLTFParser1.apply(this, arguments);
+    }
+    var _proto = GLTFMeshParser.prototype;
+    _proto.parse = function parse(context) {
+        var _loop = function(i) {
+            var _loop = function(j) {
+                var gltfPrimitive = gltfMesh.primitives[j];
+                primitivePromises[j] = new Promise(function(resolve) {
+                    var mesh = GLTFParser.executeExtensionsCreateAndParse(gltfPrimitive.extensions, context, gltfPrimitive, gltfMesh);
+                    if (mesh) {
+                        if (_instanceof(mesh, miniprogram.ModelMesh)) {
+                            resolve(mesh);
+                        } else {
+                            mesh.then(function(mesh) {
+                                return resolve(mesh);
+                            });
+                        }
+                    } else {
+                        var mesh1 = new miniprogram.ModelMesh(engine, gltfMesh.name || j + "");
+                        var meshRestoreInfo = new ModelMeshRestoreInfo();
+                        meshRestoreInfo.mesh = mesh1;
+                        context.contentRestorer.meshes.push(meshRestoreInfo);
+                        GLTFMeshParser._parseMeshFromGLTFPrimitive(context, mesh1, meshRestoreInfo, gltfMesh, gltfPrimitive, glTF, function(attributeSemantic) {
+                            return null;
+                        }, function(attributeName, shapeIndex) {
+                            var shapeAccessorIdx = gltfPrimitive.targets[shapeIndex];
+                            var attributeAccessorIdx = shapeAccessorIdx[attributeName];
+                            if (attributeAccessorIdx) {
+                                var accessor = glTF.accessors[attributeAccessorIdx];
+                                return GLTFUtils.getAccessorBuffer(context, context.glTF.bufferViews, accessor);
+                            } else {
+                                return null;
+                            }
+                        }, function() {
+                            var indexAccessor = glTF.accessors[gltfPrimitive.indices];
+                            return context.getBuffers().then(function(buffers) {
+                                return GLTFUtils.getAccessorData(glTF, indexAccessor, buffers);
+                            });
+                        }, context.keepMeshData).then(resolve);
                     }
                 });
             };
-            var gltfMesh = gltf.meshes[i];
+            var gltfMesh = glTF.meshes[i];
             var primitivePromises = [];
             for(var j = 0; j < gltfMesh.primitives.length; j++)_loop(j);
             meshPromises[i] = Promise.all(primitivePromises);
         };
-        var _this = this;
-        var gltf = context.gltf, buffers = context.buffers, glTFResource = context.glTFResource;
+        var glTF = context.glTF, glTFResource = context.glTFResource;
         var engine = glTFResource.engine;
-        if (!gltf.meshes) return;
+        if (!glTF.meshes) return;
         var meshesPromiseInfo = context.meshesPromiseInfo;
         var meshPromises = [];
-        for(var i = 0; i < gltf.meshes.length; i++)_loop(i);
+        for(var i = 0; i < glTF.meshes.length; i++)_loop(i);
         miniprogram.AssetPromise.all(meshPromises).then(function(meshes) {
             glTFResource.meshes = meshes;
             meshesPromiseInfo.resolve(meshes);
         }).catch(meshesPromiseInfo.reject);
         return meshesPromiseInfo.promise;
     };
-    _proto._parseMeshFromGLTFPrimitive = function _parseMeshFromGLTFPrimitive(context, mesh, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
-        var accessors = gltf.accessors;
-        context.buffers;
-        var attributes = gltfPrimitive.attributes, targets = gltfPrimitive.targets, indices = gltfPrimitive.indices, mode = gltfPrimitive.mode;
-        var engine = mesh.engine;
-        var vertexElements = new Array();
-        var vertexCount;
-        var bufferBindIndex = 0;
-        var positions;
-        keepMeshData && (positions = new Array(vertexCount));
-        for(var attribute in attributes){
+    /**
+   * @internal
+   */ GLTFMeshParser._parseMeshFromGLTFPrimitive = function _parseMeshFromGLTFPrimitive(context, mesh, meshRestoreInfo, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
+        var _loop = function(attribute) {
             var accessor = accessors[attributes[attribute]];
-            var accessorBuffer = GLTFUtil.getAccessorBuffer(context, gltf, accessor);
-            var dataElmentSize = GLTFUtil.getAccessorTypeSize(accessor.type);
-            var attributeCount = accessor.count;
-            var vertices = accessorBuffer.data;
-            var vertexElement = void 0;
-            var meshId = mesh.instanceId;
-            var vertexBindingInfos = accessorBuffer.vertexBindingInfos;
-            var elementFormat = GLTFUtil.getElementFormat(accessor.componentType, dataElmentSize, accessor.normalized);
-            if (accessorBuffer.interleaved) {
-                var byteOffset = accessor.byteOffset || 0;
-                var stride = accessorBuffer.stride;
-                var elementOffset = byteOffset % stride;
-                if (vertexBindingInfos[meshId] === undefined) {
-                    vertexElement = new miniprogram.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
-                    var vertexBuffer = accessorBuffer.vertexBuffer;
-                    if (!vertexBuffer) {
-                        vertexBuffer = new miniprogram.Buffer(engine, miniprogram.BufferBindFlag.VertexBuffer, vertices.byteLength, miniprogram.BufferUsage.Static);
-                        vertexBuffer.setData(vertices);
-                        accessorBuffer.vertexBuffer = vertexBuffer;
+            var promise = GLTFUtils.getAccessorBuffer(context, gltf.bufferViews, accessor).then(function(accessorBuffer) {
+                var dataElementSize = GLTFUtils.getAccessorTypeSize(accessor.type);
+                var accessorCount = accessor.count;
+                var vertices = accessorBuffer.data;
+                var vertexElement;
+                var meshId = mesh.instanceId;
+                var vertexBindingInfos = accessorBuffer.vertexBindingInfos;
+                var elementNormalized = accessor.normalized;
+                var elementFormat = GLTFUtils.getElementFormat(accessor.componentType, dataElementSize, elementNormalized);
+                var scaleFactor;
+                elementNormalized && (scaleFactor = GLTFUtils.getNormalizedComponentScale(accessor.componentType));
+                var elementOffset;
+                if (accessorBuffer.interleaved) {
+                    var byteOffset = accessor.byteOffset || 0;
+                    var stride = accessorBuffer.stride;
+                    elementOffset = byteOffset % stride;
+                    if (vertexBindingInfos[meshId] === undefined) {
+                        vertexElement = new miniprogram.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
+                        var vertexBuffer = accessorBuffer.vertexBuffer;
+                        if (!vertexBuffer) {
+                            vertexBuffer = new miniprogram.Buffer(engine, miniprogram.BufferBindFlag.VertexBuffer, vertices.byteLength, miniprogram.BufferUsage.Static);
+                            vertexBuffer.setData(vertices);
+                            accessorBuffer.vertexBuffer = vertexBuffer;
+                            meshRestoreInfo.vertexBuffers.push(new BufferRestoreInfo(vertexBuffer, accessorBuffer.restoreInfo));
+                        }
+                        mesh.setVertexBufferBinding(vertexBuffer, stride, bufferBindIndex);
+                        vertexBindingInfos[meshId] = bufferBindIndex++;
+                    } else {
+                        vertexElement = new miniprogram.VertexElement(attribute, elementOffset, elementFormat, vertexBindingInfos[meshId]);
                     }
-                    mesh.setVertexBufferBinding(vertexBuffer, stride, bufferBindIndex);
-                    vertexBindingInfos[meshId] = bufferBindIndex++;
                 } else {
-                    vertexElement = new miniprogram.VertexElement(attribute, elementOffset, elementFormat, vertexBindingInfos[meshId]);
+                    elementOffset = 0;
+                    vertexElement = new miniprogram.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
+                    var vertexBuffer1 = new miniprogram.Buffer(engine, miniprogram.BufferBindFlag.VertexBuffer, vertices.byteLength, miniprogram.BufferUsage.Static);
+                    vertexBuffer1.setData(vertices);
+                    meshRestoreInfo.vertexBuffers.push(new BufferRestoreInfo(vertexBuffer1, accessorBuffer.restoreInfo));
+                    mesh.setVertexBufferBinding(vertexBuffer1, accessorBuffer.stride, bufferBindIndex);
+                    vertexBindingInfos[meshId] = bufferBindIndex++;
                 }
-            } else {
-                vertexElement = new miniprogram.VertexElement(attribute, 0, elementFormat, bufferBindIndex);
-                var vertexBuffer1 = new miniprogram.Buffer(engine, miniprogram.BufferBindFlag.VertexBuffer, vertices.byteLength, miniprogram.BufferUsage.Static);
-                vertexBuffer1.setData(vertices);
-                mesh.setVertexBufferBinding(vertexBuffer1, accessorBuffer.stride, bufferBindIndex);
-                vertexBindingInfos[meshId] = bufferBindIndex++;
-            }
-            vertexElements.push(vertexElement);
-            if (attribute === "POSITION") {
-                vertexCount = attributeCount;
-                var _mesh_bounds = mesh.bounds, min = _mesh_bounds.min, max = _mesh_bounds.max;
-                if (accessor.min && accessor.max) {
-                    min.copyFromArray(accessor.min);
-                    max.copyFromArray(accessor.max);
-                    if (keepMeshData) {
-                        var stride1 = vertices.length / attributeCount;
-                        for(var j = 0; j < attributeCount; j++){
-                            var offset = j * stride1;
-                            positions[j] = new miniprogram$1.Vector3(vertices[offset], vertices[offset + 1], vertices[offset + 2]);
+                vertexElements.push(vertexElement);
+                if (attribute === "POSITION") {
+                    vertexCount = accessorCount;
+                    var _mesh_bounds = mesh.bounds, min = _mesh_bounds.min, max = _mesh_bounds.max;
+                    if (accessor.min && accessor.max) {
+                        min.copyFromArray(accessor.min);
+                        max.copyFromArray(accessor.max);
+                        if (keepMeshData) {
+                            var baseOffset = elementOffset / vertices.BYTES_PER_ELEMENT;
+                            var stride1 = vertices.length / accessorCount;
+                            for(var j = 0; j < accessorCount; j++){
+                                var offset = baseOffset + j * stride1;
+                                var position = new miniprogram$1.Vector3(vertices[offset], vertices[offset + 1], vertices[offset + 2]);
+                                elementNormalized && position.scale(scaleFactor);
+                                positions[j] = position;
+                            }
+                        }
+                    } else {
+                        var position1 = GLTFMeshParser._tempVector3;
+                        min.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+                        max.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+                        var baseOffset1 = elementOffset / vertices.BYTES_PER_ELEMENT;
+                        var stride2 = vertices.length / accessorCount;
+                        for(var j1 = 0; j1 < accessorCount; j1++){
+                            var offset1 = baseOffset1 + j1 * stride2;
+                            position1.copyFromArray(vertices, offset1);
+                            miniprogram$1.Vector3.min(min, position1, min);
+                            miniprogram$1.Vector3.max(max, position1, max);
+                            if (keepMeshData) {
+                                var clonePosition = position1.clone();
+                                elementNormalized && clonePosition.scale(scaleFactor);
+                                positions[j1] = clonePosition;
+                            }
                         }
                     }
-                } else {
-                    var position = MeshParser._tempVector3;
-                    min.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-                    max.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-                    var stride2 = vertices.length / attributeCount;
-                    for(var j1 = 0; j1 < attributeCount; j1++){
-                        var offset1 = j1 * stride2;
-                        position.copyFromArray(vertices, offset1);
-                        miniprogram$1.Vector3.min(min, position, min);
-                        miniprogram$1.Vector3.max(max, position, max);
-                        keepMeshData && (positions[j1] = position.clone());
+                    if (elementNormalized) {
+                        min.scale(scaleFactor);
+                        max.scale(scaleFactor);
+                    }
+                } else if (attribute === "JOINTS_0" && keepMeshData) {
+                    var baseOffset2 = elementOffset / vertices.BYTES_PER_ELEMENT;
+                    var stride3 = vertices.length / accessorCount;
+                    for(var j2 = 0; j2 < accessorCount; j2++){
+                        var offset2 = baseOffset2 + j2 * stride3;
+                        var boneIndex = new miniprogram$1.Vector4(vertices[offset2], vertices[offset2 + 1], vertices[offset2 + 2], vertices[offset2 + 3]);
+                        elementNormalized && boneIndex.scale(scaleFactor);
+                        boneIndices[j2] = boneIndex;
+                    }
+                } else if (attribute === "WEIGHTS_0" && keepMeshData) {
+                    var baseOffset3 = elementOffset / vertices.BYTES_PER_ELEMENT;
+                    var stride4 = vertices.length / accessorCount;
+                    for(var j3 = 0; j3 < accessorCount; j3++){
+                        var offset3 = baseOffset3 + j3 * stride4;
+                        var boneWeight = new miniprogram$1.Vector4(vertices[offset3], vertices[offset3 + 1], vertices[offset3 + 2], vertices[offset3 + 3]);
+                        elementNormalized && boneWeight.scale(scaleFactor);
+                        boneWeights[j3] = boneWeight;
                     }
                 }
-                if (accessor.normalized) {
-                    var sacleFactor = GLTFUtil.getNormalizedComponentScale(accessor.componentType);
-                    min.scale(sacleFactor);
-                    max.scale(sacleFactor);
-                }
-            }
-        }
-        mesh.setVertexElements(vertexElements);
-        // Indices
-        if (indices !== undefined) {
-            var indexAccessor = gltf.accessors[indices];
-            var indexData = getIndexBufferData();
-            mesh.setIndices(indexData);
-            mesh.addSubMesh(0, indexAccessor.count, mode);
-        } else {
-            mesh.addSubMesh(0, vertexCount, mode);
-        }
-        // BlendShapes
-        targets && this._createBlendShape(mesh, gltfMesh, targets, getBlendShapeData);
-        mesh.uploadData(!keepMeshData);
-        //@ts-ignore
-        mesh._positions = positions;
-        return Promise.resolve(mesh);
-    };
-    _proto._createBlendShape = function _createBlendShape(mesh, glTFMesh, glTFTargets, getBlendShapeData) {
-        var blendShapeNames = glTFMesh.extras ? glTFMesh.extras.targetNames : null;
-        for(var i = 0, n = glTFTargets.length; i < n; i++){
-            var name = blendShapeNames ? blendShapeNames[i] : "blendShape" + i;
-            var deltaPosBuffer = getBlendShapeData("POSITION", i);
-            var deltaNorBuffer = getBlendShapeData("NORMAL", i);
-            var deltaTanBuffer = getBlendShapeData("TANGENT", i);
-            var deltaPositions = deltaPosBuffer ? GLTFUtil.floatBufferToVector3Array(deltaPosBuffer) : null;
-            var deltaNormals = deltaNorBuffer ? GLTFUtil.floatBufferToVector3Array(deltaNorBuffer) : null;
-            var deltaTangents = deltaTanBuffer ? GLTFUtil.floatBufferToVector3Array(deltaTanBuffer) : null;
-            var blendShape = new miniprogram.BlendShape(name);
-            blendShape.addFrame(1.0, deltaPositions, deltaNormals, deltaTangents);
-            mesh.addBlendShape(blendShape);
-        }
-    };
-    /**
-   * @deprecated
-   */ _proto._parseMeshFromGLTFPrimitiveDraco = function _parseMeshFromGLTFPrimitiveDraco(mesh, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
+            });
+            promises.push(promise);
+        };
+        var accessors = gltf.accessors;
         var attributes = gltfPrimitive.attributes, targets = gltfPrimitive.targets, indices = gltfPrimitive.indices, mode = gltfPrimitive.mode;
+        var engine = mesh.engine;
+        var vertexElements = new Array();
         var vertexCount;
-        var accessors = gltf.accessors;
-        var accessor = accessors[attributes["POSITION"]];
-        var positionBuffer = getVertexBufferData("POSITION");
-        var positions = GLTFUtil.floatBufferToVector3Array(positionBuffer);
-        mesh.setPositions(positions);
-        var bounds = mesh.bounds;
-        vertexCount = accessor.count;
-        if (accessor.min && accessor.max) {
-            bounds.min.copyFromArray(accessor.min);
-            bounds.max.copyFromArray(accessor.max);
-        } else {
-            var position = MeshParser._tempVector3;
-            var min = bounds.min, max = bounds.max;
-            min.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-            max.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-            var stride = positionBuffer.length / vertexCount;
-            for(var j = 0; j < vertexCount; j++){
-                var offset = j * stride;
-                position.copyFromArray(positionBuffer, offset);
-                miniprogram$1.Vector3.min(min, position, min);
-                miniprogram$1.Vector3.max(max, position, max);
-            }
+        var bufferBindIndex = 0;
+        var positions;
+        var boneIndices;
+        var boneWeights;
+        if (keepMeshData) {
+            positions = new Array(vertexCount);
+            boneIndices = new Array(vertexCount);
+            boneWeights = new Array(vertexCount);
         }
-        for(var attributeSemantic in attributes){
-            if (attributeSemantic === "POSITION") {
-                continue;
+        var promises = new Array();
+        for(var attribute in attributes)_loop(attribute);
+        return Promise.all(promises).then(function() {
+            mesh.setVertexElements(vertexElements);
+            // Indices
+            if (indices !== undefined) {
+                var indexAccessor = gltf.accessors[indices];
+                var promise = GLTFUtils.getAccessorBuffer(context, gltf.bufferViews, indexAccessor).then(function(accessorBuffer) {
+                    mesh.setIndices(accessorBuffer.data);
+                    mesh.addSubMesh(0, indexAccessor.count, mode);
+                    meshRestoreInfo.indexBuffer = accessorBuffer.restoreInfo;
+                });
+                promises.push(promise);
+            } else {
+                mesh.addSubMesh(0, vertexCount, mode);
             }
-            var bufferData = getVertexBufferData(attributeSemantic);
-            switch(attributeSemantic){
-                case "NORMAL":
-                    var normals = GLTFUtil.floatBufferToVector3Array(bufferData);
-                    mesh.setNormals(normals);
-                    break;
-                case "TEXCOORD_0":
-                    var texturecoords = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords, 0);
-                    break;
-                case "TEXCOORD_1":
-                    var texturecoords1 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords1, 1);
-                    break;
-                case "TEXCOORD_2":
-                    var texturecoords2 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords2, 2);
-                    break;
-                case "TEXCOORD_3":
-                    var texturecoords3 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords3, 3);
-                    break;
-                case "TEXCOORD_4":
-                    var texturecoords4 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords4, 4);
-                    break;
-                case "TEXCOORD_5":
-                    var texturecoords5 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords5, 5);
-                    break;
-                case "TEXCOORD_6":
-                    var texturecoords6 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords6, 6);
-                    break;
-                case "TEXCOORD_7":
-                    var texturecoords7 = GLTFUtil.floatBufferToVector2Array(bufferData);
-                    mesh.setUVs(texturecoords7, 7);
-                    break;
-                case "COLOR_0":
-                    var colors = GLTFUtil.floatBufferToColorArray(bufferData, accessors[attributes["COLOR_0"]].type === AccessorType.VEC3);
-                    mesh.setColors(colors);
-                    break;
-                case "TANGENT":
-                    var tangents = GLTFUtil.floatBufferToVector4Array(bufferData);
-                    mesh.setTangents(tangents);
-                    break;
-                case "JOINTS_0":
-                    var joints = GLTFUtil.floatBufferToVector4Array(bufferData);
-                    mesh.setBoneIndices(joints);
-                    break;
-                case "WEIGHTS_0":
-                    var weights = GLTFUtil.floatBufferToVector4Array(bufferData);
-                    mesh.setBoneWeights(weights);
-                    break;
+            // BlendShapes
+            if (targets) {
+                promises.push(GLTFMeshParser._createBlendShape(mesh, meshRestoreInfo, gltfMesh, accessors, targets, getBlendShapeData));
             }
-        }
-        // Indices
-        if (indices !== undefined) {
-            var indexAccessor = gltf.accessors[indices];
-            var indexData = getIndexBufferData();
-            mesh.setIndices(indexData);
-            mesh.addSubMesh(0, indexAccessor.count, mode);
-        } else {
-            mesh.addSubMesh(0, vertexCount, mode);
-        }
-        // BlendShapes
-        targets && this._createBlendShape(mesh, gltfMesh, targets, getBlendShapeData);
-        mesh.uploadData(!keepMeshData);
-        return Promise.resolve(mesh);
+            return Promise.all(promises).then(function() {
+                mesh.uploadData(!keepMeshData);
+                //@ts-ignore
+                mesh._positions = positions;
+                //@ts-ignore
+                mesh._boneIndices = boneIndices;
+                //@ts-ignore
+                mesh._boneWeights = boneWeights;
+                return Promise.resolve(mesh);
+            });
+        });
+    };
+    /**
+   * @internal
+   */ GLTFMeshParser._createBlendShape = function _createBlendShape(mesh, meshRestoreInfo, glTFMesh, accessors, glTFTargets, getBlendShapeData) {
+        var _loop = function(i, n) {
+            var name = blendShapeNames ? blendShapeNames[i] : "blendShape" + i;
+            var promise = Promise.all([
+                getBlendShapeData("POSITION", i),
+                getBlendShapeData("NORMAL", i),
+                getBlendShapeData("TANGENT", i)
+            ]).then(function(infos) {
+                var posBufferInfo = infos[0];
+                var norBufferInfo = infos[1];
+                var tanBufferInfo = infos[2];
+                var target = glTFTargets[i];
+                var posAccessor;
+                var norAccessor;
+                var tanAccessor;
+                var positions = null;
+                if (posBufferInfo) {
+                    posAccessor = accessors[target["POSITION"]];
+                    var _posAccessor_byteOffset;
+                    positions = GLTFUtils.bufferToVector3Array(posBufferInfo.data, posBufferInfo.stride, (_posAccessor_byteOffset = posAccessor.byteOffset) != null ? _posAccessor_byteOffset : 0, posAccessor.count);
+                }
+                var normals = null;
+                if (norBufferInfo) {
+                    norAccessor = accessors[target["NORMAL"]];
+                    var _norAccessor_byteOffset;
+                    normals = GLTFUtils.bufferToVector3Array(norBufferInfo.data, norBufferInfo.stride, (_norAccessor_byteOffset = norAccessor.byteOffset) != null ? _norAccessor_byteOffset : 0, norAccessor.count);
+                }
+                var tangents = null;
+                if (tanBufferInfo) {
+                    tanAccessor = accessors[target["NORMAL"]];
+                    var _tanAccessor_byteOffset;
+                    tangents = GLTFUtils.bufferToVector3Array(tanBufferInfo.data, tanBufferInfo.stride, (_tanAccessor_byteOffset = tanAccessor.byteOffset) != null ? _tanAccessor_byteOffset : 0, tanAccessor.count);
+                }
+                var blendShape = new miniprogram.BlendShape(name);
+                blendShape.addFrame(1.0, positions, normals, tangents);
+                mesh.addBlendShape(blendShape);
+                var _posAccessor_byteOffset1, _norAccessor_byteOffset1, _tanAccessor_byteOffset1;
+                meshRestoreInfo.blendShapes.push(new BlendShapeRestoreInfo(blendShape, new BlendShapeDataRestoreInfo(posBufferInfo.restoreInfo, posBufferInfo.stride, (_posAccessor_byteOffset1 = posAccessor.byteOffset) != null ? _posAccessor_byteOffset1 : 0, posAccessor.count), norBufferInfo ? new BlendShapeDataRestoreInfo(norBufferInfo.restoreInfo, norBufferInfo.stride, (_norAccessor_byteOffset1 = norAccessor.byteOffset) != null ? _norAccessor_byteOffset1 : 0, norAccessor.count) : null, tanBufferInfo ? new BlendShapeDataRestoreInfo(tanBufferInfo.restoreInfo, tanBufferInfo.stride, (_tanAccessor_byteOffset1 = tanAccessor.byteOffset) != null ? _tanAccessor_byteOffset1 : 0, tanAccessor.count) : null));
+            });
+            promises.push(promise);
+        };
+        var blendShapeNames = glTFMesh.extras ? glTFMesh.extras.targetNames : null;
+        var promises = new Array();
+        for(var i = 0, n = glTFTargets.length; i < n; i++)_loop(i);
+        return Promise.all(promises);
     };
-    return MeshParser;
-}(Parser);
+    return GLTFMeshParser;
+}(GLTFParser);
 (function() {
-    MeshParser._tempVector3 = new miniprogram$1.Vector3();
+    GLTFMeshParser._tempVector3 = new miniprogram$1.Vector3();
 })();
 
-var SceneParser$1 = /*#__PURE__*/ function(Parser1) {
-    _inherits(SceneParser, Parser1);
-    function SceneParser() {
-        return Parser1.apply(this, arguments);
+var GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFSceneParser, GLTFParser1);
+    function GLTFSceneParser() {
+        return GLTFParser1.apply(this, arguments);
     }
-    var _proto = SceneParser.prototype;
+    var _proto = GLTFSceneParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource, gltf = context.gltf;
+        var glTFResource = context.glTFResource, glTF = context.glTF;
         var entities = glTFResource.entities;
-        var nodes = gltf.nodes, gltfCameras = gltf.cameras;
+        var nodes = glTF.nodes, cameras = glTF.cameras;
         if (!nodes) return;
         var defaultSceneRootPromiseInfo = context.defaultSceneRootPromiseInfo;
-        var promises = [];
         for(var i = 0; i < nodes.length; i++){
-            var gltfNode = nodes[i];
-            var cameraID = gltfNode.camera, meshID = gltfNode.mesh, _gltfNode_extensions = gltfNode.extensions, extensions = _gltfNode_extensions === void 0 ? {} : _gltfNode_extensions;
-            var KHR_lights_punctual = extensions.KHR_lights_punctual;
+            var glTFNode = nodes[i];
+            var cameraID = glTFNode.camera, meshID = glTFNode.mesh, extensions = glTFNode.extensions;
             var entity = entities[i];
             if (cameraID !== undefined) {
-                this._createCamera(glTFResource, gltfCameras[cameraID], entity);
+                this._createCamera(glTFResource, cameras[cameraID], entity);
             }
             if (meshID !== undefined) {
-                promises.push(this._createRenderer(context, gltfNode, entity));
-            }
-            if (KHR_lights_punctual) {
-                var lightIndex = KHR_lights_punctual.light;
-                var lights = gltf.extensions.KHR_lights_punctual.lights;
-                Parser.parseEngineResource("KHR_lights_punctual", lights[lightIndex], entity, context);
+                this._createRenderer(context, glTFNode, entity);
             }
+            GLTFParser.executeExtensionsAdditiveAndParse(extensions, context, entity, glTFNode);
         }
         if (glTFResource.defaultSceneRoot) {
             this._createAnimator(context);
         }
-        gltf.extensions && delete gltf.extensions["OASIS_materials_remap"];
-        miniprogram.AssetPromise.all(promises).then(function() {
-            return defaultSceneRootPromiseInfo.resolve(glTFResource.defaultSceneRoot);
-        }).catch(defaultSceneRootPromiseInfo.reject);
+        defaultSceneRootPromiseInfo.resolve(glTFResource.defaultSceneRoot);
         return defaultSceneRootPromiseInfo.promise;
     };
     _proto._createCamera = function _createCamera(context, cameraSchema, entity) {
@@ -2089,8 +2131,9 @@ var SceneParser$1 = /*#__PURE__*/ function(Parser1) {
         // @todo: use engine camera by default
         camera.enabled = false;
     };
-    _proto._createRenderer = function _createRenderer(context, gltfNode, entity) {
+    _proto._createRenderer = function _createRenderer(context, glTFNode, entity) {
         var _loop = function(i) {
+            var gltfPrimitive = glTFMeshPrimitives[i];
             var mesh = meshes[meshID][i];
             var renderer = void 0;
             if (skinID !== undefined || blendShapeWeights) {
@@ -2108,32 +2151,25 @@ var SceneParser$1 = /*#__PURE__*/ function(Parser1) {
                 renderer = entity.addComponent(miniprogram.MeshRenderer);
                 renderer.mesh = mesh;
             }
-            var materialIndex = gltfMeshPrimitives[i].material;
-            var remapMaterials = gltf.extensions && gltf.extensions["OASIS_materials_remap"];
-            if (remapMaterials && remapMaterials[materialIndex]) {
-                promises.push(remapMaterials[materialIndex].then(function(mtl) {
-                    renderer.setMaterial(mtl);
-                }));
-            } else {
-                var material = (materials == null ? void 0 : materials[materialIndex]) || SceneParser._getDefaultMaterial(engine);
-                renderer.setMaterial(material);
-            }
-            var _gltfMeshPrimitives_i = gltfMeshPrimitives[i], _gltfMeshPrimitives_i_extensions = _gltfMeshPrimitives_i.extensions, extensions = _gltfMeshPrimitives_i_extensions === void 0 ? {} : _gltfMeshPrimitives_i_extensions;
-            var KHR_materials_variants = extensions.KHR_materials_variants;
-            if (KHR_materials_variants) {
-                Parser.parseEngineResource("KHR_materials_variants", KHR_materials_variants, renderer, context);
-            }
+            var materialIndex = gltfPrimitive.material;
+            var material = (materials == null ? void 0 : materials[materialIndex]) || GLTFSceneParser._getDefaultMaterial(engine);
+            renderer.setMaterial(material);
+            // Enable vertex color if mesh has COLOR_0 vertex element
+            mesh.vertexElements.forEach(function(element) {
+                if (element.semantic === "COLOR_0") {
+                    renderer.enableVertexColor = true;
+                }
+            });
+            GLTFParser.executeExtensionsAdditiveAndParse(gltfPrimitive.extensions, context, renderer, gltfPrimitive);
         };
-        var glTFResource = context.glTFResource, gltf = context.gltf;
-        var gltfMeshes = gltf.meshes;
+        var glTFResource = context.glTFResource, glTF = context.glTF;
+        var glTFMeshes = glTF.meshes;
         var engine = glTFResource.engine, meshes = glTFResource.meshes, materials = glTFResource.materials, skins = glTFResource.skins;
-        var meshID = gltfNode.mesh, skinID = gltfNode.skin;
-        var glTFMesh = gltfMeshes[meshID];
-        var gltfMeshPrimitives = glTFMesh.primitives;
-        var blendShapeWeights = gltfNode.weights || glTFMesh.weights;
-        var promises = [];
-        for(var i = 0; i < gltfMeshPrimitives.length; i++)_loop(i);
-        return Promise.all(promises);
+        var meshID = glTFNode.mesh, skinID = glTFNode.skin;
+        var glTFMesh = glTFMeshes[meshID];
+        var glTFMeshPrimitives = glTFMesh.primitives;
+        var blendShapeWeights = glTFNode.weights || glTFMesh.weights;
+        for(var i = 0; i < glTFMeshPrimitives.length; i++)_loop(i);
     };
     _proto._createAnimator = function _createAnimator(context) {
         if (!context.hasSkinned && !context.glTFResource.animations) {
@@ -2160,67 +2196,74 @@ var SceneParser$1 = /*#__PURE__*/ function(Parser1) {
             }
         }
     };
-    SceneParser._getDefaultMaterial = function _getDefaultMaterial(engine) {
-        if (!SceneParser._defaultMaterial) {
-            SceneParser._defaultMaterial = new miniprogram.BlinnPhongMaterial(engine);
+    GLTFSceneParser._getDefaultMaterial = function _getDefaultMaterial(engine) {
+        if (!GLTFSceneParser._defaultMaterial) {
+            GLTFSceneParser._defaultMaterial = new miniprogram.BlinnPhongMaterial(engine);
         }
-        return SceneParser._defaultMaterial;
+        return GLTFSceneParser._defaultMaterial;
     };
-    return SceneParser;
-}(Parser);
+    return GLTFSceneParser;
+}(GLTFParser);
 
-var SkinParser = /*#__PURE__*/ function(Parser) {
-    _inherits(SkinParser, Parser);
-    function SkinParser() {
-        return Parser.apply(this, arguments);
+var GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
+    _inherits(GLTFSkinParser, GLTFParser);
+    function GLTFSkinParser() {
+        return GLTFParser.apply(this, arguments);
     }
-    var _proto = SkinParser.prototype;
+    var _proto = GLTFSkinParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource, gltf = context.gltf; context.buffers;
-        var entities = glTFResource.entities;
-        var gltfSkins = gltf.skins;
-        if (!gltfSkins) return;
-        var count = gltfSkins.length;
-        var skins = new Array(count);
-        for(var i = 0; i < count; i++){
+        var _loop = function(i) {
             var _gltfSkins_i = gltfSkins[i], inverseBindMatrices = _gltfSkins_i.inverseBindMatrices, skeleton = _gltfSkins_i.skeleton, joints = _gltfSkins_i.joints, _gltfSkins_i_name = _gltfSkins_i.name, name = _gltfSkins_i_name === void 0 ? "SKIN_" + i : _gltfSkins_i_name;
             var jointCount = joints.length;
             var skin = new miniprogram.Skin(name);
             skin.inverseBindMatrices.length = jointCount;
             // parse IBM
-            var accessor = gltf.accessors[inverseBindMatrices];
-            var buffer = GLTFUtil.getAccessorBuffer(context, gltf, accessor).data;
-            for(var i1 = 0; i1 < jointCount; i1++){
-                var inverseBindMatrix = new miniprogram$1.Matrix();
-                inverseBindMatrix.copyFromArray(buffer, i1 * 16);
-                skin.inverseBindMatrices[i1] = inverseBindMatrix;
-            }
-            // get joints
-            for(var i2 = 0; i2 < jointCount; i2++){
-                var jointIndex = joints[i2];
-                var jointName = entities[jointIndex].name;
-                skin.joints[i2] = jointName;
-                // @todo Temporary solution, but it can alleviate the current BUG, and the skinning data mechanism of SkinnedMeshRenderer will be completely refactored in the future
-                for(var j = entities.length - 1; j >= 0; j--){
-                    if (jointIndex !== j && entities[j].name === jointName) {
-                        entities[j].name = jointName + "_" + j;
+            var accessor = glTF.accessors[inverseBindMatrices];
+            var promise = GLTFUtils.getAccessorBuffer(context, glTF.bufferViews, accessor).then(function(bufferInfo) {
+                var buffer = bufferInfo.data;
+                for(var i = 0; i < jointCount; i++){
+                    var inverseBindMatrix = new miniprogram$1.Matrix();
+                    inverseBindMatrix.copyFromArray(buffer, i * 16);
+                    skin.inverseBindMatrices[i] = inverseBindMatrix;
+                    // get joints
+                    for(var i1 = 0; i1 < jointCount; i1++){
+                        var jointIndex = joints[i1];
+                        var jointName = entities[jointIndex].name;
+                        skin.joints[i1] = jointName;
+                        // @todo Temporary solution, but it can alleviate the current BUG, and the skinning data mechanism of SkinnedMeshRenderer will be completely refactored in the future
+                        for(var j = entities.length - 1; j >= 0; j--){
+                            if (jointIndex !== j && entities[j].name === jointName) {
+                                entities[j].name = jointName + "_" + j;
+                            }
+                        }
+                    }
+                    // get skeleton
+                    if (skeleton !== undefined) {
+                        skin.skeleton = entities[skeleton].name;
+                    } else {
+                        var rootBone = _this._findSkeletonRootBone(joints, entities);
+                        if (rootBone) {
+                            skin.skeleton = rootBone.name;
+                        } else {
+                            throw "Failed to find skeleton root bone.";
+                        }
                     }
                 }
-            }
-            // get skeleton
-            if (skeleton !== undefined) {
-                skin.skeleton = entities[skeleton].name;
-            } else {
-                var rootBone = this._findSkeletonRootBone(joints, entities);
-                if (rootBone) {
-                    skin.skeleton = rootBone.name;
-                } else {
-                    throw "Failed to find skeleton root bone.";
-                }
-            }
-            skins[i] = skin;
-        }
-        glTFResource.skins = skins;
+                return skin;
+            });
+            promises.push(promise);
+        };
+        var _this = this;
+        var glTFResource = context.glTFResource, glTF = context.glTF;
+        var entities = glTFResource.entities;
+        var gltfSkins = glTF.skins;
+        if (!gltfSkins) return;
+        var count = gltfSkins.length;
+        var promises = new Array();
+        for(var i = 0; i < count; i++)_loop(i);
+        return miniprogram.AssetPromise.all(promises).then(function(skins) {
+            glTFResource.skins = skins;
+        });
     };
     _proto._findSkeletonRootBone = function _findSkeletonRootBone(joints, entities) {
         var paths = {};
@@ -2250,53 +2293,62 @@ var SkinParser = /*#__PURE__*/ function(Parser) {
             rootNode = entity1;
         }
     };
-    return SkinParser;
-}(Parser);
+    return GLTFSkinParser;
+}(GLTFParser);
 
-var TextureParser = /*#__PURE__*/ function(Parser) {
-    _inherits(TextureParser, Parser);
-    function TextureParser() {
-        return Parser.apply(this, arguments);
+var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
+    _inherits(GLTFTextureParser, GLTFParser);
+    function GLTFTextureParser() {
+        return GLTFParser.apply(this, arguments);
     }
-    var _proto = TextureParser.prototype;
+    var _proto = GLTFTextureParser.prototype;
     _proto.parse = function parse(context) {
         var _this = this;
-        var glTFResource = context.glTFResource, gltf = context.gltf, buffers = context.buffers;
+        var glTFResource = context.glTFResource, glTF = context.glTF;
         var engine = glTFResource.engine, url = glTFResource.url;
-        if (gltf.textures) {
+        if (glTF.textures) {
             var texturesPromiseInfo = context.texturesPromiseInfo;
-            miniprogram.AssetPromise.all(gltf.textures.map(function(param, index) {
+            miniprogram.AssetPromise.all(glTF.textures.map(function(param, index) {
                 var sampler = param.sampler, _param_source = param.source, source = _param_source === void 0 ? 0 : _param_source, textureName = param.name;
-                var _gltf_images_source = gltf.images[source], uri = _gltf_images_source.uri, bufferViewIndex = _gltf_images_source.bufferView, mimeType = _gltf_images_source.mimeType, imageName = _gltf_images_source.name;
+                var _glTF_images_source = glTF.images[source], uri = _glTF_images_source.uri, bufferViewIndex = _glTF_images_source.bufferView, mimeType = _glTF_images_source.mimeType, imageName = _glTF_images_source.name;
+                var samplerInfo = sampler !== undefined && _this._getSamplerInfo(glTF.samplers[sampler]);
                 if (uri) {
                     // TODO: support ktx extension https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_basisu/README.md
                     var index1 = uri.lastIndexOf(".");
                     var ext = uri.substring(index1 + 1);
                     var type = ext.startsWith("ktx") ? miniprogram.AssetType.KTX : miniprogram.AssetType.Texture2D;
                     return engine.resourceManager.load({
-                        url: GLTFUtil.parseRelativeUrl(url, uri),
-                        type: type
+                        url: miniprogram.Utils.resolveAbsoluteUrl(url, uri),
+                        type: type,
+                        params: {
+                            mipmap: samplerInfo == null ? void 0 : samplerInfo.mipmap
+                        }
                     }).then(function(texture) {
                         if (!texture.name) {
                             texture.name = textureName || imageName || "texture_" + index1;
                         }
                         if (sampler !== undefined) {
-                            _this._parseSampler(texture, gltf.samplers[sampler]);
+                            _this._parseSampler(texture, samplerInfo);
                         }
                         return texture;
                     });
                 } else {
-                    var bufferView = gltf.bufferViews[bufferViewIndex];
-                    var bufferViewData = GLTFUtil.getBufferViewData(bufferView, buffers);
-                    return GLTFUtil.loadImageBuffer(bufferViewData, mimeType).then(function(image) {
-                        var texture = new miniprogram.Texture2D(engine, image.width, image.height);
-                        texture.setImageSource(image);
-                        texture.generateMipmaps();
-                        texture.name = textureName || imageName || "texture_" + index;
-                        if (sampler !== undefined) {
-                            _this._parseSampler(texture, gltf.samplers[sampler]);
-                        }
-                        return texture;
+                    var bufferView = glTF.bufferViews[bufferViewIndex];
+                    return context.getBuffers().then(function(buffers) {
+                        var buffer = buffers[bufferView.buffer];
+                        var imageBuffer = new Uint8Array(buffer, bufferView.byteOffset, bufferView.byteLength);
+                        return GLTFUtils.loadImageBuffer(imageBuffer, mimeType).then(function(image) {
+                            var texture = new miniprogram.Texture2D(engine, image.width, image.height, undefined, samplerInfo == null ? void 0 : samplerInfo.mipmap);
+                            texture.setImageSource(image);
+                            texture.generateMipmaps();
+                            texture.name = textureName || imageName || "texture_" + index;
+                            if (sampler !== undefined) {
+                                _this._parseSampler(texture, samplerInfo);
+                            }
+                            var bufferTextureRestoreInfo = new BufferTextureRestoreInfo(texture, bufferView, mimeType);
+                            context.contentRestorer.bufferTextures.push(bufferTextureRestoreInfo);
+                            return texture;
+                        });
                     });
                 }
             })).then(function(textures) {
@@ -2306,48 +2358,67 @@ var TextureParser = /*#__PURE__*/ function(Parser) {
             return texturesPromiseInfo.promise;
         }
     };
-    _proto._parseSampler = function _parseSampler(texture, sampler) {
-        var magFilter = sampler.magFilter, minFilter = sampler.minFilter, wrapS = sampler.wrapS, wrapT = sampler.wrapT;
-        if (magFilter || minFilter) {
+    _proto._getSamplerInfo = function _getSamplerInfo(sampler) {
+        var minFilter = sampler.minFilter, magFilter = sampler.magFilter, wrapS = sampler.wrapS, wrapT = sampler.wrapT;
+        var info = {};
+        if (minFilter || magFilter) {
+            info.mipmap = minFilter >= TextureMinFilter.NEAREST_MIPMAP_NEAREST;
             if (magFilter === TextureMagFilter.NEAREST) {
-                texture.filterMode = miniprogram.TextureFilterMode.Point;
-            } else if (minFilter <= TextureMinFilter.LINEAR_MIPMAP_NEAREST) {
-                texture.filterMode = miniprogram.TextureFilterMode.Bilinear;
+                info.filterMode = miniprogram.TextureFilterMode.Point;
             } else {
-                texture.filterMode = miniprogram.TextureFilterMode.Trilinear;
-            }
+                if (minFilter <= TextureMinFilter.LINEAR_MIPMAP_NEAREST) {
+                    info.filterMode = miniprogram.TextureFilterMode.Bilinear;
+                } else {
+                    info.filterMode = miniprogram.TextureFilterMode.Trilinear;
+                }
+            }
         }
         if (wrapS) {
-            texture.wrapModeU = TextureParser._wrapMap[wrapS];
+            info.wrapModeU = GLTFTextureParser._wrapMap[wrapS];
         }
         if (wrapT) {
-            texture.wrapModeV = TextureParser._wrapMap[wrapT];
+            info.wrapModeV = GLTFTextureParser._wrapMap[wrapT];
         }
+        return info;
     };
-    return TextureParser;
-}(Parser);
+    _proto._parseSampler = function _parseSampler(texture, samplerInfo) {
+        var filterMode = samplerInfo.filterMode, wrapModeU = samplerInfo.wrapModeU, wrapModeV = samplerInfo.wrapModeV;
+        if (filterMode !== undefined) {
+            texture.filterMode = filterMode;
+        }
+        if (wrapModeU !== undefined) {
+            texture.wrapModeU = wrapModeU;
+        }
+        if (wrapModeV !== undefined) {
+            texture.wrapModeV = wrapModeV;
+        }
+    };
+    return GLTFTextureParser;
+}(GLTFParser);
 (function() {
     var _obj;
-    TextureParser._wrapMap = (_obj = {}, _obj[TextureWrapMode.CLAMP_TO_EDGE] = miniprogram.TextureWrapMode.Clamp, _obj[TextureWrapMode.MIRRORED_REPEAT] = miniprogram.TextureWrapMode.Mirror, _obj[TextureWrapMode.REPEAT] = miniprogram.TextureWrapMode.Repeat, _obj);
+    GLTFTextureParser._wrapMap = (_obj = {}, _obj[TextureWrapMode.CLAMP_TO_EDGE] = miniprogram.TextureWrapMode.Clamp, _obj[TextureWrapMode.MIRRORED_REPEAT] = miniprogram.TextureWrapMode.Mirror, _obj[TextureWrapMode.REPEAT] = miniprogram.TextureWrapMode.Repeat, _obj);
 })();
 
-var Validator = /*#__PURE__*/ function(Parser1) {
-    _inherits(Validator, Parser1);
-    function Validator() {
-        return Parser1.apply(this, arguments);
+var GLTFValidator = /*#__PURE__*/ function(GLTFParser1) {
+    _inherits(GLTFValidator, GLTFParser1);
+    function GLTFValidator() {
+        return GLTFParser1.apply(this, arguments);
     }
-    var _proto = Validator.prototype;
+    var _proto = GLTFValidator.prototype;
     _proto.parse = function parse(context) {
-        var _context_gltf = context.gltf, version = _context_gltf.asset.version, extensionsUsed = _context_gltf.extensionsUsed, extensionsRequired = _context_gltf.extensionsRequired;
-        var gltfVersion = Number(version);
-        if (!(gltfVersion >= 2 && gltfVersion < 3)) {
-            throw "Only support gltf 2.x.";
+        var _context_glTF = context.glTF, version = _context_glTF.asset.version, extensionsUsed = _context_glTF.extensionsUsed, extensionsRequired = _context_glTF.extensionsRequired;
+        var glTFVersion = Number(version);
+        if (!(glTFVersion >= 2 && glTFVersion < 3)) {
+            throw "Only support glTF 2.x.";
         }
+        var promises = [];
         if (extensionsUsed) {
             miniprogram.Logger.info("extensionsUsed: ", extensionsUsed);
             for(var i = 0; i < extensionsUsed.length; i++){
-                if (!Parser.hasExtensionParser(extensionsUsed[i])) {
-                    miniprogram.Logger.warn("Extension " + extensionsUsed[i] + " is not implemented, you can customize this extension in gltf.");
+                var extensionUsed = extensionsUsed[i];
+                if (!GLTFParser.hasExtensionParser(extensionUsed)) {
+                    miniprogram.Logger.warn("Extension " + extensionUsed + " is not implemented, you can customize this extension in gltf.");
                 }
             }
         }
@@ -2355,98 +2426,78 @@ var Validator = /*#__PURE__*/ function(Parser1) {
             miniprogram.Logger.info("extensionsRequired: " + extensionsRequired);
             for(var i1 = 0; i1 < extensionsRequired.length; i1++){
                 var extensionRequired = extensionsRequired[i1];
-                if (!Parser.hasExtensionParser(extensionRequired)) {
+                if (!GLTFParser.hasExtensionParser(extensionRequired)) {
                     miniprogram.Logger.error("GLTF parser has not supported required extension " + extensionRequired + ".");
                 } else {
-                    Parser.initialize(extensionRequired);
+                    promises.push(GLTFParser.executeExtensionsInitialize(extensionRequired));
                 }
             }
         }
+        return miniprogram.AssetPromise.all(promises).then(null);
     };
-    return Validator;
-}(Parser);
+    return GLTFValidator;
+}(GLTFParser);
 
-var GLTFParser = /*#__PURE__*/ function() {
-    function GLTFParser(pipes) {
+/**
+ * GLTF pipeline.
+ */ var GLTFPipeline = /*#__PURE__*/ function() {
+    function GLTFPipeline() {
+        for(var _len = arguments.length, parsers = new Array(_len), _key = 0; _key < _len; _key++){
+            parsers[_key] = arguments[_key];
+        }
         var _this = this;
-        this._pipes = [];
-        pipes.forEach(function(pipe, index) {
-            _this._pipes[index] = new pipe();
+        this._parsers = [];
+        parsers.forEach(function(pipe, index) {
+            _this._parsers[index] = new pipe();
         });
     }
-    var _proto = GLTFParser.prototype;
-    _proto.parse = function parse(context) {
+    var _proto = GLTFPipeline.prototype;
+    /**
+   * @internal
+   */ _proto._parse = function _parse(context) {
         var _this = this;
         var glTFResource = context.glTFResource;
-        var lastPipe;
+        var lastParser;
         return new miniprogram.AssetPromise(function(resolve, reject) {
-            _this._pipes.forEach(function(parser) {
-                if (lastPipe) {
-                    lastPipe = lastPipe.then(function() {
+            _this._parsers.forEach(function(parser) {
+                if (lastParser) {
+                    lastParser = lastParser.then(function() {
                         return parser.parse(context);
                     });
-                    if (lastPipe.cancel) {
-                        context.chainPromises.push(lastPipe);
+                    if (lastParser.cancel) {
+                        context.chainPromises.push(lastParser);
                     }
                 } else {
-                    lastPipe = parser.parse(context);
+                    lastParser = parser.parse(context);
                 }
             });
-            if (lastPipe) {
-                lastPipe.then(function() {
+            if (lastParser) {
+                lastParser.then(function() {
                     resolve(glTFResource);
                 }).catch(reject);
             }
         });
     };
-    return GLTFParser;
+    return GLTFPipeline;
 }();
 (function() {
-    GLTFParser.defaultPipeline = new GLTFParser([
-        BufferParser,
-        Validator,
-        TextureParser,
-        MaterialParser,
-        MeshParser,
-        EntityParser,
-        SkinParser,
-        AnimationParser,
-        SceneParser$1
-    ]);
+    /**
+   * Default pipeline.
+   */ GLTFPipeline.defaultPipeline = new GLTFPipeline(GLTFBufferParser, GLTFValidator, GLTFTextureParser, GLTFMaterialParser, GLTFMeshParser, GLTFEntityParser, GLTFSkinParser, GLTFAnimationParser, GLTFSceneParser);
 })();
 
 /**
- * Product after GLTF parser, usually, `defaultSceneRoot` is only needed to use.
- */ var GLTFResource = /*#__PURE__*/ function(EngineObject) {
-    _inherits(GLTFResource, EngineObject);
+ * Product after glTF parser, usually, `defaultSceneRoot` is only needed to use.
+ */ var GLTFResource = /*#__PURE__*/ function(ReferResource) {
+    _inherits(GLTFResource, ReferResource);
     function GLTFResource(engine, url) {
         var _this;
-        _this = EngineObject.call(this, engine) || this;
+        _this = ReferResource.call(this, engine) || this;
         _this.url = url;
         return _this;
     }
-    var _proto = GLTFResource.prototype;
-    /**
-   * @override
-   */ _proto.destroy = function destroy() {
-        if (this._destroyed) {
-            return;
-        }
-        EngineObject.prototype.destroy.call(this);
-        this.defaultSceneRoot.destroy();
-        this.textures = null;
-        this.materials = null;
-        this.meshes = null;
-        this.skins = null;
-        this.animations = null;
-        this.entities = null;
-        this.cameras = null;
-        this.lights = null;
-        this.sceneRoots = null;
-        this.variants = null;
-    };
     return GLTFResource;
-}(miniprogram.EngineObject);
+}(miniprogram.ReferResource);
 
 var GLTFLoader = /*#__PURE__*/ function(Loader) {
     _inherits(GLTFLoader, Loader);
@@ -2455,14 +2506,16 @@ var GLTFLoader = /*#__PURE__*/ function(Loader) {
     }
     var _proto = GLTFLoader.prototype;
     _proto.load = function load(item, resourceManager) {
-        var _item_params;
         var url = item.url;
-        var context = new ParserContext(url);
+        var params = item.params;
+        var context = new GLTFParserContext(url);
         var glTFResource = new GLTFResource(resourceManager.engine, url);
+        var restorer = new GLTFContentRestorer(glTFResource);
         var masterPromiseInfo = context.masterPromiseInfo;
+        context.contentRestorer = restorer;
         context.glTFResource = glTFResource;
-        var _item_params_keepMeshData;
-        context.keepMeshData = (_item_params_keepMeshData = (_item_params = item.params) == null ? void 0 : _item_params.keepMeshData) != null ? _item_params_keepMeshData : false;
+        var _params_keepMeshData;
+        context.keepMeshData = (_params_keepMeshData = params == null ? void 0 : params.keepMeshData) != null ? _params_keepMeshData : false;
         masterPromiseInfo.onCancel(function() {
             var chainPromises = context.chainPromises;
             for(var _iterator = _create_for_of_iterator_helper_loose(chainPromises), _step; !(_step = _iterator()).done;){
@@ -2470,16 +2523,25 @@ var GLTFLoader = /*#__PURE__*/ function(Loader) {
                 promise.cancel();
             }
         });
-        GLTFParser.defaultPipeline.parse(context).then(masterPromiseInfo.resolve).catch(function(e) {
-            console.error(e);
-            masterPromiseInfo.reject("Error loading glTF model from " + url + " .");
+        ((params == null ? void 0 : params.pipeline) || GLTFPipeline.defaultPipeline)._parse(context).then(function(glTFResource) {
+            resourceManager.addContentRestorer(restorer);
+            masterPromiseInfo.resolve(glTFResource);
+        }).catch(function(e) {
+            var msg = "Error loading glTF model from " + url + " : " + e;
+            miniprogram.Logger.error(msg);
+            masterPromiseInfo.reject(msg);
+            context.defaultSceneRootPromiseInfo.reject(e);
+            context.texturesPromiseInfo.reject(e);
+            context.materialsPromiseInfo.reject(e);
+            context.meshesPromiseInfo.reject(e);
+            context.animationClipsPromiseInfo.reject(e);
         });
         return context.promiseMap;
     };
     return GLTFLoader;
 }(miniprogram.Loader);
 GLTFLoader = __decorate([
-    miniprogram.resourceLoader(miniprogram.AssetType.Prefab, [
+    miniprogram.resourceLoader(miniprogram.AssetType.GLTF, [
         "gltf",
         "glb"
     ])
@@ -2565,7 +2627,7 @@ var HDRLoader = (_HDRLoader = /*#__PURE__*/ function(Loader) {
         return textureArray;
     };
     HDRLoader1._calcProjectionSpherical = function _calcProjectionSpherical(vDir, pixels, inputWidth, inputHeight) {
-        var theta = Math.atan2(vDir.z, -vDir.x);
+        var theta = Math.atan2(vDir.z, vDir.x);
         var phi = Math.acos(vDir.y);
         while(theta < -PI){
             theta += 2 * PI;
@@ -2867,40 +2929,40 @@ function getEngineFormat(internalFormat) {
         // case GLCompressedTextureInternalFormat.RGBA_S3TC_DXT3_EXT:
         // case GLCompressedTextureInternalFormat.RGBA_S3TC_DXT5_EXT:
         // break;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGB_S3TC_DXT1_EXT:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGB_S3TC_DXT1_EXT:
             return miniprogram.TextureFormat.DXT1;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA_S3TC_DXT5_EXT:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA_S3TC_DXT5_EXT:
             return miniprogram.TextureFormat.DXT5;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGB_ETC1_WEBGL:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGB_ETC1_WEBGL:
             return miniprogram.TextureFormat.ETC1_RGB;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGB8_ETC2:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGB8_ETC2:
             return miniprogram.TextureFormat.ETC2_RGB;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
             return miniprogram.TextureFormat.ETC2_RGBA5;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA8_ETC2_EAC:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA8_ETC2_EAC:
             return miniprogram.TextureFormat.ETC2_RGBA8;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGB_PVRTC_2BPPV1_IMG:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGB_PVRTC_2BPPV1_IMG:
             return miniprogram.TextureFormat.PVRTC_RGB2;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA_PVRTC_2BPPV1_IMG:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA_PVRTC_2BPPV1_IMG:
             return miniprogram.TextureFormat.PVRTC_RGBA2;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGB_PVRTC_4BPPV1_IMG:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGB_PVRTC_4BPPV1_IMG:
             return miniprogram.TextureFormat.PVRTC_RGB4;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA_PVRTC_4BPPV1_IMG:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA_PVRTC_4BPPV1_IMG:
             return miniprogram.TextureFormat.PVRTC_RGBA4;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA_ASTC_4X4_KHR:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA_ASTC_4X4_KHR:
             return miniprogram.TextureFormat.ASTC_4x4;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA_ASTC_5X5_KHR:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA_ASTC_5X5_KHR:
             return miniprogram.TextureFormat.ASTC_5x5;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA_ASTC_6X6_KHR:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA_ASTC_6X6_KHR:
             return miniprogram.TextureFormat.ASTC_6x6;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA_ASTC_8X8_KHR:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA_ASTC_8X8_KHR:
             return miniprogram.TextureFormat.ASTC_8x8;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA_ASTC_10X10_KHR:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA_ASTC_10X10_KHR:
             return miniprogram.TextureFormat.ASTC_10x10;
-        case miniprogram$3.GLCompressedTextureInternalFormat.RGBA_ASTC_12X12_KHR:
+        case miniprogram$2.GLCompressedTextureInternalFormat.RGBA_ASTC_12X12_KHR:
             return miniprogram.TextureFormat.ASTC_12x12;
         default:
-            var formatName = miniprogram$3.GLCompressedTextureInternalFormat[internalFormat];
+            var formatName = miniprogram$2.GLCompressedTextureInternalFormat[internalFormat];
             throw new Error("this format is not supported in Galacean Engine: " + formatName);
     }
 }
@@ -3074,6 +3136,15 @@ KTXLoader = __decorate([
     ])
 ], KTXLoader);
 
+function parseProperty(object, key, value) {
+    if (typeof value === "object") {
+        for(var subKey in value){
+            parseProperty(object[key], subKey, value[subKey]);
+        }
+    } else {
+        object[key] = value;
+    }
+}
 var MaterialLoader = /*#__PURE__*/ function(Loader) {
     _inherits(MaterialLoader, Loader);
     function MaterialLoader() {
@@ -3085,7 +3156,7 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
         return new miniprogram.AssetPromise(function(resolve, reject) {
             _this.request(item.url, _extends({}, item, {
                 type: "json"
-            })).then(function(json) {
+            })).then(function(materialSchema) {
                 var _loop = function(key) {
                     var _shaderData_key = shaderData[key], type = _shaderData_key.type, value = _shaderData_key.value;
                     switch(type){
@@ -3113,27 +3184,8 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                     }
                 };
                 var engine = resourceManager.engine;
-                var name = json.name, shader = json.shader, shaderData = json.shaderData, macros = json.macros, renderState = json.renderState;
-                var material;
-                switch(shader){
-                    case "pbr":
-                        material = new miniprogram.PBRMaterial(engine);
-                        break;
-                    case "pbr-specular":
-                        material = new miniprogram.PBRSpecularMaterial(engine);
-                        break;
-                    case "unlit":
-                        material = new miniprogram.UnlitMaterial(engine);
-                        break;
-                    case "blinn-phong":
-                        material = new miniprogram.BlinnPhongMaterial(engine);
-                        break;
-                    case "bake-pbr":
-                        // @todo refactor custom shader later
-                        // @ts-ignore
-                        material = new miniprogram.PBRBaseMaterial(engine, miniprogram.Shader.find("bake-pbr"));
-                        break;
-                }
+                var name = materialSchema.name, shader = materialSchema.shader, shaderData = materialSchema.shaderData, macros = materialSchema.macros, renderState = materialSchema.renderState;
+                var material = new miniprogram.Material(engine, miniprogram.Shader.find(shader));
                 material.name = name;
                 var texturePromises = new Array();
                 var materialShaderData = material.shaderData;
@@ -3146,9 +3198,7 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                         materialShaderData.enableMacro(name1, value);
                     }
                 }
-                for(var key1 in renderState){
-                    material[key1] = renderState[key1];
-                }
+                parseProperty(material, "renderState", renderState);
                 return Promise.all(texturePromises).then(function() {
                     resolve(material);
                 });
@@ -3248,7 +3298,7 @@ var BufferReader = /*#__PURE__*/ function() {
         var strByteLength = this.nextUint16();
         var uint8Array = new Uint8Array(this.buffer, this._offset, strByteLength);
         this._offset += strByteLength;
-        return GLTFUtil.decodeText(uint8Array);
+        return miniprogram.Utils.decodeText(uint8Array);
     };
     /**
    * image data 放在最后
@@ -3333,8 +3383,8 @@ var FileHeader = /*#__PURE__*/ function() {
         var typeUint8Array = new Uint8Array(arrayBuffer, 7, typeLen);
         var nameLen = dataView.getUint16(7 + typeLen, true);
         var nameUint8Array = new Uint8Array(arrayBuffer, 9 + typeLen, nameLen);
-        var name = GLTFUtil.decodeText(nameUint8Array);
-        var type = GLTFUtil.decodeText(typeUint8Array);
+        var name = miniprogram.Utils.decodeText(nameUint8Array);
+        var type = miniprogram.Utils.decodeText(typeUint8Array);
         var header = new FileHeader();
         header.totalLength = totalLen;
         header.name = name;
@@ -3903,6 +3953,12 @@ exports.AnimationClipDecoder = __decorate([
     decoder("AnimationClip")
 ], exports.AnimationClipDecoder);
 
+exports.SpecularMode = void 0;
+(function(SpecularMode) {
+    SpecularMode["Sky"] = "Sky";
+    SpecularMode["Custom"] = "Custom";
+})(exports.SpecularMode || (exports.SpecularMode = {}));
+
 var SceneParserContext = /*#__PURE__*/ function() {
     function SceneParserContext(originalData, scene) {
         this.originalData = originalData;
@@ -4030,7 +4086,7 @@ exports.MeshLoader = /*#__PURE__*/ function(Loader) {
                 decode(data, resourceManager.engine).then(function(mesh) {
                     resolve(mesh);
                 });
-            });
+            }).catch(reject);
         });
     };
     return MeshLoader;
@@ -4049,14 +4105,14 @@ exports.EditorTextureLoader = /*#__PURE__*/ function(Loader) {
     var _proto = EditorTextureLoader.prototype;
     _proto.load = function load(item, resourceManager) {
         var _this = this;
-        return new miniprogram.AssetPromise(function(resolve) {
+        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;
@@ -4185,7 +4241,7 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader) {
                     var atlasItem = atlasItems[i];
                     if (atlasItem.img) {
                         chainPromises.push(resourceManager.load({
-                            url: atlasItem.img,
+                            url: miniprogram.Utils.resolveAbsoluteUrl(item.url, atlasItem.img),
                             type: miniprogram.AssetType.Texture2D,
                             params: {
                                 format: format,
@@ -4284,6 +4340,30 @@ SpriteLoader = __decorate([
     ], false)
 ], SpriteLoader);
 
+/**
+ * @internal
+ */ var Texture2DContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
+    _inherits(Texture2DContentRestorer, ContentRestorer);
+    function Texture2DContentRestorer(resource, url, requestConfig) {
+        var _this;
+        _this = ContentRestorer.call(this, resource) || this;
+        _this.url = url;
+        _this.requestConfig = requestConfig;
+        return _this;
+    }
+    var _proto = Texture2DContentRestorer.prototype;
+    _proto.restoreContent = function restoreContent() {
+        var _this = this;
+        return miniprogram.request(this.url, this.requestConfig).then(function(image) {
+            var resource = _this.resource;
+            resource.setImageSource(image);
+            resource.generateMipmaps();
+            return resource;
+        });
+    };
+    return Texture2DContentRestorer;
+}(miniprogram.ContentRestorer);
+
 var Texture2DLoader = /*#__PURE__*/ function(Loader) {
     _inherits(Texture2DLoader, Loader);
     function Texture2DLoader() {
@@ -4293,19 +4373,20 @@ var Texture2DLoader = /*#__PURE__*/ function(Loader) {
     _proto.load = function load(item, resourceManager) {
         var _this = this;
         return new miniprogram.AssetPromise(function(resolve, reject) {
-            _this.request(item.url, _extends({}, item, {
+            var url = item.url;
+            var requestConfig = _extends({}, item, {
                 type: "image"
-            })).then(function(image) {
-                var _item_params;
-                var params = (_item_params = item.params) != null ? _item_params : {};
-                var texture = new miniprogram.Texture2D(resourceManager.engine, image.width, image.height, params.format, params.mipmap);
-                /** @ts-ignore */ if (!texture._platformTexture) return;
+            });
+            _this.request(url, requestConfig).then(function(image) {
+                var params = item.params;
+                var texture = new miniprogram.Texture2D(resourceManager.engine, image.width, image.height, params == null ? void 0 : params.format, params == null ? void 0 : params.mipmap);
                 texture.setImageSource(image);
                 texture.generateMipmaps();
-                if (item.url.indexOf("data:") !== 0) {
-                    var splitPath = item.url.split("/");
-                    texture.name = splitPath[splitPath.length - 1];
+                if (url.indexOf("data:") !== 0) {
+                    var index = url.lastIndexOf("/");
+                    texture.name = url.substring(index + 1);
                 }
+                resourceManager.addContentRestorer(new Texture2DContentRestorer(texture, url, requestConfig));
                 resolve(texture);
             }).catch(function(e) {
                 reject(e);
@@ -4323,6 +4404,38 @@ Texture2DLoader = __decorate([
     ])
 ], Texture2DLoader);
 
+/**
+ * @internal
+ */ var TextureCubeContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
+    _inherits(TextureCubeContentRestorer, ContentRestorer);
+    function TextureCubeContentRestorer(resource, urls, requestConfig) {
+        var _this;
+        _this = ContentRestorer.call(this, resource) || this;
+        _this.urls = urls;
+        _this.requestConfig = requestConfig;
+        return _this;
+    }
+    var _proto = TextureCubeContentRestorer.prototype;
+    _proto.restoreContent = function restoreContent() {
+        var _this = this;
+        return new miniprogram.AssetPromise(function(resolve, reject) {
+            Promise.all(_this.urls.map(function(url) {
+                return miniprogram.request(url, _this.requestConfig);
+            })).then(function(images) {
+                var resource = _this.resource;
+                for(var faceIndex = 0; faceIndex < 6; faceIndex++){
+                    resource.setImageSource(miniprogram.TextureCubeFace.PositiveX + faceIndex, images[faceIndex], 0);
+                }
+                resource.generateMipmaps();
+                resolve(resource);
+            }).catch(function(e) {
+                reject(e);
+            });
+        });
+    };
+    return TextureCubeContentRestorer;
+}(miniprogram.ContentRestorer);
+
 var TextureCubeLoader = /*#__PURE__*/ function(Loader) {
     _inherits(TextureCubeLoader, Loader);
     function TextureCubeLoader() {
@@ -4332,23 +4445,25 @@ var TextureCubeLoader = /*#__PURE__*/ function(Loader) {
     _proto.load = function load(item, resourceManager) {
         var _this = this;
         return new miniprogram.AssetPromise(function(resolve, reject) {
-            Promise.all(item.urls.map(function(url) {
-                return _this.request(url, _extends({}, item, {
-                    type: "image"
-                }));
+            var urls = item.urls;
+            var requestConfig = _extends({}, item, {
+                type: "image"
+            });
+            Promise.all(urls.map(function(url) {
+                return _this.request(url, requestConfig);
             })).then(function(images) {
                 var _images_ = images[0], width = _images_.width, height = _images_.height;
                 if (width !== height) {
                     console.error("The cube texture must have the same width and height");
                     return;
                 }
-                var tex = new miniprogram.TextureCube(resourceManager.engine, width);
-                /** @ts-ignore */ if (!tex._platformTexture) return;
+                var texture = new miniprogram.TextureCube(resourceManager.engine, width);
                 for(var faceIndex = 0; faceIndex < 6; faceIndex++){
-                    tex.setImageSource(miniprogram.TextureCubeFace.PositiveX + faceIndex, images[faceIndex], 0);
+                    texture.setImageSource(miniprogram.TextureCubeFace.PositiveX + faceIndex, images[faceIndex], 0);
                 }
-                tex.generateMipmaps();
-                resolve(tex);
+                texture.generateMipmaps();
+                resourceManager.addContentRestorer(new TextureCubeContentRestorer(texture, urls, requestConfig));
+                resolve(texture);
             }).catch(function(e) {
                 reject(e);
             });
@@ -4362,6 +4477,30 @@ TextureCubeLoader = __decorate([
     ])
 ], TextureCubeLoader);
 
+var AnimationClipLoader = /*#__PURE__*/ function(Loader) {
+    _inherits(AnimationClipLoader, Loader);
+    function AnimationClipLoader() {
+        return Loader.apply(this, arguments);
+    }
+    var _proto = AnimationClipLoader.prototype;
+    _proto.load = function load(item, resourceManager) {
+        var _this = this;
+        return new miniprogram.AssetPromise(function(resolve, reject) {
+            _this.request(item.url, _extends({}, item, {
+                type: "arraybuffer"
+            })).then(function(data) {
+                return decode(data, resourceManager.engine).then(resolve);
+            }).catch(reject);
+        });
+    };
+    return AnimationClipLoader;
+}(miniprogram.Loader);
+AnimationClipLoader = __decorate([
+    miniprogram.resourceLoader(miniprogram.AssetType.AnimationClip, [
+        "ani"
+    ])
+], AnimationClipLoader);
+
 var SceneLoader = /*#__PURE__*/ function(Loader) {
     _inherits(SceneLoader, Loader);
     function SceneLoader() {
@@ -4378,16 +4517,32 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
                 // @ts-ignore
                 engine.resourceManager.initVirtualResources(data.files);
                 return SceneParser.parse(engine, data).then(function(scene) {
+                    var promises = [];
                     // parse ambient light
                     var ambient = data.scene.ambient;
-                    var ambientLightPromise = Promise.resolve();
-                    if (ambient.ambientLight) {
-                        ambientLightPromise = resourceManager// @ts-ignore
-                        .getResourceByRef(data.scene.ambient.ambientLight).then(function(light) {
-                            scene.ambientLight = light;
+                    var useCustomAmbient = ambient.specularMode === "Custom";
+                    if (useCustomAmbient && ambient.customAmbientLight) {
+                        // @ts-ignore
+                        // prettier-ignore
+                        var customAmbientPromise = resourceManager.getResourceByRef(ambient.customAmbientLight).then(function(ambientLight) {
+                            scene.ambientLight = ambientLight;
+                            scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
+                            scene.ambientLight.specularIntensity = ambient.specularIntensity;
+                            scene.ambientLight.diffuseMode = ambient.diffuseMode;
+                            scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
+                        });
+                        promises.push(customAmbientPromise);
+                    } else if (!useCustomAmbient && ambient.ambientLight) {
+                        // @ts-ignore
+                        // prettier-ignore
+                        var ambientLightPromise = resourceManager.getResourceByRef(ambient.ambientLight).then(function(ambientLight) {
+                            scene.ambientLight = ambientLight;
                             scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
                             scene.ambientLight.specularIntensity = ambient.specularIntensity;
+                            scene.ambientLight.diffuseMode = ambient.diffuseMode;
+                            scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
                         });
+                        promises.push(ambientLightPromise);
                     } else {
                         scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
                         scene.ambientLight.specularIntensity = ambient.specularIntensity;
@@ -4395,30 +4550,34 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
                     }
                     var background = data.scene.background;
                     scene.background.mode = background.mode;
-                    var backgroundPromise = Promise.resolve();
                     switch(scene.background.mode){
                         case miniprogram.BackgroundMode.SolidColor:
                             scene.background.solidColor.copyFrom(background.color);
                             break;
                         case miniprogram.BackgroundMode.Sky:
-                            if (background.sky) {
+                            if (background.skyMesh && background.skyMaterial) {
                                 // @ts-ignore
-                                backgroundPromise = resourceManager.getResourceByRef(background.sky).then(function(light) {
-                                    var sky = scene.background.sky;
-                                    var skyMaterial = new miniprogram.SkyBoxMaterial(engine);
-                                    skyMaterial.textureCubeMap = light.specularTexture;
-                                    skyMaterial.textureDecodeRGBM = true;
-                                    sky.material = skyMaterial;
-                                    sky.mesh = miniprogram.PrimitiveMesh.createCuboid(engine, 1, 1, 1);
+                                var skyMeshPromise = resourceManager.getResourceByRef(background.skyMesh).then(function(mesh) {
+                                    scene.background.sky.mesh = mesh;
                                 });
+                                // @ts-ignore
+                                // prettier-ignore
+                                var skyMaterialPromise = resourceManager.getResourceByRef(background.skyMaterial).then(function(material) {
+                                    scene.background.sky.material = material;
+                                });
+                                promises.push(skyMeshPromise, skyMaterialPromise);
+                            } else {
+                                miniprogram.Logger.warn("Sky background mode requires skyMesh and skyMaterial");
                             }
                             break;
                         case miniprogram.BackgroundMode.Texture:
                             if (background.texture) {
                                 // @ts-ignore
-                                backgroundPromise = resourceManager.getResourceByRef(background.texture).then(function(texture) {
+                                // prettier-ignore
+                                var backgroundPromise = resourceManager.getResourceByRef(background.texture).then(function(texture) {
                                     scene.background.texture = texture;
                                 });
+                                promises.push(backgroundPromise);
                             }
                             break;
                     }
@@ -4430,10 +4589,7 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
                         if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
                         if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
                     }
-                    return Promise.all([
-                        ambientLightPromise,
-                        backgroundPromise
-                    ]).then(function() {
+                    return Promise.all(promises).then(function() {
                         resolve(scene);
                     });
                 });
@@ -4462,10 +4618,410 @@ ReflectionParser.registerCustomParseComponent("TextRenderer", /*#__PURE__*/ _asy
     });
 }));
 
+var _KHR_draco_mesh_compression;
+var KHR_draco_mesh_compression = (_KHR_draco_mesh_compression = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_draco_mesh_compression1, GLTFExtensionParser);
+    function KHR_draco_mesh_compression1() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_draco_mesh_compression1.prototype;
+    _proto.initialize = function initialize() {
+        if (!KHR_draco_mesh_compression._decoder) {
+            KHR_draco_mesh_compression._decoder = new miniprogram$3.DRACODecoder();
+        }
+    };
+    _proto.createAndParse = function createAndParse(context, schema, glTFPrimitive, glTFMesh) {
+        var _this = this;
+        var glTF = context.glTF, engine = context.glTFResource.engine;
+        var bufferViews = glTF.bufferViews, accessors = glTF.accessors;
+        var bufferViewIndex = schema.bufferView, gltfAttributeMap = schema.attributes;
+        var attributeMap = {};
+        var attributeTypeMap = {};
+        for(var attributeName in gltfAttributeMap){
+            attributeMap[attributeName] = gltfAttributeMap[attributeName];
+        }
+        for(var attributeName1 in glTFPrimitive.attributes){
+            if (gltfAttributeMap[attributeName1] !== undefined) {
+                var accessorDef = accessors[glTFPrimitive.attributes[attributeName1]];
+                attributeTypeMap[attributeName1] = GLTFUtils.getComponentType(accessorDef.componentType).name;
+            }
+        }
+        var indexAccessor = accessors[glTFPrimitive.indices];
+        var indexType = GLTFUtils.getComponentType(indexAccessor.componentType).name;
+        var taskConfig = {
+            attributeIDs: attributeMap,
+            attributeTypes: attributeTypeMap,
+            useUniqueIDs: true,
+            indexType: indexType
+        };
+        return context.getBuffers().then(function(buffers) {
+            var buffer = GLTFUtils.getBufferViewData(bufferViews[bufferViewIndex], buffers);
+            return KHR_draco_mesh_compression._decoder.decode(buffer, taskConfig).then(function(decodedGeometry) {
+                var mesh = new miniprogram.ModelMesh(engine, glTFMesh.name);
+                return _this._parseMeshFromGLTFPrimitiveDraco(mesh, glTFMesh, glTFPrimitive, glTF, function(attributeSemantic) {
+                    for(var j = 0; j < decodedGeometry.attributes.length; j++){
+                        if (decodedGeometry.attributes[j].name === attributeSemantic) {
+                            return decodedGeometry.attributes[j].array;
+                        }
+                    }
+                    return null;
+                }, function(attributeSemantic, shapeIndex) {
+                    throw "BlendShape animation is not supported when using draco.";
+                }, function() {
+                    return decodedGeometry.index.array;
+                }, context.keepMeshData);
+            });
+        });
+    };
+    _proto._parseMeshFromGLTFPrimitiveDraco = function _parseMeshFromGLTFPrimitiveDraco(mesh, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
+        var attributes = gltfPrimitive.attributes, targets = gltfPrimitive.targets, indices = gltfPrimitive.indices, mode = gltfPrimitive.mode;
+        var vertexCount;
+        var accessors = gltf.accessors;
+        var accessor = accessors[attributes["POSITION"]];
+        var positionBuffer = getVertexBufferData("POSITION");
+        var positions = GLTFUtils.floatBufferToVector3Array(positionBuffer);
+        mesh.setPositions(positions);
+        var bounds = mesh.bounds;
+        vertexCount = accessor.count;
+        if (accessor.min && accessor.max) {
+            bounds.min.copyFromArray(accessor.min);
+            bounds.max.copyFromArray(accessor.max);
+        } else {
+            var position = KHR_draco_mesh_compression._tempVector3;
+            var min = bounds.min, max = bounds.max;
+            min.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+            max.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+            var stride = positionBuffer.length / vertexCount;
+            for(var j = 0; j < vertexCount; j++){
+                var offset = j * stride;
+                position.copyFromArray(positionBuffer, offset);
+                miniprogram$1.Vector3.min(min, position, min);
+                miniprogram$1.Vector3.max(max, position, max);
+            }
+        }
+        for(var attributeSemantic in attributes){
+            if (attributeSemantic === "POSITION") {
+                continue;
+            }
+            var bufferData = getVertexBufferData(attributeSemantic);
+            switch(attributeSemantic){
+                case "NORMAL":
+                    var normals = GLTFUtils.floatBufferToVector3Array(bufferData);
+                    mesh.setNormals(normals);
+                    break;
+                case "TEXCOORD_0":
+                    var texturecoords = GLTFUtils.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords, 0);
+                    break;
+                case "TEXCOORD_1":
+                    var texturecoords1 = GLTFUtils.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords1, 1);
+                    break;
+                case "TEXCOORD_2":
+                    var texturecoords2 = GLTFUtils.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords2, 2);
+                    break;
+                case "TEXCOORD_3":
+                    var texturecoords3 = GLTFUtils.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords3, 3);
+                    break;
+                case "TEXCOORD_4":
+                    var texturecoords4 = GLTFUtils.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords4, 4);
+                    break;
+                case "TEXCOORD_5":
+                    var texturecoords5 = GLTFUtils.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords5, 5);
+                    break;
+                case "TEXCOORD_6":
+                    var texturecoords6 = GLTFUtils.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords6, 6);
+                    break;
+                case "TEXCOORD_7":
+                    var texturecoords7 = GLTFUtils.floatBufferToVector2Array(bufferData);
+                    mesh.setUVs(texturecoords7, 7);
+                    break;
+                case "COLOR_0":
+                    var colors = GLTFUtils.floatBufferToColorArray(bufferData, accessors[attributes["COLOR_0"]].type === AccessorType.VEC3);
+                    mesh.setColors(colors);
+                    break;
+                case "TANGENT":
+                    var tangents = GLTFUtils.floatBufferToVector4Array(bufferData);
+                    mesh.setTangents(tangents);
+                    break;
+                case "JOINTS_0":
+                    var joints = GLTFUtils.floatBufferToVector4Array(bufferData);
+                    mesh.setBoneIndices(joints);
+                    break;
+                case "WEIGHTS_0":
+                    var weights = GLTFUtils.floatBufferToVector4Array(bufferData);
+                    mesh.setBoneWeights(weights);
+                    break;
+            }
+        }
+        // Indices
+        if (indices !== undefined) {
+            var indexAccessor = gltf.accessors[indices];
+            var indexData = getIndexBufferData();
+            mesh.setIndices(indexData);
+            mesh.addSubMesh(0, indexAccessor.count, mode);
+        } else {
+            mesh.addSubMesh(0, vertexCount, mode);
+        }
+        // BlendShapes
+        targets && GLTFMeshParser._createBlendShape(mesh, null, gltfMesh, accessors, targets, getBlendShapeData);
+        mesh.uploadData(!keepMeshData);
+        return Promise.resolve(mesh);
+    };
+    return KHR_draco_mesh_compression1;
+}(GLTFExtensionParser), function() {
+    _KHR_draco_mesh_compression._tempVector3 = new miniprogram$1.Vector3();
+}(), _KHR_draco_mesh_compression);
+KHR_draco_mesh_compression = __decorate([
+    registerGLTFExtension("KHR_draco_mesh_compression", exports.GLTFExtensionMode.CreateAndParse)
+], KHR_draco_mesh_compression);
+
+var KHR_lights_punctual = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_lights_punctual, GLTFExtensionParser);
+    function KHR_lights_punctual() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_lights_punctual.prototype;
+    _proto.additiveParse = function additiveParse(context, entity, extensionSchema) {
+        var lightsSchema = context.glTF.extensions.KHR_lights_punctual.lights;
+        var lightSchema = lightsSchema[extensionSchema.light];
+        var color = lightSchema.color, _lightSchema_intensity = lightSchema.intensity, intensity = _lightSchema_intensity === void 0 ? 1 : _lightSchema_intensity, type = lightSchema.type, range = lightSchema.range, spot = lightSchema.spot;
+        var glTFResource = context.glTFResource;
+        var light;
+        if (type === "directional") {
+            light = entity.addComponent(miniprogram.DirectLight);
+        } else if (type === "point") {
+            light = entity.addComponent(miniprogram.PointLight);
+        } else if (type === "spot") {
+            light = entity.addComponent(miniprogram.SpotLight);
+        }
+        if (color) {
+            light.color.set(color[0], color[1], color[2], 1);
+        }
+        light.intensity = intensity;
+        if (range && !_instanceof(light, miniprogram.DirectLight)) {
+            light.distance = range;
+        }
+        if (spot && _instanceof(light, miniprogram.SpotLight)) {
+            var _spot_innerConeAngle = spot.innerConeAngle, innerConeAngle = _spot_innerConeAngle === void 0 ? 0 : _spot_innerConeAngle, _spot_outerConeAngle = spot.outerConeAngle, outerConeAngle = _spot_outerConeAngle === void 0 ? Math.PI / 4 : _spot_outerConeAngle;
+            light.angle = innerConeAngle;
+            light.penumbra = outerConeAngle - innerConeAngle;
+        }
+        if (!glTFResource.lights) glTFResource.lights = [];
+        glTFResource.lights.push(light);
+    };
+    return KHR_lights_punctual;
+}(GLTFExtensionParser);
+KHR_lights_punctual = __decorate([
+    registerGLTFExtension("KHR_lights_punctual", exports.GLTFExtensionMode.AdditiveParse)
+], KHR_lights_punctual);
+
+var KHR_materials_clearcoat = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_materials_clearcoat, GLTFExtensionParser);
+    function KHR_materials_clearcoat() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_materials_clearcoat.prototype;
+    _proto.additiveParse = function additiveParse(context, material, schema) {
+        var textures = context.glTFResource.textures;
+        var _schema_clearcoatFactor = schema.clearcoatFactor, clearcoatFactor = _schema_clearcoatFactor === void 0 ? 0 : _schema_clearcoatFactor, clearcoatTexture = schema.clearcoatTexture, _schema_clearcoatRoughnessFactor = schema.clearcoatRoughnessFactor, clearcoatRoughnessFactor = _schema_clearcoatRoughnessFactor === void 0 ? 0 : _schema_clearcoatRoughnessFactor, clearcoatRoughnessTexture = schema.clearcoatRoughnessTexture, clearcoatNormalTexture = schema.clearcoatNormalTexture;
+        material.clearCoat = clearcoatFactor;
+        material.clearCoatRoughness = clearcoatRoughnessFactor;
+        if (clearcoatTexture) {
+            material.clearCoatTexture = textures[clearcoatTexture.index];
+            GLTFMaterialParser._checkOtherTextureTransform(clearcoatTexture, "Clear coat");
+        }
+        if (clearcoatRoughnessTexture) {
+            material.clearCoatRoughnessTexture = textures[clearcoatRoughnessTexture.index];
+            GLTFMaterialParser._checkOtherTextureTransform(clearcoatRoughnessTexture, "Clear coat roughness");
+        }
+        if (clearcoatNormalTexture) {
+            material.clearCoatNormalTexture = textures[clearcoatNormalTexture.index];
+            GLTFMaterialParser._checkOtherTextureTransform(clearcoatNormalTexture, "Clear coat normal");
+        }
+    };
+    return KHR_materials_clearcoat;
+}(GLTFExtensionParser);
+KHR_materials_clearcoat = __decorate([
+    registerGLTFExtension("KHR_materials_clearcoat", exports.GLTFExtensionMode.AdditiveParse)
+], KHR_materials_clearcoat);
+
+var KHR_materials_ior = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_materials_ior, GLTFExtensionParser);
+    function KHR_materials_ior() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_materials_ior.prototype;
+    _proto.additiveParse = function additiveParse(context, material, schema) {
+        var _schema_ior = schema.ior, ior = _schema_ior === void 0 ? 1.5 : _schema_ior;
+        material.ior = ior;
+    };
+    return KHR_materials_ior;
+}(GLTFExtensionParser);
+KHR_materials_ior = __decorate([
+    registerGLTFExtension("KHR_materials_ior", exports.GLTFExtensionMode.AdditiveParse)
+], KHR_materials_ior);
+
+var KHR_materials_pbrSpecularGlossiness = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_materials_pbrSpecularGlossiness, GLTFExtensionParser);
+    function KHR_materials_pbrSpecularGlossiness() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_materials_pbrSpecularGlossiness.prototype;
+    _proto.createAndParse = function createAndParse(context, schema, ownerSchema) {
+        var _context_glTFResource = context.glTFResource, engine = _context_glTFResource.engine, textures = _context_glTFResource.textures;
+        var material = new miniprogram.PBRSpecularMaterial(engine);
+        var diffuseFactor = schema.diffuseFactor, diffuseTexture = schema.diffuseTexture, specularFactor = schema.specularFactor, glossinessFactor = schema.glossinessFactor, specularGlossinessTexture = schema.specularGlossinessTexture;
+        if (diffuseFactor) {
+            material.baseColor = new miniprogram$1.Color(miniprogram$1.Color.linearToGammaSpace(diffuseFactor[0]), miniprogram$1.Color.linearToGammaSpace(diffuseFactor[1]), miniprogram$1.Color.linearToGammaSpace(diffuseFactor[2]), diffuseFactor[3]);
+        }
+        if (diffuseTexture) {
+            material.baseTexture = textures[diffuseTexture.index];
+            GLTFParser.executeExtensionsAdditiveAndParse(diffuseTexture.extensions, context, material, diffuseTexture);
+        }
+        if (specularFactor) {
+            material.specularColor = new miniprogram$1.Color(miniprogram$1.Color.linearToGammaSpace(specularFactor[0]), miniprogram$1.Color.linearToGammaSpace(specularFactor[1]), miniprogram$1.Color.linearToGammaSpace(specularFactor[2]));
+        }
+        if (glossinessFactor !== undefined) {
+            material.glossiness = glossinessFactor;
+        }
+        if (specularGlossinessTexture) {
+            material.specularGlossinessTexture = textures[specularGlossinessTexture.index];
+            GLTFMaterialParser._checkOtherTextureTransform(specularGlossinessTexture, "Specular glossiness");
+        }
+        material.name = ownerSchema.name;
+        GLTFMaterialParser._parseStandardProperty(context, material, ownerSchema);
+        return material;
+    };
+    return KHR_materials_pbrSpecularGlossiness;
+}(GLTFExtensionParser);
+KHR_materials_pbrSpecularGlossiness = __decorate([
+    registerGLTFExtension("KHR_materials_pbrSpecularGlossiness", exports.GLTFExtensionMode.CreateAndParse)
+], KHR_materials_pbrSpecularGlossiness);
+
+var KHR_materials_unlit = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_materials_unlit, GLTFExtensionParser);
+    function KHR_materials_unlit() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_materials_unlit.prototype;
+    _proto.createAndParse = function createAndParse(context, _, ownerSchema) {
+        var engine = context.glTFResource.engine;
+        var material = new miniprogram.UnlitMaterial(engine);
+        material.name = ownerSchema.name;
+        GLTFMaterialParser._parseStandardProperty(context, material, ownerSchema);
+        return material;
+    };
+    return KHR_materials_unlit;
+}(GLTFExtensionParser);
+KHR_materials_unlit = __decorate([
+    registerGLTFExtension("KHR_materials_unlit", exports.GLTFExtensionMode.CreateAndParse)
+], KHR_materials_unlit);
+
+var KHR_mesh_quantization = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_mesh_quantization, GLTFExtensionParser);
+    function KHR_mesh_quantization() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    return KHR_mesh_quantization;
+}(GLTFExtensionParser);
+KHR_mesh_quantization = __decorate([
+    registerGLTFExtension("KHR_mesh_quantization", exports.GLTFExtensionMode.AdditiveParse)
+], KHR_mesh_quantization);
+
+var KHR_texture_transform = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(KHR_texture_transform, GLTFExtensionParser);
+    function KHR_texture_transform() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = KHR_texture_transform.prototype;
+    _proto.additiveParse = function additiveParse(context, material, schema) {
+        var offset = schema.offset, rotation = schema.rotation, scale = schema.scale, texCoord = schema.texCoord;
+        if (offset) {
+            material.tilingOffset.z = offset[0];
+            material.tilingOffset.w = offset[1];
+        }
+        if (scale) {
+            material.tilingOffset.x = scale[0];
+            material.tilingOffset.y = scale[1];
+        }
+        if (rotation) {
+            miniprogram.Logger.warn("rotation in KHR_texture_transform is not supported now");
+        }
+        if (texCoord) {
+            miniprogram.Logger.warn("texCoord in KHR_texture_transform is not supported now");
+        }
+    };
+    return KHR_texture_transform;
+}(GLTFExtensionParser);
+KHR_texture_transform = __decorate([
+    registerGLTFExtension("KHR_texture_transform", exports.GLTFExtensionMode.AdditiveParse)
+], KHR_texture_transform);
+
+var GALACEAN_materials_remap = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(GALACEAN_materials_remap, GLTFExtensionParser);
+    function GALACEAN_materials_remap() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = GALACEAN_materials_remap.prototype;
+    _proto.createAndParse = function createAndParse(context, schema) {
+        var engine = context.glTFResource.engine;
+        // @ts-ignore
+        return engine.resourceManager.getResourceByRef(schema);
+    };
+    return GALACEAN_materials_remap;
+}(GLTFExtensionParser);
+GALACEAN_materials_remap = __decorate([
+    registerGLTFExtension("GALACEAN_materials_remap", exports.GLTFExtensionMode.CreateAndParse)
+], GALACEAN_materials_remap);
+
+var GALACEAN_animation_event = /*#__PURE__*/ function(GLTFExtensionParser) {
+    _inherits(GALACEAN_animation_event, GLTFExtensionParser);
+    function GALACEAN_animation_event() {
+        return GLTFExtensionParser.apply(this, arguments);
+    }
+    var _proto = GALACEAN_animation_event.prototype;
+    _proto.additiveParse = function additiveParse(context, animationClip, schema) {
+        context.glTFResource.engine;
+        var events = schema.events;
+        events.map(function(eventData) {
+            var event = new miniprogram.AnimationEvent();
+            event.functionName = eventData.functionName;
+            event.time = eventData.time;
+            event.parameter = eventData.parameter;
+            animationClip.addEvent(event);
+        });
+    };
+    return GALACEAN_animation_event;
+}(GLTFExtensionParser);
+GALACEAN_animation_event = __decorate([
+    registerGLTFExtension("GALACEAN_animation_event", exports.GLTFExtensionMode.AdditiveParse)
+], GALACEAN_animation_event);
+
 exports.ComponentMap = ComponentMap;
+exports.GLTFAnimationParser = GLTFAnimationParser;
+exports.GLTFBufferParser = GLTFBufferParser;
+exports.GLTFEntityParser = GLTFEntityParser;
+exports.GLTFExtensionParser = GLTFExtensionParser;
+exports.GLTFMaterialParser = GLTFMaterialParser;
+exports.GLTFMeshParser = GLTFMeshParser;
+exports.GLTFParser = GLTFParser;
+exports.GLTFParserContext = GLTFParserContext;
+exports.GLTFPipeline = GLTFPipeline;
 exports.GLTFResource = GLTFResource;
+exports.GLTFSceneParser = GLTFSceneParser;
+exports.GLTFSkinParser = GLTFSkinParser;
+exports.GLTFTextureParser = GLTFTextureParser;
+exports.GLTFUtils = GLTFUtils;
+exports.GLTFValidator = GLTFValidator;
 exports.PrefabParser = PrefabParser;
 exports.ReflectionParser = ReflectionParser;
 exports.SceneParser = SceneParser;
 exports.decode = decode;
 exports.parseSingleKTX = parseSingleKTX;
+exports.registerGLTFExtension = registerGLTFExtension;