@galacean/engine-loader 1.0.0-beta.16 → 1.0.0-beta.18

package/dist/miniprogram.js

@@ -122,7 +122,8 @@ var AnimatorControllerLoader = /*#__PURE__*/ function(Loader1) {
                             state.wrapMode = wrapMode;
                             state.clipStartTime = clipStartNormalizedTime;
                             state.clipEndTime = clipEndNormalizedTime;
-                            scripts == null ? void 0 : scripts.forEach(function(script) {
+                            var scriptsObject = JSON.parse(scripts);
+                            scriptsObject == null ? void 0 : scriptsObject.forEach(function(script) {
                                 state.addStateMachineScript(miniprogram.Loader.getClass(script));
                             });
                             if (clipData) {
@@ -443,15 +444,18 @@ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
                         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 positionData = _this._getBufferData(buffers, restoreInfo.position);
-                            frame.deltaPositions = GLTFUtils.floatBufferToVector3Array(positionData);
+                            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 normalData = _this._getBufferData(buffers, restoreInfo.normal);
-                                frame.deltaNormals = GLTFUtils.floatBufferToVector3Array(normalData);
+                                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 tangentData = _this._getBufferData(buffers, restoreInfo.tangent);
-                                frame.deltaTangents = GLTFUtils.floatBufferToVector3Array(tangentData);
+                                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);
@@ -535,6 +539,14 @@ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
     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;
+};
 
 /**
  * Module for glTF 2.0 Interface
@@ -706,6 +718,11 @@ var TextureWrapMode;
         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;
@@ -827,44 +844,58 @@ var TextureWrapMode;
         }
     };
     GLTFUtils.getAccessorBuffer = function getAccessorBuffer(context, bufferViews, accessor) {
-        var buffers = context.buffers;
         var componentType = accessor.componentType;
         var bufferView = bufferViews[accessor.bufferView];
-        var bufferIndex = bufferView.buffer;
-        var buffer = buffers[bufferIndex];
-        var bufferByteOffset = bufferView.byteOffset || 0;
-        var byteOffset = 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));
+        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 * dataElementSize;
-            var data1 = new TypedArray(buffer, offset1, count1);
-            bufferInfo = new BufferInfo(data1, false, elementStride);
-            bufferInfo.restoreInfo = new BufferDataRestoreInfo(new RestoreDataAccessor(bufferIndex, TypedArray, offset1, count1));
-        }
-        if (accessor.sparse) {
-            GLTFUtils.processingSparseData(bufferViews, accessor, buffers, bufferInfo);
+            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
@@ -1330,7 +1361,7 @@ var GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
     }
     var _proto = GLTFAnimationParser.prototype;
     _proto.parse = function parse(context) {
-        var glTF = context.glTF; context.buffers; var glTFResource = context.glTFResource;
+        var glTF = context.glTF, glTFResource = context.glTFResource;
         glTFResource.entities;
         var animations = glTF.animations; glTF.accessors; glTF.bufferViews;
         if (!animations) {
@@ -1340,106 +1371,120 @@ var GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
         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);
-                GLTFAnimationParser._parseStandardProperty(context, animationClip, animationInfo);
+                parseStandardPropertyPromises.push(GLTFAnimationParser._parseStandardProperty(context, animationClip, animationInfo));
             }
             animationClipPromises.push(animationClip);
         }
-        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 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;
+            });
         });
     };
     /**
    * @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 = 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;
+                    }
+                    output = scaled;
+                }
+                var outputStride = output.length / input.length;
+                var _gltfSampler_interpolation;
+                var interpolation = (_gltfSampler_interpolation = gltfSampler.interpolation) != null ? _gltfSampler_interpolation : AnimationSamplerInterpolation.Linear;
+                var samplerInterpolation;
+                switch(interpolation){
+                    case AnimationSamplerInterpolation.CubicSpine:
+                        samplerInterpolation = miniprogram.InterpolationType.CubicSpine;
+                        break;
+                    case AnimationSamplerInterpolation.Step:
+                        samplerInterpolation = miniprogram.InterpolationType.Step;
+                        break;
+                    case AnimationSamplerInterpolation.Linear:
+                        samplerInterpolation = miniprogram.InterpolationType.Linear;
+                        break;
+                }
+                input[input.length - 1];
+                sampleDataCollection.push({
+                    type: outputAccessor.type,
+                    interpolation: samplerInterpolation,
+                    input: input,
+                    output: output,
+                    outputSize: outputStride
+                });
+            });
+            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++){
-            var gltfSampler = samplers[j];
-            var inputAccessor = accessors[gltfSampler.input];
-            var outputAccessor = accessors[gltfSampler.output];
-            var input = GLTFUtils.getAccessorBuffer(context, bufferViews, inputAccessor).data;
-            var output = GLTFUtils.getAccessorBuffer(context, bufferViews, outputAccessor).data;
-            if (outputAccessor.normalized) {
-                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;
+        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 = "";
+                var entity = channelTargetEntity;
+                while(entity.parent){
+                    relativePath = relativePath === "" ? "" + entity.name : entity.name + "/" + relativePath;
+                    entity = entity.parent;
                 }
-                output = scaled;
-            }
-            var outputStride = output.length / input.length;
-            var _gltfSampler_interpolation;
-            var interpolation = (_gltfSampler_interpolation = gltfSampler.interpolation) != null ? _gltfSampler_interpolation : AnimationSamplerInterpolation.Linear;
-            var samplerInterpolation = void 0;
-            switch(interpolation){
-                case AnimationSamplerInterpolation.CubicSpine:
-                    samplerInterpolation = miniprogram.InterpolationType.CubicSpine;
-                    break;
-                case AnimationSamplerInterpolation.Step:
-                    samplerInterpolation = miniprogram.InterpolationType.Step;
-                    break;
-                case AnimationSamplerInterpolation.Linear:
-                    samplerInterpolation = miniprogram.InterpolationType.Linear;
-                    break;
-            }
-            input[input.length - 1];
-            sampleDataCollection.push({
-                type: outputAccessor.type,
-                interpolation: samplerInterpolation,
-                input: input,
-                output: output,
-                outputSize: outputStride
-            });
-        }
-        for(var j1 = 0, m1 = channels.length; j1 < m1; j1++){
-            var gltfChannel = channels[j1];
-            var target = gltfChannel.target;
-            var channelTargetEntity = entities[target.node];
-            var relativePath = "";
-            var entity = channelTargetEntity;
-            while(entity.parent){
-                relativePath = relativePath === "" ? "" + entity.name : entity.name + "/" + relativePath;
-                entity = entity.parent;
-            }
-            var ComponentType = void 0;
-            var propertyName = void 0;
-            switch(target.path){
-                case AnimationChannelTargetPath.TRANSLATION:
-                    ComponentType = miniprogram.Transform;
-                    propertyName = "position";
-                    break;
-                case AnimationChannelTargetPath.ROTATION:
-                    ComponentType = miniprogram.Transform;
-                    propertyName = "rotationQuaternion";
-                    break;
-                case AnimationChannelTargetPath.SCALE:
-                    ComponentType = miniprogram.Transform;
-                    propertyName = "scale";
-                    break;
-                case AnimationChannelTargetPath.WEIGHTS:
-                    ComponentType = miniprogram.SkinnedMeshRenderer;
-                    propertyName = "blendShapeWeights";
-                    break;
+                var ComponentType = void 0;
+                var propertyName = void 0;
+                switch(target.path){
+                    case AnimationChannelTargetPath.TRANSLATION:
+                        ComponentType = miniprogram.Transform;
+                        propertyName = "position";
+                        break;
+                    case AnimationChannelTargetPath.ROTATION:
+                        ComponentType = miniprogram.Transform;
+                        propertyName = "rotationQuaternion";
+                        break;
+                    case AnimationChannelTargetPath.SCALE:
+                        ComponentType = miniprogram.Transform;
+                        propertyName = "scale";
+                        break;
+                    case AnimationChannelTargetPath.WEIGHTS:
+                        ComponentType = miniprogram.SkinnedMeshRenderer;
+                        propertyName = "blendShapeWeights";
+                        break;
+                }
+                var curve = _this._addCurve(target.path, gltfChannel, sampleDataCollection);
+                animationClip.addCurveBinding(relativePath, ComponentType, propertyName, curve);
             }
-            var curve = this._addCurve(target.path, gltfChannel, sampleDataCollection);
-            animationClip.addCurveBinding(relativePath, ComponentType, propertyName, curve);
-        }
+        });
     };
     GLTFAnimationParser._addCurve = function _addCurve(animationChannelTargetPath, gltfChannel, sampleDataCollection) {
         var sampleData = sampleDataCollection[gltfChannel.sampler];
@@ -1534,20 +1579,18 @@ var GLTFBufferParser = /*#__PURE__*/ function(GLTFParser) {
             }).then(function(param) {
                 var glTF = param.glTF, buffers = param.buffers;
                 context.glTF = glTF;
-                context.buffers = buffers;
+                context._buffers = buffers;
             });
         } else {
             return miniprogram.request(url, {
                 type: "json"
             }).then(function(glTF) {
                 context.glTF = glTF;
-                return Promise.all(glTF.buffers.map(function(buffer) {
+                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);
-                })).then(function(buffers) {
-                    context.buffers = buffers;
-                });
+                }));
             });
         }
     };
