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

package/dist/browser.js

@@ -6483,6 +6483,11 @@
             subFont.nativeFontString = fontString;
             for(var i = 0, n = subTexts.length; i < n; i++){
                 var subText = subTexts[i];
+                // If subText is empty, push an empty line directly
+                if (subText.length === 0) {
+                    this._pushLine(lines, lineWidths, lineMaxSizes, "", 0, 0, 0);
+                    continue;
+                }
                 var word = "";
                 var wordWidth = 0;
                 var wordMaxAscent = 0;
@@ -6510,7 +6515,10 @@
                         // If it is a word before, need to handle the previous word and line
                         if (word.length > 0) {
                             if (lineWidth + wordWidth > wrapWidth) {
-                                this._pushLine(lines, lineWidths, lineMaxSizes, line, lineWidth, lineMaxAscent, lineMaxDescent);
+                                // Push if before line is not empty
+                                if (lineWidth > 0) {
+                                    this._pushLine(lines, lineWidths, lineMaxSizes, line, lineWidth, lineMaxAscent, lineMaxDescent);
+                                }
                                 textWidth = Math.max(textWidth, lineWidth);
                                 notFirstLine = true;
                                 line = word;
@@ -6555,7 +6563,10 @@
                                 line = "";
                                 lineWidth = lineMaxAscent = lineMaxDescent = 0;
                             }
-                            this._pushLine(lines, lineWidths, lineMaxSizes, word, wordWidth, wordMaxAscent, wordMaxDescent);
+                            // Push if before word is not empty
+                            if (wordWidth > 0) {
+                                this._pushLine(lines, lineWidths, lineMaxSizes, word, wordWidth, wordMaxAscent, wordMaxDescent);
+                            }
                             textWidth = Math.max(textWidth, wordWidth);
                             notFirstLine = true;
                             word = char;
@@ -6574,11 +6585,15 @@
                     // If the total width from line and word exceed wrap width
                     if (lineWidth + wordWidth > wrapWidth) {
                         // Push chars to a single line
-                        this._pushLine(lines, lineWidths, lineMaxSizes, line, lineWidth, lineMaxAscent, lineMaxDescent);
+                        if (lineWidth > 0) {
+                            this._pushLine(lines, lineWidths, lineMaxSizes, line, lineWidth, lineMaxAscent, lineMaxDescent);
+                        }
                         textWidth = Math.max(textWidth, lineWidth);
                         lineWidth = 0;
                         // Push word to a single line
-                        this._pushLine(lines, lineWidths, lineMaxSizes, word, wordWidth, wordMaxAscent, wordMaxDescent);
+                        if (wordWidth > 0) {
+                            this._pushLine(lines, lineWidths, lineMaxSizes, word, wordWidth, wordMaxAscent, wordMaxDescent);
+                        }
                         textWidth = Math.max(textWidth, wordWidth);
                     } else {
                         // Merge to chars
@@ -6610,23 +6625,20 @@
             var subFont = renderer._subFont;
             var fontString = subFont.nativeFontString;
             var fontSizeInfo = TextUtils.measureFont(fontString);
-            var lines = renderer.text.split(/(?:\r\n|\r|\n)/);
-            var lineCount = lines.length;
+            var subTexts = renderer.text.split(/(?:\r\n|\r|\n)/);
+            var textCount = subTexts.length;
+            var lines = new Array();
             var lineWidths = new Array();
             var lineMaxSizes = new Array();
             var _pixelsPerUnit = Engine._pixelsPerUnit;
             var lineHeight = fontSizeInfo.size + renderer.lineSpacing * _pixelsPerUnit;
             var width = 0;
-            var height = renderer.height * _pixelsPerUnit;
-            if (renderer.overflowMode === exports.OverflowMode.Overflow) {
-                height = lineHeight * lineCount;
-            }
             subFont.nativeFontString = fontString;
-            for(var i = 0; i < lineCount; ++i){
-                var line = lines[i];
+            for(var i = 0; i < textCount; ++i){
+                var line = subTexts[i];
                 var curWidth = 0;
-                var maxAscent = -1;
-                var maxDescent = -1;
+                var maxAscent = 0;
+                var maxDescent = 0;
                 for(var j = 0, m = line.length; j < m; ++j){
                     var charInfo = TextUtils._getCharInfo(line[j], fontString, subFont);
                     curWidth += charInfo.xAdvance;
@@ -6637,16 +6649,15 @@
                     maxAscent < ascent && (maxAscent = ascent);
                     maxDescent < descent && (maxDescent = descent);
                 }
-                lineWidths[i] = curWidth;
-                lineMaxSizes[i] = {
-                    ascent: maxAscent,
-                    descent: maxDescent,
-                    size: maxAscent + maxDescent
-                };
-                if (curWidth > width) {
-                    width = curWidth;
+                if (curWidth > 0) {
+                    this._pushLine(lines, lineWidths, lineMaxSizes, line, curWidth, maxAscent, maxDescent);
+                    width = Math.max(width, curWidth);
                 }
             }
+            var height = renderer.height * _pixelsPerUnit;
+            if (renderer.overflowMode === exports.OverflowMode.Overflow) {
+                height = lineHeight * lines.length;
+            }
             return {
                 width: width,
                 height: height,
@@ -7492,7 +7503,6 @@
         var EventDispatcher = function EventDispatcher() {
             this._events = Object.create(null);
             this._eventCount = 0;
-            this._dispatchingListeners = [];
         };
         var _proto = EventDispatcher.prototype;
         /**
@@ -7532,7 +7542,8 @@
             if (Array.isArray(listeners)) {
                 var count = listeners.length;
                 // cloning list to avoid structure breaking
-                var dispatchingListeners = this._dispatchingListeners;
+                var pool = EventDispatcher._dispatchingListenersPool;
+                var dispatchingListeners = pool.length > 0 ? pool.pop() : [];
                 dispatchingListeners.length = count;
                 for(var i = 0; i < count; i++){
                     dispatchingListeners[i] = listeners[i];
@@ -7546,6 +7557,7 @@
                 }
                 // remove hooked function to avoid gc problem
                 dispatchingListeners.length = 0;
+                pool.push(dispatchingListeners);
             } else {
                 if (listeners.once) this.off(event, listeners.fn);
                 listeners.fn(data);
@@ -7646,6 +7658,9 @@
         };
         return EventDispatcher;
     }();
+    (function() {
+        EventDispatcher._dispatchingListenersPool = [];
+    })();
     /**
      * Shader property.
      */ var ShaderProperty = /*#__PURE__*/ function() {
@@ -9628,6 +9643,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;
@@ -18428,6 +18444,15 @@
         };
         /**
        * @internal
+       */ _proto._prepareRender = function _prepareRender(context) {
+            if (!this._mesh) {
+                Logger.error("mesh is null.");
+                return;
+            }
+            Renderer.prototype._prepareRender.call(this, context);
+        };
+        /**
+       * @internal
        */ _proto._cloneTo = function _cloneTo(target) {
             Renderer.prototype._cloneTo.call(this, target);
             target.mesh = this._mesh;
@@ -18449,49 +18474,45 @@
        * @internal
        */ _proto._render = function _render(context) {
             var mesh = this._mesh;
-            if (mesh) {
-                if (this._dirtyUpdateFlag & 0x2) {
-                    var shaderData = this.shaderData;
-                    var vertexElements = mesh._vertexElements;
-                    shaderData.disableMacro(MeshRenderer._uvMacro);
-                    shaderData.disableMacro(MeshRenderer._uv1Macro);
-                    shaderData.disableMacro(MeshRenderer._normalMacro);
-                    shaderData.disableMacro(MeshRenderer._tangentMacro);
-                    shaderData.disableMacro(MeshRenderer._enableVertexColorMacro);
-                    for(var i = 0, n = vertexElements.length; i < n; i++){
-                        switch(vertexElements[i].semantic){
-                            case "TEXCOORD_0":
-                                shaderData.enableMacro(MeshRenderer._uvMacro);
-                                break;
-                            case "TEXCOORD_1":
-                                shaderData.enableMacro(MeshRenderer._uv1Macro);
-                                break;
-                            case "NORMAL":
-                                shaderData.enableMacro(MeshRenderer._normalMacro);
-                                break;
-                            case "TANGENT":
-                                shaderData.enableMacro(MeshRenderer._tangentMacro);
-                                break;
-                            case "COLOR_0":
-                                this._enableVertexColor && shaderData.enableMacro(MeshRenderer._enableVertexColorMacro);
-                                break;
-                        }
+            if (this._dirtyUpdateFlag & 0x2) {
+                var shaderData = this.shaderData;
+                var vertexElements = mesh._vertexElements;
+                shaderData.disableMacro(MeshRenderer._uvMacro);
+                shaderData.disableMacro(MeshRenderer._uv1Macro);
+                shaderData.disableMacro(MeshRenderer._normalMacro);
+                shaderData.disableMacro(MeshRenderer._tangentMacro);
+                shaderData.disableMacro(MeshRenderer._enableVertexColorMacro);
+                for(var i = 0, n = vertexElements.length; i < n; i++){
+                    switch(vertexElements[i].semantic){
+                        case "TEXCOORD_0":
+                            shaderData.enableMacro(MeshRenderer._uvMacro);
+                            break;
+                        case "TEXCOORD_1":
+                            shaderData.enableMacro(MeshRenderer._uv1Macro);
+                            break;
+                        case "NORMAL":
+                            shaderData.enableMacro(MeshRenderer._normalMacro);
+                            break;
+                        case "TANGENT":
+                            shaderData.enableMacro(MeshRenderer._tangentMacro);
+                            break;
+                        case "COLOR_0":
+                            this._enableVertexColor && shaderData.enableMacro(MeshRenderer._enableVertexColorMacro);
+                            break;
                     }
-                    this._dirtyUpdateFlag &= ~0x2;
                 }
-                var materials = this._materials;
-                var subMeshes = mesh.subMeshes;
-                var renderPipeline = context.camera._renderPipeline;
-                var meshRenderDataPool = this._engine._meshRenderDataPool;
-                for(var i1 = 0, n1 = subMeshes.length; i1 < n1; i1++){
-                    var material = materials[i1];
-                    if (!material) continue;
-                    var renderData = meshRenderDataPool.getFromPool();
-                    renderData.set(this, material, mesh, subMeshes[i1]);
-                    renderPipeline.pushRenderData(context, renderData);
-                }
-            } else {
-                Logger.error("mesh is null.");
+                this._dirtyUpdateFlag &= ~0x2;
+            }
+            var materials = this._materials;
+            var subMeshes = mesh.subMeshes;
+            var renderPipeline = context.camera._renderPipeline;
+            var meshRenderDataPool = this._engine._meshRenderDataPool;
+            for(var i1 = 0, n1 = subMeshes.length; i1 < n1; i1++){
+                var material = materials[i1];
+                if (!material) continue;
+                var renderData = meshRenderDataPool.getFromPool();
+                renderData.set(this, material, mesh, subMeshes[i1]);
+                renderPipeline.pushRenderData(context, renderData);
             }
         };
         _proto._setMesh = function _setMesh(mesh) {
@@ -24188,18 +24209,10 @@
             var _config_type;
             config.type = (_config_type = config.type) != null ? _config_type : getMimeTypeFromUrl(url);
             var realRequest = config.type === "image" ? requestImage : requestRes;
-            var lastError;
             var executor = new MultiExecutor(function() {
-                return realRequest(url, config).onProgress(setProgress).then(function(res) {
-                    resolve(res);
-                    executor.stop();
-                }).catch(function(err) {
-                    return lastError = err;
-                });
+                return realRequest(url, config).onProgress(setProgress);
             }, retryCount, retryInterval);
-            executor.start(function() {
-                reject(lastError);
-            });
+            executor.start().onError(reject).onComplete(resolve);
         });
     }
     function requestImage(url, config) {
@@ -24286,23 +24299,33 @@
             this.exec = this.exec.bind(this);
         };
         var _proto = MultiExecutor.prototype;
-        _proto.start = function start(done) {
-            this.done = done;
+        _proto.start = function start() {
             this.exec();
+            return this;
         };
-        _proto.stop = function stop() {
-            clearTimeout(this._timeoutId);
+        _proto.onComplete = function onComplete(func) {
+            this._onComplete = func;
+            return this;
+        };
+        _proto.onError = function onError(func) {
+            this._onError = func;
+            return this;
+        };
+        _proto.cancel = function cancel() {
+            window.clearTimeout(this._timeoutId);
         };
         _proto.exec = function exec() {
             var _this = this;
             if (this._currentCount >= this.totalCount) {
-                this.done && this.done();
+                this._onError && this._onError(this._error);
                 return;
             }
             this._currentCount++;
-            this.execFunc(this._currentCount).then(function() {
-                //@ts-ignore
-                _this._timeoutId = setTimeout(_this.exec, _this.interval);
+            this.execFunc(this._currentCount).then(function(result) {
+                return _this._onComplete && _this._onComplete(result);
+            }).catch(function(e) {
+                _this._error = e;
+                _this._timeoutId = window.setTimeout(_this.exec, _this.interval);
             });
         };
         return MultiExecutor;
@@ -26913,92 +26936,97 @@
             }
         };
         _proto._updateLocalData = function _updateLocalData() {
-            var _this = this, color = _this.color, horizontalAlignment = _this.horizontalAlignment, verticalAlignment = _this.verticalAlignment, charRenderDatas = _this._charRenderDatas;
+            var _this = this, color = _this.color, charRenderDatas = _this._charRenderDatas, charFont = _this._subFont;
             var _this__localBounds = this._localBounds, min = _this__localBounds.min, max = _this__localBounds.max;
-            var _pixelsPerUnit = Engine._pixelsPerUnit;
-            var pixelsPerUnitReciprocal = 1.0 / _pixelsPerUnit;
-            var charFont = this._subFont;
-            var rendererWidth = this.width * _pixelsPerUnit;
-            var halfRendererWidth = rendererWidth * 0.5;
-            var rendererHeight = this.height * _pixelsPerUnit;
             var textMetrics = this.enableWrapping ? TextUtils.measureTextWithWrap(this) : TextUtils.measureTextWithoutWrap(this);
             var height = textMetrics.height, lines = textMetrics.lines, lineWidths = textMetrics.lineWidths, lineHeight = textMetrics.lineHeight, lineMaxSizes = textMetrics.lineMaxSizes;
             var charRenderDataPool = TextRenderer._charRenderDataPool;
-            var halfLineHeight = lineHeight * 0.5;
             var linesLen = lines.length;
-            var startY = 0;
-            var topDiff = lineHeight * 0.5 - lineMaxSizes[0].ascent;
-            var bottomDiff = lineHeight * 0.5 - lineMaxSizes[linesLen - 1].descent - 1;
-            switch(verticalAlignment){
-                case exports.TextVerticalAlignment.Top:
-                    startY = rendererHeight * 0.5 - halfLineHeight + topDiff;
-                    break;
-                case exports.TextVerticalAlignment.Center:
-                    startY = height * 0.5 - halfLineHeight - (bottomDiff - topDiff) * 0.5;
-                    break;
-                case exports.TextVerticalAlignment.Bottom:
-                    startY = height - rendererHeight * 0.5 - halfLineHeight - bottomDiff;
-                    break;
-            }
             var renderDataCount = 0;
-            var firstLine = -1;
-            var minX = Number.MAX_SAFE_INTEGER;
-            var minY = Number.MAX_SAFE_INTEGER;
-            var maxX = Number.MIN_SAFE_INTEGER;
-            var maxY = Number.MIN_SAFE_INTEGER;
-            for(var i = 0; i < linesLen; ++i){
-                var lineWidth = lineWidths[i];
-                if (lineWidth > 0) {
-                    var line = lines[i];
-                    var startX = 0;
-                    var firstRow = -1;
-                    if (firstLine < 0) {
-                        firstLine = i;
-                    }
-                    switch(horizontalAlignment){
-                        case exports.TextHorizontalAlignment.Left:
-                            startX = -halfRendererWidth;
-                            break;
-                        case exports.TextHorizontalAlignment.Center:
-                            startX = -lineWidth * 0.5;
-                            break;
-                        case exports.TextHorizontalAlignment.Right:
-                            startX = halfRendererWidth - lineWidth;
-                            break;
-                    }
-                    for(var j = 0, n = line.length; j < n; ++j){
-                        var char = line[j];
-                        var charInfo = charFont._getCharInfo(char);
-                        if (charInfo.h > 0) {
-                            var _charRenderDatas, _ref;
-                            firstRow < 0 && (firstRow = j);
-                            var charRenderData = (_charRenderDatas = charRenderDatas)[_ref = renderDataCount++] || (_charRenderDatas[_ref] = charRenderDataPool.get());
-                            var renderData = charRenderData.renderData, localPositions = charRenderData.localPositions;
-                            charRenderData.texture = charFont._getTextureByIndex(charInfo.index);
-                            renderData.color = color;
-                            renderData.uvs = charInfo.uvs;
-                            var w = charInfo.w, ascent = charInfo.ascent, descent = charInfo.descent;
-                            var left = startX * pixelsPerUnitReciprocal;
-                            var right = (startX + w) * pixelsPerUnitReciprocal;
-                            var top = (startY + ascent) * pixelsPerUnitReciprocal;
-                            var bottom = (startY - descent + 1) * pixelsPerUnitReciprocal;
-                            localPositions.set(left, top, right, bottom);
-                            i === firstLine && (maxY = Math.max(maxY, top));
-                            minY = Math.min(minY, bottom);
-                            j === firstRow && (minX = Math.min(minX, left));
-                            maxX = Math.max(maxX, right);
+            if (linesLen > 0) {
+                var _pixelsPerUnit = Engine._pixelsPerUnit;
+                var horizontalAlignment = this.horizontalAlignment;
+                var pixelsPerUnitReciprocal = 1.0 / _pixelsPerUnit;
+                var rendererWidth = this.width * _pixelsPerUnit;
+                var halfRendererWidth = rendererWidth * 0.5;
+                var rendererHeight = this.height * _pixelsPerUnit;
+                var halfLineHeight = lineHeight * 0.5;
+                var startY = 0;
+                var topDiff = lineHeight * 0.5 - lineMaxSizes[0].ascent;
+                var bottomDiff = lineHeight * 0.5 - lineMaxSizes[linesLen - 1].descent - 1;
+                switch(this.verticalAlignment){
+                    case exports.TextVerticalAlignment.Top:
+                        startY = rendererHeight * 0.5 - halfLineHeight + topDiff;
+                        break;
+                    case exports.TextVerticalAlignment.Center:
+                        startY = height * 0.5 - halfLineHeight - (bottomDiff - topDiff) * 0.5;
+                        break;
+                    case exports.TextVerticalAlignment.Bottom:
+                        startY = height - rendererHeight * 0.5 - halfLineHeight - bottomDiff;
+                        break;
+                }
+                var firstLine = -1;
+                var minX = Number.MAX_SAFE_INTEGER;
+                var minY = Number.MAX_SAFE_INTEGER;
+                var maxX = Number.MIN_SAFE_INTEGER;
+                var maxY = Number.MIN_SAFE_INTEGER;
+                for(var i = 0; i < linesLen; ++i){
+                    var lineWidth = lineWidths[i];
+                    if (lineWidth > 0) {
+                        var line = lines[i];
+                        var startX = 0;
+                        var firstRow = -1;
+                        if (firstLine < 0) {
+                            firstLine = i;
+                        }
+                        switch(horizontalAlignment){
+                            case exports.TextHorizontalAlignment.Left:
+                                startX = -halfRendererWidth;
+                                break;
+                            case exports.TextHorizontalAlignment.Center:
+                                startX = -lineWidth * 0.5;
+                                break;
+                            case exports.TextHorizontalAlignment.Right:
+                                startX = halfRendererWidth - lineWidth;
+                                break;
+                        }
+                        for(var j = 0, n = line.length; j < n; ++j){
+                            var char = line[j];
+                            var charInfo = charFont._getCharInfo(char);
+                            if (charInfo.h > 0) {
+                                var _charRenderDatas, _ref;
+                                firstRow < 0 && (firstRow = j);
+                                var charRenderData = (_charRenderDatas = charRenderDatas)[_ref = renderDataCount++] || (_charRenderDatas[_ref] = charRenderDataPool.get());
+                                var renderData = charRenderData.renderData, localPositions = charRenderData.localPositions;
+                                charRenderData.texture = charFont._getTextureByIndex(charInfo.index);
+                                renderData.color = color;
+                                renderData.uvs = charInfo.uvs;
+                                var w = charInfo.w, ascent = charInfo.ascent, descent = charInfo.descent;
+                                var left = startX * pixelsPerUnitReciprocal;
+                                var right = (startX + w) * pixelsPerUnitReciprocal;
+                                var top = (startY + ascent) * pixelsPerUnitReciprocal;
+                                var bottom = (startY - descent + 1) * pixelsPerUnitReciprocal;
+                                localPositions.set(left, top, right, bottom);
+                                i === firstLine && (maxY = Math.max(maxY, top));
+                                minY = Math.min(minY, bottom);
+                                j === firstRow && (minX = Math.min(minX, left));
+                                maxX = Math.max(maxX, right);
+                            }
+                            startX += charInfo.xAdvance;
                         }
-                        startX += charInfo.xAdvance;
                     }
+                    startY -= lineHeight;
                 }
-                startY -= lineHeight;
-            }
-            if (firstLine < 0) {
+                if (firstLine < 0) {
+                    min.set(0, 0, 0);
+                    max.set(0, 0, 0);
+                } else {
+                    min.set(minX, minY, 0);
+                    max.set(maxX, maxY, 0);
+                }
+            } else {
                 min.set(0, 0, 0);
                 max.set(0, 0, 0);
-            } else {
-                min.set(minX, minY, 0);
-                max.set(maxX, maxY, 0);
             }
             // Revert excess render data to pool.
             var lastRenderDataCount = charRenderDatas.length;
@@ -28981,7 +29009,8 @@
         };
         _proto._saveAnimatorEventHandlers = function _saveAnimatorEventHandlers(state, animatorStateData) {
             var eventHandlerPool = this._animationEventHandlerPool;
-            var scripts = this._entity._scripts;
+            var scripts = [];
+            this._entity.getComponents(Script, scripts);
             var scriptCount = scripts.length;
             var eventHandlers = animatorStateData.eventHandlers;
             var events = state.clip.events;
@@ -28994,7 +29023,7 @@
                 eventHandler.event = event;
                 handlers.length = 0;
                 for(var j = scriptCount - 1; j >= 0; j--){
-                    var handler = scripts.get(j)[funcName];
+                    var handler = scripts[j][funcName];
                     handler && handlers.push(handler);
                 }
                 eventHandlers.push(eventHandler);
@@ -33731,7 +33760,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) {
@@ -34036,15 +34066,18 @@
                             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);
@@ -34128,6 +34161,14 @@
         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
      */ var AccessorComponentType;
@@ -34297,6 +34338,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 +34462,58 @@
             }
         };
         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 Vector3(data[index], data[index + 1], data[index + 2]);
             }
-            return bufferInfo;
+            return vector3s;
         };
         /**
        * @deprecated
@@ -34912,9 +34972,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 +34984,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 +35191,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 +35447,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 +35459,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 +35474,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 +35590,85 @@
                 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, accessors, 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++){
+       */ GLTFMeshParser._createBlendShape = function _createBlendShape(mesh, meshRestoreInfo, glTFMesh, accessors, glTFTargets, getBlendShapeData) {
+            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 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 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);
@@ -35705,52 +35818,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 +35909,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 +35924,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 +35963,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 !== undefined) {
+                texture.filterMode = filterMode;
+            }
+            if (wrapModeU !== undefined) {
+                texture.wrapModeU = wrapModeU;
+            }
+            if (wrapModeV !== undefined) {
+                texture.wrapModeV = wrapModeV;
             }
         };
         return GLTFTextureParser;
@@ -35986,7 +36128,7 @@
                 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;
                 Logger.error(msg);
                 masterPromiseInfo.reject(msg);
                 context.defaultSceneRootPromiseInfo.reject(e);
@@ -37907,7 +38049,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 +38186,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 +38208,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) {
@@ -38179,7 +38323,7 @@
                 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);
         };
@@ -38405,7 +38549,7 @@
     ], GALACEAN_animation_event);
 
     //@ts-ignore
-    var version = "1.0.0-beta.16";
+    var version = "1.0.0-beta.18";
     console.log("Galacean engine version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);