@galacean/engine-loader 1.0.0-beta.9 → 1.0.1

package/dist/main.js

@@ -121,7 +121,8 @@ var AnimatorControllerLoader = /*#__PURE__*/ function(Loader1) {
                             state.wrapMode = wrapMode;
                             state.clipStartTime = clipStartNormalizedTime;
                             state.clipEndTime = clipEndNormalizedTime;
-                            scripts == null ? void 0 : scripts.forEach(function(script) {
+                            var scriptsObject = JSON.parse(scripts);
+                            scriptsObject == null ? void 0 : scriptsObject.forEach(function(script) {
                                 state.addStateMachineScript(engineCore.Loader.getClass(script));
                             });
                             if (clipData) {
@@ -221,7 +222,8 @@ var EnvLoader = /*#__PURE__*/ function(Loader) {
                 var shArray = new Float32Array(arraybuffer, 0, 27);
                 var shByteLength = 27 * 4;
                 var size = (_ref = new Uint16Array(arraybuffer, shByteLength, 1)) == null ? void 0 : _ref[0];
-                var texture = new engineCore.TextureCube(resourceManager.engine, size);
+                var engine = resourceManager.engine;
+                var texture = new engineCore.TextureCube(engine, size);
                 texture.filterMode = engineCore.TextureFilterMode.Trilinear;
                 var mipmapCount = texture.mipmapCount;
                 var offset = shByteLength + 2;
@@ -234,7 +236,7 @@ var EnvLoader = /*#__PURE__*/ function(Loader) {
                         texture.setPixelBuffer(engineCore.TextureCubeFace.PositiveX + face, data, mipLevel);
                     }
                 }
-                var ambientLight = new engineCore.AmbientLight();
+                var ambientLight = new engineCore.AmbientLight(engine);
                 var sh = new engineMath.SphericalHarmonics3();
                 ambientLight.diffuseMode = engineCore.DiffuseMode.SphericalHarmonics;
                 sh.copyFromArray(shArray);
@@ -441,15 +443,18 @@ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
                         for(var _iterator2 = _create_for_of_iterator_helper_loose(meshInfo.blendShapes), _step2; !(_step2 = _iterator2()).done;){
                             var restoreInfo = _step2.value;
                             var frame = restoreInfo.blendShape.frames[0];
-                            var positionData = _this._getBufferData(buffers, restoreInfo.position);
-                            frame.deltaPositions = GLTFUtils.floatBufferToVector3Array(positionData);
+                            var position = restoreInfo.position;
+                            var positionData = _this._getBufferData(buffers, position.buffer);
+                            frame.deltaPositions = GLTFUtils.bufferToVector3Array(positionData, position.stride, position.byteOffset, position.count);
                             if (restoreInfo.normal) {
-                                var normalData = _this._getBufferData(buffers, restoreInfo.normal);
-                                frame.deltaNormals = GLTFUtils.floatBufferToVector3Array(normalData);
+                                var normal = restoreInfo.normal;
+                                var normalData = _this._getBufferData(buffers, normal.buffer);
+                                frame.deltaNormals = GLTFUtils.bufferToVector3Array(normalData, normal.stride, normal.byteOffset, normal.count);
                             }
                             if (restoreInfo.tangent) {
-                                var tangentData = _this._getBufferData(buffers, restoreInfo.tangent);
-                                frame.deltaTangents = GLTFUtils.floatBufferToVector3Array(tangentData);
+                                var tangent = restoreInfo.tangent;
+                                var tangentData = _this._getBufferData(buffers, tangent.buffer);
+                                frame.deltaTangents = GLTFUtils.bufferToVector3Array(tangentData, tangent.stride, tangent.byteOffset, tangent.count);
                             }
                         }
                         mesh.uploadData(true);
@@ -533,6 +538,14 @@ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
     this.normal = normal;
     this.tangent = tangent;
 };
+/**
+ * @internal
+ */ var BlendShapeDataRestoreInfo = function BlendShapeDataRestoreInfo(buffer, stride, byteOffset, count) {
+    this.buffer = buffer;
+    this.stride = stride;
+    this.byteOffset = byteOffset;
+    this.count = count;
+};
 
 /**
  * Module for glTF 2.0 Interface
@@ -704,6 +717,11 @@ var TextureWrapMode;
         promiseMap["" + url] = this._initPromiseInfo(this.masterPromiseInfo);
     }
     var _proto = GLTFParserContext.prototype;
+    /**
+   * Get all the buffer data.
+   */ _proto.getBuffers = function getBuffers() {
+        return Promise.resolve(this._buffers);
+    };
     _proto._initPromiseInfo = function _initPromiseInfo(promiseInfo) {
         var promise = new engineCore.AssetPromise(function(resolve, reject, setProgress, onCancel) {
             promiseInfo.resolve = resolve;
@@ -825,44 +843,58 @@ var TextureWrapMode;
         }
     };
     GLTFUtils.getAccessorBuffer = function getAccessorBuffer(context, bufferViews, accessor) {
-        var buffers = context.buffers;
         var componentType = accessor.componentType;
         var bufferView = bufferViews[accessor.bufferView];
-        var bufferIndex = bufferView.buffer;
-        var buffer = buffers[bufferIndex];
-        var bufferByteOffset = bufferView.byteOffset || 0;
-        var byteOffset = accessor.byteOffset || 0;
-        var TypedArray = GLTFUtils.getComponentType(componentType);
-        var dataElementSize = GLTFUtils.getAccessorTypeSize(accessor.type);
-        var dataElementBytes = TypedArray.BYTES_PER_ELEMENT;
-        var elementStride = dataElementSize * dataElementBytes;
-        var accessorCount = accessor.count;
-        var bufferStride = bufferView.byteStride;
-        var bufferInfo;
-        // According to the glTF official documentation only byteStride not undefined is allowed
-        if (bufferStride !== undefined && bufferStride !== elementStride) {
-            var bufferSlice = Math.floor(byteOffset / bufferStride);
-            var bufferCacheKey = accessor.bufferView + ":" + componentType + ":" + bufferSlice + ":" + accessorCount;
-            var accessorBufferCache = context.accessorBufferCache;
-            bufferInfo = accessorBufferCache[bufferCacheKey];
-            if (!bufferInfo) {
-                var offset = bufferByteOffset + bufferSlice * bufferStride;
-                var count = accessorCount * (bufferStride / dataElementBytes);
-                var data = new TypedArray(buffer, offset, count);
-                accessorBufferCache[bufferCacheKey] = bufferInfo = new BufferInfo(data, true, bufferStride);
-                bufferInfo.restoreInfo = new BufferDataRestoreInfo(new RestoreDataAccessor(bufferIndex, TypedArray, offset, count));
+        return context.getBuffers().then(function(buffers) {
+            var bufferIndex = bufferView.buffer;
+            var buffer = buffers[bufferIndex];
+            var _bufferView_byteOffset;
+            var bufferByteOffset = (_bufferView_byteOffset = bufferView.byteOffset) != null ? _bufferView_byteOffset : 0;
+            var _accessor_byteOffset;
+            var byteOffset = (_accessor_byteOffset = accessor.byteOffset) != null ? _accessor_byteOffset : 0;
+            var TypedArray = GLTFUtils.getComponentType(componentType);
+            var dataElementSize = GLTFUtils.getAccessorTypeSize(accessor.type);
+            var dataElementBytes = TypedArray.BYTES_PER_ELEMENT;
+            var elementStride = dataElementSize * dataElementBytes;
+            var accessorCount = accessor.count;
+            var bufferStride = bufferView.byteStride;
+            var bufferInfo;
+            // According to the glTF official documentation only byteStride not undefined is allowed
+            if (bufferStride !== undefined && bufferStride !== elementStride) {
+                var bufferSlice = Math.floor(byteOffset / bufferStride);
+                var bufferCacheKey = accessor.bufferView + ":" + componentType + ":" + bufferSlice + ":" + accessorCount;
+                var accessorBufferCache = context.accessorBufferCache;
+                bufferInfo = accessorBufferCache[bufferCacheKey];
+                if (!bufferInfo) {
+                    var offset = bufferByteOffset + bufferSlice * bufferStride;
+                    var count = accessorCount * (bufferStride / dataElementBytes);
+                    var data = new TypedArray(buffer, offset, count);
+                    accessorBufferCache[bufferCacheKey] = bufferInfo = new BufferInfo(data, true, bufferStride);
+                    bufferInfo.restoreInfo = new BufferDataRestoreInfo(new RestoreDataAccessor(bufferIndex, TypedArray, offset, count));
+                }
+            } else {
+                var offset1 = bufferByteOffset + byteOffset;
+                var count1 = accessorCount * dataElementSize;
+                var data1 = new TypedArray(buffer, offset1, count1);
+                bufferInfo = new BufferInfo(data1, false, elementStride);
+                bufferInfo.restoreInfo = new BufferDataRestoreInfo(new RestoreDataAccessor(bufferIndex, TypedArray, offset1, count1));
             }
-        } else {
-            var offset1 = bufferByteOffset + byteOffset;
-            var count1 = accessorCount * dataElementSize;
-            var data1 = new TypedArray(buffer, offset1, count1);
-            bufferInfo = new BufferInfo(data1, false, elementStride);
-            bufferInfo.restoreInfo = new BufferDataRestoreInfo(new RestoreDataAccessor(bufferIndex, TypedArray, offset1, count1));
-        }
-        if (accessor.sparse) {
-            GLTFUtils.processingSparseData(bufferViews, accessor, buffers, bufferInfo);
+            if (accessor.sparse) {
+                GLTFUtils.processingSparseData(bufferViews, accessor, buffers, bufferInfo);
+            }
+            return bufferInfo;
+        });
+    };
+    GLTFUtils.bufferToVector3Array = function bufferToVector3Array(data, byteStride, accessorByteOffset, count) {
+        var bytesPerElement = data.BYTES_PER_ELEMENT;
+        var offset = accessorByteOffset % byteStride / bytesPerElement;
+        var stride = byteStride / bytesPerElement;
+        var vector3s = new Array(count);
+        for(var i = 0; i < count; i++){
+            var index = offset + i * stride;
+            vector3s[i] = new engineMath.Vector3(data[index], data[index + 1], data[index + 2]);
         }
-        return bufferInfo;
+        return vector3s;
     };
     /**
    * @deprecated
@@ -1328,7 +1360,7 @@ var GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
     }
     var _proto = GLTFAnimationParser.prototype;
     _proto.parse = function parse(context) {
-        var glTF = context.glTF; context.buffers; var glTFResource = context.glTFResource;
+        var glTF = context.glTF, glTFResource = context.glTFResource;
         glTFResource.entities;
         var animations = glTF.animations; glTF.accessors; glTF.bufferViews;
         if (!animations) {
@@ -1338,106 +1370,120 @@ var GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
         var animationClipCount = animations.length;
         var animationClipPromises = [];
         new Array(animationClipCount);
+        var parseStandardPropertyPromises = new Array();
         for(var i = 0; i < animationClipCount; i++){
             var animationInfo = animations[i];
             var _animationInfo_name = animationInfo.name, name = _animationInfo_name === void 0 ? "AnimationClip" + i : _animationInfo_name;
             var animationClip = GLTFParser.executeExtensionsCreateAndParse(animationInfo.extensions, context, animationInfo);
             if (!animationClip) {
                 animationClip = new engineCore.AnimationClip(name);
-                GLTFAnimationParser._parseStandardProperty(context, animationClip, animationInfo);
+                parseStandardPropertyPromises.push(GLTFAnimationParser._parseStandardProperty(context, animationClip, animationInfo));
             }
             animationClipPromises.push(animationClip);
         }
-        return engineCore.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 engineCore.AssetPromise.all(parseStandardPropertyPromises).then(function() {
+            return engineCore.AssetPromise.all(animationClipPromises).then(function(animationClips) {
+                glTFResource.animations = animationClips;
+                for(var i = 0; i < glTF.animations.length; i++){
+                    var animationInfo = glTF.animations[i];
+                    GLTFParser.executeExtensionsAdditiveAndParse(animationInfo.extensions, context, animationClips[i], animationInfo);
+                }
+                animationClipsPromiseInfo.resolve(animationClips);
+                return animationClipsPromiseInfo.promise;
+            });
         });
     };
     /**
    * @internal
    */ GLTFAnimationParser._parseStandardProperty = function _parseStandardProperty(context, animationClip, animationInfo) {
+        var _loop = function(j, m) {
+            var gltfSampler = samplers[j];
+            var inputAccessor = accessors[gltfSampler.input];
+            var outputAccessor = accessors[gltfSampler.output];
+            var promise = Promise.all([
+                GLTFUtils.getAccessorBuffer(context, bufferViews, inputAccessor),
+                GLTFUtils.getAccessorBuffer(context, bufferViews, outputAccessor)
+            ]).then(function(bufferInfos) {
+                var input = bufferInfos[0].data;
+                var output = bufferInfos[1].data;
+                if (outputAccessor.normalized) {
+                    var scale = GLTFUtils.getNormalizedComponentScale(outputAccessor.componentType);
+                    var scaled = new Float32Array(output.length);
+                    for(var k = 0, v = output.length; k < v; k++){
+                        scaled[k] = output[k] * scale;
+                    }
+                    output = scaled;
+                }
+                var outputStride = output.length / input.length;
+                var _gltfSampler_interpolation;
+                var interpolation = (_gltfSampler_interpolation = gltfSampler.interpolation) != null ? _gltfSampler_interpolation : AnimationSamplerInterpolation.Linear;
+                var samplerInterpolation;
+                switch(interpolation){
+                    case AnimationSamplerInterpolation.CubicSpine:
+                        samplerInterpolation = engineCore.InterpolationType.CubicSpine;
+                        break;
+                    case AnimationSamplerInterpolation.Step:
+                        samplerInterpolation = engineCore.InterpolationType.Step;
+                        break;
+                    case AnimationSamplerInterpolation.Linear:
+                        samplerInterpolation = engineCore.InterpolationType.Linear;
+                        break;
+                }
+                input[input.length - 1];
+                sampleDataCollection.push({
+                    type: outputAccessor.type,
+                    interpolation: samplerInterpolation,
+                    input: input,
+                    output: output,
+                    outputSize: outputStride
+                });
+            });
+            promises.push(promise);
+        };
+        var _this = this;
         var glTF = context.glTF, glTFResource = context.glTFResource;
         var entities = glTFResource.entities;
         var accessors = glTF.accessors, bufferViews = glTF.bufferViews;
         var channels = animationInfo.channels, samplers = animationInfo.samplers;
         var sampleDataCollection = new Array();
+        var promises = new Array();
         // parse samplers
-        for(var j = 0, m = samplers.length; j < m; j++){
-            var gltfSampler = samplers[j];
-            var inputAccessor = accessors[gltfSampler.input];
-            var outputAccessor = accessors[gltfSampler.output];
-            var input = GLTFUtils.getAccessorBuffer(context, bufferViews, inputAccessor).data;
-            var output = GLTFUtils.getAccessorBuffer(context, bufferViews, outputAccessor).data;
-            if (outputAccessor.normalized) {
-                var scale = GLTFUtils.getNormalizedComponentScale(outputAccessor.componentType);
-                var scaled = new Float32Array(output.length);
-                for(var k = 0, v = output.length; k < v; k++){
-                    scaled[k] = output[k] * scale;
+        for(var j = 0, m = samplers.length; j < m; j++)_loop(j);
+        return Promise.all(promises).then(function() {
+            for(var j = 0, m = channels.length; j < m; j++){
+                var gltfChannel = channels[j];
+                var target = gltfChannel.target;
+                var channelTargetEntity = entities[target.node];
+                var relativePath = "";
+                var entity = channelTargetEntity;
+                while(entity.parent){
+                    relativePath = relativePath === "" ? "" + entity.name : entity.name + "/" + relativePath;
+                    entity = entity.parent;
                 }
-                output = scaled;
-            }
-            var outputStride = output.length / input.length;
-            var _gltfSampler_interpolation;
-            var interpolation = (_gltfSampler_interpolation = gltfSampler.interpolation) != null ? _gltfSampler_interpolation : AnimationSamplerInterpolation.Linear;
-            var samplerInterpolation = void 0;
-            switch(interpolation){
-                case AnimationSamplerInterpolation.CubicSpine:
-                    samplerInterpolation = engineCore.InterpolationType.CubicSpine;
-                    break;
-                case AnimationSamplerInterpolation.Step:
-                    samplerInterpolation = engineCore.InterpolationType.Step;
-                    break;
-                case AnimationSamplerInterpolation.Linear:
-                    samplerInterpolation = engineCore.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 = engineCore.Transform;
-                    propertyName = "position";
-                    break;
-                case AnimationChannelTargetPath.ROTATION:
-                    ComponentType = engineCore.Transform;
-                    propertyName = "rotationQuaternion";
-                    break;
-                case AnimationChannelTargetPath.SCALE:
-                    ComponentType = engineCore.Transform;
-                    propertyName = "scale";
-                    break;
-                case AnimationChannelTargetPath.WEIGHTS:
-                    ComponentType = engineCore.SkinnedMeshRenderer;
-                    propertyName = "blendShapeWeights";
-                    break;
+                var ComponentType = void 0;
+                var propertyName = void 0;
+                switch(target.path){
+                    case AnimationChannelTargetPath.TRANSLATION:
+                        ComponentType = engineCore.Transform;
+                        propertyName = "position";
+                        break;
+                    case AnimationChannelTargetPath.ROTATION:
+                        ComponentType = engineCore.Transform;
+                        propertyName = "rotationQuaternion";
+                        break;
+                    case AnimationChannelTargetPath.SCALE:
+                        ComponentType = engineCore.Transform;
+                        propertyName = "scale";
+                        break;
+                    case AnimationChannelTargetPath.WEIGHTS:
+                        ComponentType = engineCore.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];
@@ -1532,20 +1578,18 @@ var GLTFBufferParser = /*#__PURE__*/ function(GLTFParser) {
             }).then(function(param) {
                 var glTF = param.glTF, buffers = param.buffers;
                 context.glTF = glTF;
-                context.buffers = buffers;
+                context._buffers = buffers;
             });
         } else {
             return engineCore.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 = engineCore.Utils.resolveAbsoluteUrl(url, buffer.uri);
                     restoreBufferRequests.push(new BufferRequestInfo(absoluteUrl, requestConfig));
                     return engineCore.request(absoluteUrl, requestConfig);
-                })).then(function(buffers) {
-                    context.buffers = buffers;
-                });
+                }));
             });
         }
     };
@@ -1624,6 +1668,10 @@ var GLTFEntityParser = /*#__PURE__*/ function(GLTFParser) {
                 }
                 sceneRoots[i] = rootEntity;
             }
+            // @ts-ignore
+            sceneRoots[i]._hookResource = glTFResource;
+            // @ts-ignore
+            glTFResource._addReferCount(1);
         }
         glTFResource.sceneRoots = sceneRoots;
         glTFResource.defaultSceneRoot = sceneRoots[sceneID];