@@ -1796,7 +1839,9 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
                             }
                         }, function() {
                             var indexAccessor = glTF.accessors[gltfPrimitive.indices];
-                            return GLTFUtils.getAccessorData(glTF, indexAccessor, buffers);
+                            return context.getBuffers().then(function(buffers) {
+                                return GLTFUtils.getAccessorData(glTF, indexAccessor, buffers);
+                            });
                         }, context.keepMeshData).then(resolve);
                     }
                 });
@@ -1806,7 +1851,7 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
             for(var j = 0; j < gltfMesh.primitives.length; j++)_loop(j);
             meshPromises[i] = Promise.all(primitivePromises);
         };
-        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;
         var meshesPromiseInfo = context.meshesPromiseInfo;
@@ -1821,8 +1866,109 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
     /**
    * @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 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]);
+                    }
+                } else {
+                    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++;
+                }
+                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;
+                            }
+                        }
+                    }
+                    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;
+                    }
+                }
+            });
+            promises.push(promise);
+        };
         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();
@@ -1836,145 +1982,85 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
             boneIndices = new Array(vertexCount);
             boneWeights = new Array(vertexCount);
         }
-        for(var attribute in attributes){
-            var accessor = accessors[attributes[attribute]];
-            var accessorBuffer = GLTFUtils.getAccessorBuffer(context, gltf.bufferViews, accessor);
-            var dataElementSize = GLTFUtils.getAccessorTypeSize(accessor.type);
-            var accessorCount = accessor.count;
-            var vertices = accessorBuffer.data;
-            var vertexElement = void 0;
-            var meshId = mesh.instanceId;
-            var vertexBindingInfos = accessorBuffer.vertexBindingInfos;
-            var elementNormalized = accessor.normalized;
-            var elementFormat = GLTFUtils.getElementFormat(accessor.componentType, dataElementSize, elementNormalized);
-            var scaleFactor = void 0;
-            elementNormalized && (scaleFactor = GLTFUtils.getNormalizedComponentScale(accessor.componentType));
-            var elementOffset = void 0;
-            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]);
-                }
+        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 {
-                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++;
+                mesh.addSubMesh(0, vertexCount, mode);
             }
-            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;
-                        }
-                    }
-                }
-                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;
-                }
+            // BlendShapes
+            if (targets) {
+                promises.push(GLTFMeshParser._createBlendShape(mesh, meshRestoreInfo, gltfMesh, accessors, targets, getBlendShapeData));
             }
-        }
-        mesh.setVertexElements(vertexElements);
-        // Indices
-        if (indices !== undefined) {
-            var indexAccessor = gltf.accessors[indices];
-            var accessorBuffer1 = GLTFUtils.getAccessorBuffer(context, gltf.bufferViews, indexAccessor);
-            mesh.setIndices(accessorBuffer1.data);
-            mesh.addSubMesh(0, indexAccessor.count, mode);
-            meshRestoreInfo.indexBuffer = accessorBuffer1.restoreInfo;
-        } else {
-            mesh.addSubMesh(0, vertexCount, mode);
-        }
-        // BlendShapes
-        targets && GLTFMeshParser._createBlendShape(mesh, meshRestoreInfo, gltfMesh, targets, getBlendShapeData);
-        mesh.uploadData(!keepMeshData);
-        //@ts-ignore
-        mesh._positions = positions;
-        //@ts-ignore
-        mesh._boneIndices = boneIndices;
-        //@ts-ignore
-        mesh._boneWeights = boneWeights;
-        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, glTFTargets, getBlendShapeData) {
-        var blendShapeNames = glTFMesh.extras ? glTFMesh.extras.targetNames : null;
-        for(var i = 0, n = glTFTargets.length; i < n; i++){
+   */ GLTFMeshParser._createBlendShape = function _createBlendShape(mesh, meshRestoreInfo, glTFMesh, accessors, glTFTargets, getBlendShapeData) {
+        var _loop = function(i, n) {
             var name = blendShapeNames ? blendShapeNames[i] : "blendShape" + i;
-            var deltaPosBufferInfo = getBlendShapeData("POSITION", i);
-            var deltaNorBufferInfo = getBlendShapeData("NORMAL", i);
-            var deltaTanBufferInfo = getBlendShapeData("TANGENT", i);
-            var deltaPositions = deltaPosBufferInfo.data ? GLTFUtils.floatBufferToVector3Array(deltaPosBufferInfo.data) : null;
-            var deltaNormals = (deltaNorBufferInfo == null ? void 0 : deltaNorBufferInfo.data) ? GLTFUtils.floatBufferToVector3Array(deltaNorBufferInfo == null ? void 0 : deltaNorBufferInfo.data) : null;
-            var deltaTangents = (deltaTanBufferInfo == null ? void 0 : deltaTanBufferInfo.data) ? GLTFUtils.floatBufferToVector3Array(deltaTanBufferInfo == null ? void 0 : deltaTanBufferInfo.data) : null;
-            var blendShape = new miniprogram.BlendShape(name);
-            blendShape.addFrame(1.0, deltaPositions, deltaNormals, deltaTangents);
-            mesh.addBlendShape(blendShape);
-            meshRestoreInfo.blendShapes.push(new BlendShapeRestoreInfo(blendShape, deltaPosBufferInfo.restoreInfo, deltaNorBufferInfo == null ? void 0 : deltaNorBufferInfo.restoreInfo, deltaTanBufferInfo == null ? void 0 : deltaTanBufferInfo.restoreInfo));
-        }
+            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 GLTFMeshParser;
 }(GLTFParser);
