@galacean/engine 1.0.0-beta.16 → 1.0.0-beta.17

package/dist/browser.js

@@ -9628,6 +9628,7 @@
                 cloneEntity._hookResource = hookResource;
                 hookResource._addReferCount(1);
             }
+            cloneEntity.layer = this.layer;
             cloneEntity._isActive = this._isActive;
             cloneEntity.transform.localMatrix = this.transform.localMatrix;
             var children = this._children;
@@ -33731,7 +33732,8 @@
                                 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(Loader.getClass(script));
                                 });
                                 if (clipData) {
@@ -34297,6 +34299,11 @@
             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 AssetPromise(function(resolve, reject, setProgress, onCancel) {
                 promiseInfo.resolve = resolve;
@@ -34416,44 +34423,45 @@
             }
         };
         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 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));
+                    }
+                } 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);
-            }
-            return bufferInfo;
+                if (accessor.sparse) {
+                    GLTFUtils.processingSparseData(bufferViews, accessor, buffers, bufferInfo);
+                }
+                return bufferInfo;
+            });
         };
         /**
        * @deprecated
@@ -34912,9 +34920,7 @@
         _inherits(GLTFAnimationParser, 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;
@@ -34926,106 +34932,120 @@
             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 AnimationClip(name);
-                    GLTFAnimationParser._parseStandardProperty(context, animationClip, animationInfo);
+                    parseStandardPropertyPromises.push(GLTFAnimationParser._parseStandardProperty(context, animationClip, animationInfo));
                 }
                 animationClipPromises.push(animationClip);
             }
-            return 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 AssetPromise.all(parseStandardPropertyPromises).then(function() {
+                return 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 _loop(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 = exports.InterpolationType.CubicSpine;
+                            break;
+                        case AnimationSamplerInterpolation.Step:
+                            samplerInterpolation = exports.InterpolationType.Step;
+                            break;
+                        case AnimationSamplerInterpolation.Linear:
+                            samplerInterpolation = exports.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;
-                    }
-                    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 = exports.InterpolationType.CubicSpine;
-                        break;
-                    case AnimationSamplerInterpolation.Step:
-                        samplerInterpolation = exports.InterpolationType.Step;
-                        break;
-                    case AnimationSamplerInterpolation.Linear:
-                        samplerInterpolation = exports.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 = Transform;
-                        propertyName = "position";
-                        break;
-                    case AnimationChannelTargetPath.ROTATION:
-                        ComponentType = Transform;
-                        propertyName = "rotationQuaternion";
-                        break;
-                    case AnimationChannelTargetPath.SCALE:
-                        ComponentType = Transform;
-                        propertyName = "scale";
-                        break;
-                    case AnimationChannelTargetPath.WEIGHTS:
-                        ComponentType = SkinnedMeshRenderer;
-                        propertyName = "blendShapeWeights";
-                        break;
+            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;
+                    }
+                    var ComponentType = void 0;
+                    var propertyName = void 0;
+                    switch(target.path){
+                        case AnimationChannelTargetPath.TRANSLATION:
+                            ComponentType = Transform;
+                            propertyName = "position";
+                            break;
+                        case AnimationChannelTargetPath.ROTATION:
+                            ComponentType = Transform;
+                            propertyName = "rotationQuaternion";
+                            break;
+                        case AnimationChannelTargetPath.SCALE:
+                            ComponentType = Transform;
+                            propertyName = "scale";
+                            break;
+                        case AnimationChannelTargetPath.WEIGHTS:
+                            ComponentType = 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];
@@ -35119,20 +35139,18 @@
                 }).then(function(param) {
                     var glTF = param.glTF, buffers = param.buffers;
                     context.glTF = glTF;
-                    context.buffers = buffers;
+                    context._buffers = buffers;
                 });
             } else {
                 return 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 = Utils.resolveAbsoluteUrl(url, buffer.uri);
                         restoreBufferRequests.push(new BufferRequestInfo(absoluteUrl, requestConfig));
                         return request(absoluteUrl, requestConfig);
-                    })).then(function(buffers) {
-                        context.buffers = buffers;
-                    });
+                    }));
                 });
             }
         };
@@ -35377,7 +35395,9 @@
                                 }
                             }, 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);
                         }
                     });
@@ -35387,7 +35407,7 @@
                 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;
@@ -35402,8 +35422,109 @@
         /**
        * @internal
        */ GLTFMeshParser._parseMeshFromGLTFPrimitive = function _parseMeshFromGLTFPrimitive(context, mesh, meshRestoreInfo, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
+            var _loop = function _loop(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 VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
+                            var vertexBuffer = accessorBuffer.vertexBuffer;
+                            if (!vertexBuffer) {
+                                vertexBuffer = new Buffer(engine, exports.BufferBindFlag.VertexBuffer, vertices.byteLength, exports.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 VertexElement(attribute, elementOffset, elementFormat, vertexBindingInfos[meshId]);
+                        }
+                    } else {
+                        elementOffset = 0;
+                        vertexElement = new VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
+                        var vertexBuffer1 = new Buffer(engine, exports.BufferBindFlag.VertexBuffer, vertices.byteLength, exports.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 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);
+                                Vector3.min(min, position1, min);
+                                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 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 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();
@@ -35417,145 +35538,65 @@
                 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 VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
-                        var vertexBuffer = accessorBuffer.vertexBuffer;
-                        if (!vertexBuffer) {
-                            vertexBuffer = new Buffer(engine, exports.BufferBindFlag.VertexBuffer, vertices.byteLength, exports.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 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 VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
-                    var vertexBuffer1 = new Buffer(engine, exports.BufferBindFlag.VertexBuffer, vertices.byteLength, exports.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 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);
-                            Vector3.min(min, position1, min);
-                            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 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 Vector4(vertices[offset3], vertices[offset3 + 1], vertices[offset3 + 2], vertices[offset3 + 3]);
-                        elementNormalized && boneWeight.scale(scaleFactor);
-                        boneWeights[j3] = boneWeight;
-                    }
-                }
-            }
-            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);
+                    mesh.addSubMesh(0, vertexCount, mode);
+                }
+                // BlendShapes
+                if (targets) {
+                    promises.push(GLTFMeshParser._createBlendShape(mesh, meshRestoreInfo, gltfMesh, targets, getBlendShapeData));
+                }
+                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++){
+            var _loop = function _loop(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 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 deltaPosBufferInfo = infos[0];
+                    var deltaNorBufferInfo = infos[1];
+                    var deltaTanBufferInfo = infos[2];
+                    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 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));
+                });
+                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);
@@ -35705,52 +35746,58 @@
         _inherits(GLTFSkinParser, 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 _loop(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 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 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 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 AssetPromise.all(promises).then(function(skins) {
+                glTFResource.skins = skins;
+            });
         };
         _proto._findSkeletonRootBone = function _findSkeletonRootBone(joints, entities) {
             var paths = {};
@@ -35790,13 +35837,14 @@
         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;
                 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(".");
@@ -35804,31 +35852,36 @@
                         var type = ext.startsWith("ktx") ? exports.AssetType.KTX : exports.AssetType.Texture2D;
                         return engine.resourceManager.load({
                             url: 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 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 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) {
@@ -35838,22 +35891,39 @@
                 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 = exports.TextureFilterMode.Point;
-                } else if (minFilter <= TextureMinFilter.LINEAR_MIPMAP_NEAREST) {
-                    texture.filterMode = exports.TextureFilterMode.Bilinear;
+                    info.filterMode = exports.TextureFilterMode.Point;
                 } else {
-                    texture.filterMode = exports.TextureFilterMode.Trilinear;
+                    if (minFilter <= TextureMinFilter.LINEAR_MIPMAP_NEAREST) {
+                        info.filterMode = exports.TextureFilterMode.Bilinear;
+                    } else {
+                        info.filterMode = exports.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) {
+                texture.filterMode = filterMode;
+            }
+            if (wrapModeU) {
+                texture.wrapModeU = wrapModeU;
+            }
+            if (wrapModeV) {
+                texture.wrapModeV = wrapModeV;
             }
         };
         return GLTFTextureParser;
@@ -37907,7 +37977,7 @@
                 _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);
             });
         };
@@ -38044,7 +38114,7 @@
         };
         _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 = {};
@@ -38066,21 +38136,23 @@
                 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 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 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) {
@@ -38405,7 +38477,7 @@
     ], GALACEAN_animation_event);
 
     //@ts-ignore
-    var version = "1.0.0-beta.16";
+    var version = "1.0.0-beta.17";
     console.log("Galacean engine version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);