@@ -1790,7 +1838,9 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
                             }
                         }, function() {
                             var indexAccessor = glTF.accessors[gltfPrimitive.indices];
-                            return GLTFUtils.getAccessorData(glTF, indexAccessor, buffers);
+                            return context.getBuffers().then(function(buffers) {
+                                return GLTFUtils.getAccessorData(glTF, indexAccessor, buffers);
+                            });
                         }, context.keepMeshData).then(resolve);
                     }
                 });
@@ -1800,7 +1850,7 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
             for(var j = 0; j < gltfMesh.primitives.length; j++)_loop(j);
             meshPromises[i] = Promise.all(primitivePromises);
         };
-        var glTF = context.glTF, buffers = context.buffers, glTFResource = context.glTFResource;
+        var glTF = context.glTF, glTFResource = context.glTFResource;
         var engine = glTFResource.engine;
         if (!glTF.meshes) return;
         var meshesPromiseInfo = context.meshesPromiseInfo;
@@ -1815,8 +1865,109 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
     /**
    * @internal
    */ GLTFMeshParser._parseMeshFromGLTFPrimitive = function _parseMeshFromGLTFPrimitive(context, mesh, meshRestoreInfo, gltfMesh, gltfPrimitive, gltf, getVertexBufferData, getBlendShapeData, getIndexBufferData, keepMeshData) {
+        var _loop = function(attribute) {
+            var accessor = accessors[attributes[attribute]];
+            var promise = GLTFUtils.getAccessorBuffer(context, gltf.bufferViews, accessor).then(function(accessorBuffer) {
+                var dataElementSize = GLTFUtils.getAccessorTypeSize(accessor.type);
+                var accessorCount = accessor.count;
+                var vertices = accessorBuffer.data;
+                var vertexElement;
+                var meshId = mesh.instanceId;
+                var vertexBindingInfos = accessorBuffer.vertexBindingInfos;
+                var elementNormalized = accessor.normalized;
+                var elementFormat = GLTFUtils.getElementFormat(accessor.componentType, dataElementSize, elementNormalized);
+                var scaleFactor;
+                elementNormalized && (scaleFactor = GLTFUtils.getNormalizedComponentScale(accessor.componentType));
+                var elementOffset;
+                if (accessorBuffer.interleaved) {
+                    var byteOffset = accessor.byteOffset || 0;
+                    var stride = accessorBuffer.stride;
+                    elementOffset = byteOffset % stride;
+                    if (vertexBindingInfos[meshId] === undefined) {
+                        vertexElement = new engineCore.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
+                        var vertexBuffer = accessorBuffer.vertexBuffer;
+                        if (!vertexBuffer) {
+                            vertexBuffer = new engineCore.Buffer(engine, engineCore.BufferBindFlag.VertexBuffer, vertices.byteLength, engineCore.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 engineCore.VertexElement(attribute, elementOffset, elementFormat, vertexBindingInfos[meshId]);
+                    }
+                } else {
+                    elementOffset = 0;
+                    vertexElement = new engineCore.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
+                    var vertexBuffer1 = new engineCore.Buffer(engine, engineCore.BufferBindFlag.VertexBuffer, vertices.byteLength, engineCore.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 engineMath.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);
+                            engineMath.Vector3.min(min, position1, min);
+                            engineMath.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 engineMath.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 engineMath.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();
@@ -1830,145 +1981,85 @@ var GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1) {
             boneIndices = new Array(vertexCount);
             boneWeights = new Array(vertexCount);
         }
-        for(var attribute in attributes){
-            var accessor = accessors[attributes[attribute]];
-            var accessorBuffer = GLTFUtils.getAccessorBuffer(context, gltf.bufferViews, accessor);
-            var dataElementSize = GLTFUtils.getAccessorTypeSize(accessor.type);
-            var accessorCount = accessor.count;
-            var vertices = accessorBuffer.data;
-            var vertexElement = void 0;
-            var meshId = mesh.instanceId;
-            var vertexBindingInfos = accessorBuffer.vertexBindingInfos;
-            var elementNormalized = accessor.normalized;
-            var elementFormat = GLTFUtils.getElementFormat(accessor.componentType, dataElementSize, elementNormalized);
-            var scaleFactor = void 0;
-            elementNormalized && (scaleFactor = GLTFUtils.getNormalizedComponentScale(accessor.componentType));
-            var elementOffset = void 0;
-            if (accessorBuffer.interleaved) {
-                var byteOffset = accessor.byteOffset || 0;
-                var stride = accessorBuffer.stride;
-                elementOffset = byteOffset % stride;
-                if (vertexBindingInfos[meshId] === undefined) {
-                    vertexElement = new engineCore.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
-                    var vertexBuffer = accessorBuffer.vertexBuffer;
-                    if (!vertexBuffer) {
-                        vertexBuffer = new engineCore.Buffer(engine, engineCore.BufferBindFlag.VertexBuffer, vertices.byteLength, engineCore.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 engineCore.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 engineCore.VertexElement(attribute, elementOffset, elementFormat, bufferBindIndex);
-                var vertexBuffer1 = new engineCore.Buffer(engine, engineCore.BufferBindFlag.VertexBuffer, vertices.byteLength, engineCore.BufferUsage.Static);
-                vertexBuffer1.setData(vertices);
-                meshRestoreInfo.vertexBuffers.push(new BufferRestoreInfo(vertexBuffer1, accessorBuffer.restoreInfo));
-                mesh.setVertexBufferBinding(vertexBuffer1, accessorBuffer.stride, bufferBindIndex);
-                vertexBindingInfos[meshId] = bufferBindIndex++;
+                mesh.addSubMesh(0, vertexCount, mode);
             }
-            vertexElements.push(vertexElement);
-            if (attribute === "POSITION") {
-                vertexCount = accessorCount;
-                var _mesh_bounds = mesh.bounds, min = _mesh_bounds.min, max = _mesh_bounds.max;
-                if (accessor.min && accessor.max) {
-                    min.copyFromArray(accessor.min);
-                    max.copyFromArray(accessor.max);
-                    if (keepMeshData) {
-                        var baseOffset = elementOffset / vertices.BYTES_PER_ELEMENT;
-                        var stride1 = vertices.length / accessorCount;
-                        for(var j = 0; j < accessorCount; j++){
-                            var offset = baseOffset + j * stride1;
-                            var position = new engineMath.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);
-                        engineMath.Vector3.min(min, position1, min);
-                        engineMath.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 engineMath.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 engineMath.Vector4(vertices[offset3], vertices[offset3 + 1], vertices[offset3 + 2], vertices[offset3 + 3]);
-                    elementNormalized && boneWeight.scale(scaleFactor);
-                    boneWeights[j3] = boneWeight;
-                }
+            // BlendShapes
+            if (targets) {
+                promises.push(GLTFMeshParser._createBlendShape(mesh, meshRestoreInfo, gltfMesh, accessors, targets, getBlendShapeData));
             }
-        }
-        mesh.setVertexElements(vertexElements);
-        // Indices
-        if (indices !== undefined) {
-            var indexAccessor = gltf.accessors[indices];
-            var accessorBuffer1 = GLTFUtils.getAccessorBuffer(context, gltf.bufferViews, indexAccessor);
-            mesh.setIndices(accessorBuffer1.data);
-            mesh.addSubMesh(0, indexAccessor.count, mode);
-            meshRestoreInfo.indexBuffer = accessorBuffer1.restoreInfo;
-        } else {
-            mesh.addSubMesh(0, vertexCount, mode);
-        }
-        // BlendShapes
-        targets && GLTFMeshParser._createBlendShape(mesh, meshRestoreInfo, gltfMesh, targets, getBlendShapeData);
-        mesh.uploadData(!keepMeshData);
-        //@ts-ignore
-        mesh._positions = positions;
-        //@ts-ignore
-        mesh._boneIndices = boneIndices;
-        //@ts-ignore
-        mesh._boneWeights = boneWeights;
-        return Promise.resolve(mesh);
+            return Promise.all(promises).then(function() {
+                mesh.uploadData(!keepMeshData);
+                //@ts-ignore
+                mesh._positions = positions;
+                //@ts-ignore
+                mesh._boneIndices = boneIndices;
+                //@ts-ignore
+                mesh._boneWeights = boneWeights;
+                return Promise.resolve(mesh);
+            });
+        });
     };
     /**
    * @internal
-   */ GLTFMeshParser._createBlendShape = function _createBlendShape(mesh, meshRestoreInfo, glTFMesh, glTFTargets, getBlendShapeData) {
-        var blendShapeNames = glTFMesh.extras ? glTFMesh.extras.targetNames : null;
-        for(var i = 0, n = glTFTargets.length; i < n; i++){
+   */ GLTFMeshParser._createBlendShape = function _createBlendShape(mesh, meshRestoreInfo, glTFMesh, accessors, glTFTargets, getBlendShapeData) {
+        var _loop = function(i, n) {
             var name = blendShapeNames ? blendShapeNames[i] : "blendShape" + i;
-            var deltaPosBufferInfo = getBlendShapeData("POSITION", i);
-            var deltaNorBufferInfo = getBlendShapeData("NORMAL", i);
-            var deltaTanBufferInfo = getBlendShapeData("TANGENT", i);
-            var deltaPositions = deltaPosBufferInfo.data ? GLTFUtils.floatBufferToVector3Array(deltaPosBufferInfo.data) : null;
-            var deltaNormals = (deltaNorBufferInfo == null ? void 0 : deltaNorBufferInfo.data) ? GLTFUtils.floatBufferToVector3Array(deltaNorBufferInfo == null ? void 0 : deltaNorBufferInfo.data) : null;
-            var deltaTangents = (deltaTanBufferInfo == null ? void 0 : deltaTanBufferInfo.data) ? GLTFUtils.floatBufferToVector3Array(deltaTanBufferInfo == null ? void 0 : deltaTanBufferInfo.data) : null;
-            var blendShape = new engineCore.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 engineCore.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);
@@ -2120,51 +2211,58 @@ var GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
     }
     var _proto = GLTFSkinParser.prototype;
     _proto.parse = function parse(context) {
-        var glTFResource = context.glTFResource, glTF = context.glTF; context.buffers;
-        var entities = glTFResource.entities;
-        var gltfSkins = glTF.skins;
-        if (!gltfSkins) return;
-        var count = gltfSkins.length;
-        var skins = new Array(count);
-        for(var i = 0; i < count; i++){
+        var _loop = function(i) {
             var _gltfSkins_i = gltfSkins[i], inverseBindMatrices = _gltfSkins_i.inverseBindMatrices, skeleton = _gltfSkins_i.skeleton, joints = _gltfSkins_i.joints, _gltfSkins_i_name = _gltfSkins_i.name, name = _gltfSkins_i_name === void 0 ? "SKIN_" + i : _gltfSkins_i_name;
             var jointCount = joints.length;
             var skin = new engineCore.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 engineMath.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 engineMath.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 engineCore.AssetPromise.all(promises).then(function(skins) {
+            glTFResource.skins = skins;
+        });
     };
     _proto._findSkeletonRootBone = function _findSkeletonRootBone(joints, entities) {
         var paths = {};
@@ -2205,13 +2303,14 @@ var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
     var _proto = GLTFTextureParser.prototype;
     _proto.parse = function parse(context) {
         var _this = this;
-        var glTFResource = context.glTFResource, glTF = context.glTF, buffers = context.buffers;
+        var glTFResource = context.glTFResource, glTF = context.glTF;
         var engine = glTFResource.engine, url = glTFResource.url;
         if (glTF.textures) {
             var texturesPromiseInfo = context.texturesPromiseInfo;
             engineCore.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(".");
@@ -2219,31 +2318,36 @@ var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
                     var type = ext.startsWith("ktx") ? engineCore.AssetType.KTX : engineCore.AssetType.Texture2D;
                     return engine.resourceManager.load({
                         url: engineCore.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 engineCore.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 engineCore.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) {
@@ -2253,22 +2357,39 @@ var GLTFTextureParser = /*#__PURE__*/ function(GLTFParser) {
             return texturesPromiseInfo.promise;
         }
     };
-    _proto._parseSampler = function _parseSampler(texture, sampler) {
-        var magFilter = sampler.magFilter, minFilter = sampler.minFilter, wrapS = sampler.wrapS, wrapT = sampler.wrapT;
-        if (magFilter || minFilter) {
+    _proto._getSamplerInfo = function _getSamplerInfo(sampler) {
+        var minFilter = sampler.minFilter, magFilter = sampler.magFilter, wrapS = sampler.wrapS, wrapT = sampler.wrapT;
+        var info = {};
+        if (minFilter || magFilter) {
+            info.mipmap = minFilter >= TextureMinFilter.NEAREST_MIPMAP_NEAREST;
             if (magFilter === TextureMagFilter.NEAREST) {
-                texture.filterMode = engineCore.TextureFilterMode.Point;
-            } else if (minFilter <= TextureMinFilter.LINEAR_MIPMAP_NEAREST) {
-                texture.filterMode = engineCore.TextureFilterMode.Bilinear;
+                info.filterMode = engineCore.TextureFilterMode.Point;
             } else {
-                texture.filterMode = engineCore.TextureFilterMode.Trilinear;
+                if (minFilter <= TextureMinFilter.LINEAR_MIPMAP_NEAREST) {
+                    info.filterMode = engineCore.TextureFilterMode.Bilinear;
+                } else {
+                    info.filterMode = engineCore.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;
@@ -2366,33 +2487,16 @@ var GLTFValidator = /*#__PURE__*/ function(GLTFParser1) {
 
 /**
  * Product after glTF parser, usually, `defaultSceneRoot` is only needed to use.
- */ var GLTFResource = /*#__PURE__*/ function(EngineObject) {
-    _inherits(GLTFResource, EngineObject);
+ */ var GLTFResource = /*#__PURE__*/ function(ReferResource) {
+    _inherits(GLTFResource, ReferResource);
     function GLTFResource(engine, url) {
         var _this;
-        _this = EngineObject.call(this, engine) || this;
+        _this = ReferResource.call(this, engine) || this;
         _this.url = url;
         return _this;
     }
-    var _proto = GLTFResource.prototype;
-    /**
-   * @internal
-   */ _proto._onDestroy = function _onDestroy() {
-        EngineObject.prototype._onDestroy.call(this);
-        this.defaultSceneRoot.destroy();
-        this.textures = null;
-        this.materials = null;
-        this.meshes = null;
-        this.skins = null;
-        this.animations = null;
-        this.entities = null;
-        this.cameras = null;
-        this.lights = null;
-        this.sceneRoots = null;
-        this.extensionsData = null;
-    };
     return GLTFResource;
-}(engineCore.EngineObject);
+}(engineCore.ReferResource);
 
 var GLTFLoader = /*#__PURE__*/ function(Loader) {
     _inherits(GLTFLoader, Loader);
@@ -2422,8 +2526,14 @@ var GLTFLoader = /*#__PURE__*/ function(Loader) {
             resourceManager.addContentRestorer(restorer);
             masterPromiseInfo.resolve(glTFResource);
         }).catch(function(e) {
-            console.error(e);
-            masterPromiseInfo.reject("Error loading glTF model from " + url + " .");
+            var msg = "Error loading glTF model from " + url + " : " + e;
+            engineCore.Logger.error(msg);
+            masterPromiseInfo.reject(msg);
+            context.defaultSceneRootPromiseInfo.reject(e);
+            context.texturesPromiseInfo.reject(e);
+            context.materialsPromiseInfo.reject(e);
+            context.meshesPromiseInfo.reject(e);
+            context.animationClipsPromiseInfo.reject(e);
         });
         return context.promiseMap;
     };
@@ -3025,6 +3135,15 @@ KTXLoader = __decorate([
     ])
 ], KTXLoader);
 
+function parseProperty(object, key, value) {
+    if (typeof value === "object") {
+        for(var subKey in value){
+            parseProperty(object[key], subKey, value[subKey]);
+        }
+    } else {
+        object[key] = value;
+    }
+}
 var MaterialLoader = /*#__PURE__*/ function(Loader) {
     _inherits(MaterialLoader, Loader);
     function MaterialLoader() {
@@ -3036,7 +3155,7 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
         return new engineCore.AssetPromise(function(resolve, reject) {
             _this.request(item.url, _extends({}, item, {
                 type: "json"
-            })).then(function(json) {
+            })).then(function(materialSchema) {
                 var _loop = function(key) {
                     var _shaderData_key = shaderData[key], type = _shaderData_key.type, value = _shaderData_key.value;
                     switch(type){
@@ -3064,27 +3183,8 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                     }
                 };
                 var engine = resourceManager.engine;
-                var name = json.name, shader = json.shader, shaderData = json.shaderData, macros = json.macros, renderState = json.renderState;
-                var material;
-                switch(shader){
-                    case "pbr":
-                        material = new engineCore.PBRMaterial(engine);
-                        break;
-                    case "pbr-specular":
-                        material = new engineCore.PBRSpecularMaterial(engine);
-                        break;
-                    case "unlit":
-                        material = new engineCore.UnlitMaterial(engine);
-                        break;
-                    case "blinn-phong":
-                        material = new engineCore.BlinnPhongMaterial(engine);
-                        break;
-                    case "bake-pbr":
-                        // @todo refactor custom shader later
-                        // @ts-ignore
-                        material = new engineCore.PBRBaseMaterial(engine, engineCore.Shader.find("bake-pbr"));
-                        break;
-                }
+                var name = materialSchema.name, shader = materialSchema.shader, shaderData = materialSchema.shaderData, macros = materialSchema.macros, renderState = materialSchema.renderState;
+                var material = new engineCore.Material(engine, engineCore.Shader.find(shader));
                 material.name = name;
                 var texturePromises = new Array();
                 var materialShaderData = material.shaderData;
@@ -3097,9 +3197,7 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                         materialShaderData.enableMacro(name1, value);
                     }
                 }
-                for(var key1 in renderState){
-                    material[key1] = renderState[key1];
-                }
+                parseProperty(material, "renderState", renderState);
                 return Promise.all(texturePromises).then(function() {
                     resolve(material);
                 });
@@ -3854,6 +3952,12 @@ exports.AnimationClipDecoder = __decorate([
     decoder("AnimationClip")
 ], exports.AnimationClipDecoder);
 
+exports.SpecularMode = void 0;
+(function(SpecularMode) {
+    SpecularMode["Sky"] = "Sky";
+    SpecularMode["Custom"] = "Custom";
+})(exports.SpecularMode || (exports.SpecularMode = {}));
+
 var SceneParserContext = /*#__PURE__*/ function() {
     function SceneParserContext(originalData, scene) {
         this.originalData = originalData;
@@ -3981,7 +4085,7 @@ exports.MeshLoader = /*#__PURE__*/ function(Loader) {
                 decode(data, resourceManager.engine).then(function(mesh) {
                     resolve(mesh);
                 });
-            });
+            }).catch(reject);
         });
     };
     return MeshLoader;
@@ -4000,14 +4104,14 @@ exports.EditorTextureLoader = /*#__PURE__*/ function(Loader) {
     var _proto = EditorTextureLoader.prototype;
     _proto.load = function load(item, resourceManager) {
         var _this = this;
-        return new engineCore.AssetPromise(function(resolve) {
+        return new engineCore.AssetPromise(function(resolve, reject) {
             _this.request(item.url, {
                 type: "arraybuffer"
             }).then(function(data) {
                 decode(data, resourceManager.engine).then(function(texture) {
                     resolve(texture);
                 });
-            });
+            }).catch(reject);
         });
     };
     return EditorTextureLoader;
@@ -4384,7 +4488,7 @@ var AnimationClipLoader = /*#__PURE__*/ function(Loader) {
             _this.request(item.url, _extends({}, item, {
                 type: "arraybuffer"
             })).then(function(data) {
-                return decode(data, resourceManager.engine);
+                return decode(data, resourceManager.engine).then(resolve);
             }).catch(reject);
         });
     };
@@ -4412,16 +4516,32 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
                 // @ts-ignore
                 engine.resourceManager.initVirtualResources(data.files);
                 return SceneParser.parse(engine, data).then(function(scene) {
+                    var promises = [];
                     // parse ambient light
                     var ambient = data.scene.ambient;
-                    var ambientLightPromise = Promise.resolve();
-                    if (ambient.ambientLight) {
-                        ambientLightPromise = resourceManager// @ts-ignore
-                        .getResourceByRef(data.scene.ambient.ambientLight).then(function(light) {
-                            scene.ambientLight = light;
+                    var useCustomAmbient = ambient.specularMode === "Custom";
+                    if (useCustomAmbient && ambient.customAmbientLight) {
+                        // @ts-ignore
+                        // prettier-ignore
+                        var customAmbientPromise = resourceManager.getResourceByRef(ambient.customAmbientLight).then(function(ambientLight) {
+                            scene.ambientLight = ambientLight;
+                            scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
+                            scene.ambientLight.specularIntensity = ambient.specularIntensity;
+                            scene.ambientLight.diffuseMode = ambient.diffuseMode;
+                            scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
+                        });
+                        promises.push(customAmbientPromise);
+                    } else if (!useCustomAmbient && ambient.ambientLight) {
+                        // @ts-ignore
+                        // prettier-ignore
+                        var ambientLightPromise = resourceManager.getResourceByRef(ambient.ambientLight).then(function(ambientLight) {
+                            scene.ambientLight = ambientLight;
                             scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
                             scene.ambientLight.specularIntensity = ambient.specularIntensity;
+                            scene.ambientLight.diffuseMode = ambient.diffuseMode;
+                            scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
                         });
+                        promises.push(ambientLightPromise);
                     } else {
                         scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
                         scene.ambientLight.specularIntensity = ambient.specularIntensity;
@@ -4429,30 +4549,34 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
                     }
                     var background = data.scene.background;
                     scene.background.mode = background.mode;
-                    var backgroundPromise = Promise.resolve();
                     switch(scene.background.mode){
                         case engineCore.BackgroundMode.SolidColor:
                             scene.background.solidColor.copyFrom(background.color);
                             break;
                         case engineCore.BackgroundMode.Sky:
-                            if (background.sky) {
+                            if (background.skyMesh && background.skyMaterial) {
+                                // @ts-ignore
+                                var skyMeshPromise = resourceManager.getResourceByRef(background.skyMesh).then(function(mesh) {
+                                    scene.background.sky.mesh = mesh;
+                                });
                                 // @ts-ignore
-                                backgroundPromise = resourceManager.getResourceByRef(background.sky).then(function(light) {
-                                    var sky = scene.background.sky;
-                                    var skyMaterial = new engineCore.SkyBoxMaterial(engine);
-                                    skyMaterial.texture = light.specularTexture;
-                                    skyMaterial.textureDecodeRGBM = true;
-                                    sky.material = skyMaterial;
-                                    sky.mesh = engineCore.PrimitiveMesh.createCuboid(engine, 1, 1, 1);
+                                // prettier-ignore
+                                var skyMaterialPromise = resourceManager.getResourceByRef(background.skyMaterial).then(function(material) {
+                                    scene.background.sky.material = material;
                                 });
+                                promises.push(skyMeshPromise, skyMaterialPromise);
+                            } else {
+                                engineCore.Logger.warn("Sky background mode requires skyMesh and skyMaterial");
                             }
                             break;
                         case engineCore.BackgroundMode.Texture:
                             if (background.texture) {
                                 // @ts-ignore
-                                backgroundPromise = resourceManager.getResourceByRef(background.texture).then(function(texture) {
+                                // prettier-ignore
+                                var backgroundPromise = resourceManager.getResourceByRef(background.texture).then(function(texture) {
                                     scene.background.texture = texture;
                                 });
+                                promises.push(backgroundPromise);
                             }
                             break;
                     }
@@ -4464,10 +4588,7 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
                         if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
                         if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
                     }
-                    return Promise.all([
-                        ambientLightPromise,
-                        backgroundPromise
-                    ]).then(function() {
+                    return Promise.all(promises).then(function() {
                         resolve(scene);
                     });
                 });
@@ -4510,7 +4631,7 @@ var KHR_draco_mesh_compression = (_KHR_draco_mesh_compression = /*#__PURE__*/ fu
     };
     _proto.createAndParse = function createAndParse(context, schema, glTFPrimitive, glTFMesh) {
         var _this = this;
-        var glTF = context.glTF, buffers = context.buffers, engine = context.glTFResource.engine;
+        var glTF = context.glTF, engine = context.glTFResource.engine;
         var bufferViews = glTF.bufferViews, accessors = glTF.accessors;
         var bufferViewIndex = schema.bufferView, gltfAttributeMap = schema.attributes;
         var attributeMap = {};
@@ -4532,21 +4653,23 @@ var KHR_draco_mesh_compression = (_KHR_draco_mesh_compression = /*#__PURE__*/ fu
             useUniqueIDs: true,
             indexType: indexType
         };
-        var buffer = GLTFUtils.getBufferViewData(bufferViews[bufferViewIndex], buffers);
-        return KHR_draco_mesh_compression._decoder.decode(buffer, taskConfig).then(function(decodedGeometry) {
-            var mesh = new engineCore.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 engineCore.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) {
@@ -4645,7 +4768,7 @@ var KHR_draco_mesh_compression = (_KHR_draco_mesh_compression = /*#__PURE__*/ fu
             mesh.addSubMesh(0, vertexCount, mode);
         }
         // BlendShapes
-        targets && GLTFMeshParser._createBlendShape(mesh, null, gltfMesh, targets, getBlendShapeData);
+        targets && GLTFMeshParser._createBlendShape(mesh, null, gltfMesh, accessors, targets, getBlendShapeData);
         mesh.uploadData(!keepMeshData);
         return Promise.resolve(mesh);
     };