@@ -2126,51 +2212,58 @@ var GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
     }
     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 = GLTFUtils.getAccessorBuffer(context, glTF.bufferViews, 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 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 = {};
@@ -2211,13 +2304,14 @@ var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
     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) {
             var texturesPromiseInfo = context.texturesPromiseInfo;
             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 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(".");
@@ -2225,31 +2319,36 @@ var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
                     var type = ext.startsWith("ktx") ? miniprogram.AssetType.KTX : miniprogram.AssetType.Texture2D;
                     return engine.resourceManager.load({
                         url: miniprogram.Utils.resolveAbsoluteUrl(url, uri),
-                        type: type
+                        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 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);
-                        texture.setImageSource(image);
-                        texture.generateMipmaps();
-                        texture.name = textureName || imageName || "texture_" + index;
-                        if (sampler !== undefined) {
-                            _this._parseSampler(texture, glTF.samplers[sampler]);
-                        }
-                        var bufferTextureRestoreInfo = new BufferTextureRestoreInfo(texture, bufferView, mimeType);
-                        context.contentRestorer.bufferTextures.push(bufferTextureRestoreInfo);
-                        return texture;
+                    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) {
@@ -2259,22 +2358,39 @@ var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
             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 = GLTFTextureParser._wrapMap[wrapS];
+            info.wrapModeU = GLTFTextureParser._wrapMap[wrapS];
         }
         if (wrapT) {
-            texture.wrapModeV = GLTFTextureParser._wrapMap[wrapT];
+            info.wrapModeV = GLTFTextureParser._wrapMap[wrapT];
+        }
+        return info;
+    };
+    _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;
@@ -2411,7 +2527,7 @@ var GLTFLoader = /*#__PURE__*/ function(Loader) {
             resourceManager.addContentRestorer(restorer);
             masterPromiseInfo.resolve(glTFResource);
         }).catch(function(e) {
-            var msg = "Error loading glTF model from " + url + " .";
+            var msg = "Error loading glTF model from " + url + " : " + e;
             miniprogram.Logger.error(msg);
             masterPromiseInfo.reject(msg);
             context.defaultSceneRootPromiseInfo.reject(e);
@@ -4373,7 +4489,7 @@ var AnimationClipLoader = /*#__PURE__*/ function(Loader) {
             _this.request(item.url, _extends({}, item, {
                 type: "arraybuffer"
             })).then(function(data) {
-                return decode(data, resourceManager.engine);
+                return decode(data, resourceManager.engine).then(resolve);
             }).catch(reject);
         });
     };
@@ -4512,7 +4628,7 @@ var KHR_draco_mesh_compression = (_KHR_draco_mesh_compression = /*#__PURE__*/ fu
     };
     _proto.createAndParse = function createAndParse(context, schema, glTFPrimitive, glTFMesh) {
         var _this = this;
-        var glTF = context.glTF, buffers = context.buffers, engine = context.glTFResource.engine;
+        var glTF = context.glTF, engine = context.glTFResource.engine;
         var bufferViews = glTF.bufferViews, accessors = glTF.accessors;
         var bufferViewIndex = schema.bufferView, gltfAttributeMap = schema.attributes;
         var attributeMap = {};
@@ -4534,21 +4650,23 @@ var KHR_draco_mesh_compression = (_KHR_draco_mesh_compression = /*#__PURE__*/ fu
             useUniqueIDs: true,
             indexType: indexType
         };
-        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 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);
+                    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) {
@@ -4647,7 +4765,7 @@ var KHR_draco_mesh_compression = (_KHR_draco_mesh_compression = /*#__PURE__*/ fu
             mesh.addSubMesh(0, vertexCount, mode);
         }
         // BlendShapes
-        targets && GLTFMeshParser._createBlendShape(mesh, null, gltfMesh, targets, getBlendShapeData);
+        targets && GLTFMeshParser._createBlendShape(mesh, null, gltfMesh, accessors, targets, getBlendShapeData);
         mesh.uploadData(!keepMeshData);
         return Promise.resolve(mesh);
     };