@galacean/engine-loader 1.1.0-beta.9 → 1.2.0-alpha.0

package/dist/main.js

@@ -120,116 +120,116 @@ var BufferReader = /*#__PURE__*/ function() {
         this.data = data;
         this._dataView = new DataView(data.buffer, data.byteOffset + byteOffset, byteLength != null ? byteLength : data.byteLength - byteOffset);
         this._littleEndian = littleEndian;
-        this._offset = 0;
+        this._position = 0;
         this._baseOffset = byteOffset;
     }
     var _proto = BufferReader.prototype;
     _proto.nextUint8 = function nextUint8() {
-        var value = this._dataView.getUint8(this._offset);
-        this._offset += 1;
+        var value = this._dataView.getUint8(this._position);
+        this._position += 1;
         return value;
     };
     _proto.nextUint16 = function nextUint16() {
-        var value = this._dataView.getUint16(this._offset, this._littleEndian);
-        this._offset += 2;
+        var value = this._dataView.getUint16(this._position, this._littleEndian);
+        this._position += 2;
         return value;
     };
     _proto.nextUint32 = function nextUint32() {
-        var value = this._dataView.getUint32(this._offset, this._littleEndian);
-        this._offset += 4;
+        var value = this._dataView.getUint32(this._position, this._littleEndian);
+        this._position += 4;
         return value;
     };
     _proto.nextInt32 = function nextInt32() {
-        var value = this._dataView.getInt32(this._offset, this._littleEndian);
-        this._offset += 4;
+        var value = this._dataView.getInt32(this._position, this._littleEndian);
+        this._position += 4;
         return value;
     };
     _proto.nextInt32Array = function nextInt32Array(len) {
-        var value = new Int32Array(this.data.buffer, this._offset + this._dataView.byteOffset, len);
-        this._offset += 4 * len;
+        var value = new Int32Array(this.data.buffer, this._position + this._dataView.byteOffset, len);
+        this._position += 4 * len;
         return value;
     };
     _proto.nextFloat32 = function nextFloat32() {
-        var value = this._dataView.getFloat32(this._offset, this._littleEndian);
-        this._offset += 4;
+        var value = this._dataView.getFloat32(this._position, this._littleEndian);
+        this._position += 4;
         return value;
     };
     _proto.nextFloat32Array = function nextFloat32Array(len) {
-        var value = new Float32Array(this.data.buffer, this._offset + this._dataView.byteOffset, len);
-        this._offset += 4 * len;
+        var value = new Float32Array(this.data.buffer, this._position + this._dataView.byteOffset, len);
+        this._position += 4 * len;
         return value;
     };
     _proto.nextUint32Array = function nextUint32Array(len) {
-        var value = new Uint32Array(this.data.buffer, this._offset + this._dataView.byteOffset, len);
-        this._offset += 4 * len;
+        var value = new Uint32Array(this.data.buffer, this._position + this._dataView.byteOffset, len);
+        this._position += 4 * len;
         return value;
     };
     _proto.nextUint8Array = function nextUint8Array(len) {
-        var value = new Uint8Array(this.data.buffer, this._offset + this._dataView.byteOffset, len);
-        this._offset += len;
+        var value = new Uint8Array(this.data.buffer, this._position + this._dataView.byteOffset, len);
+        this._position += len;
         return value;
     };
     _proto.nextUint64 = function nextUint64() {
-        var left = this._dataView.getUint32(this._offset, this._littleEndian);
-        var right = this._dataView.getUint32(this._offset + 4, this._littleEndian);
+        var left = this._dataView.getUint32(this._position, this._littleEndian);
+        var right = this._dataView.getUint32(this._position + 4, this._littleEndian);
         var value = left + Math.pow(2, 32) * right;
-        this._offset += 8;
+        this._position += 8;
         return value;
     };
     _proto.nextStr = function nextStr() {
         var strByteLength = this.nextUint16();
-        var uint8Array = new Uint8Array(this.data.buffer, this._offset + this._dataView.byteOffset, strByteLength);
-        this._offset += strByteLength;
+        var uint8Array = new Uint8Array(this.data.buffer, this._position + this._dataView.byteOffset, strByteLength);
+        this._position += strByteLength;
         return engineCore.Utils.decodeText(uint8Array);
     };
     /**
    * image data 放在最后
    */ _proto.nextImageData = function nextImageData(count) {
-        return new Uint8Array(this.data.buffer, this.data.byteOffset + this._offset);
+        return new Uint8Array(this.data.buffer, this.data.byteOffset + this._position);
     };
     _proto.nextImagesData = function nextImagesData(count) {
         var imagesLen = new Array(count);
         // Start offset of Uint32Array should be a multiple of 4. ref: https://stackoverflow.com/questions/15417310/why-typed-array-constructors-require-offset-to-be-multiple-of-underlying-type-si
         for(var i = 0; i < count; i++){
-            var len = this._dataView.getUint32(this._offset, this._littleEndian);
+            var len = this._dataView.getUint32(this._position, this._littleEndian);
             imagesLen[i] = len;
-            this._offset += 4;
+            this._position += 4;
         }
         var imagesData = [];
         for(var i1 = 0; i1 < count; i1++){
             var len1 = imagesLen[i1];
-            var buffer = new Uint8Array(this.data.buffer, this._dataView.byteOffset + this._offset, len1);
-            this._offset += len1;
+            var buffer = new Uint8Array(this.data.buffer, this._dataView.byteOffset + this._position, len1);
+            this._position += len1;
             imagesData.push(buffer);
         }
         return imagesData;
     };
     _proto.skip = function skip(bytes) {
-        this._offset += bytes;
+        this._position += bytes;
         return this;
     };
     _proto.scan = function scan(maxByteLength, term) {
         if (term === void 0) term = 0x00;
-        var byteOffset = this._offset;
+        var byteOffset = this._position;
         var byteLength = 0;
-        while(this._dataView.getUint8(this._offset) !== term && byteLength < maxByteLength){
+        while(this._dataView.getUint8(this._position) !== term && byteLength < maxByteLength){
             byteLength++;
-            this._offset++;
+            this._position++;
         }
-        if (byteLength < maxByteLength) this._offset++;
+        if (byteLength < maxByteLength) this._position++;
         return new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + byteOffset, byteLength);
     };
     _create_class(BufferReader, [
         {
             key: "position",
             get: function get() {
-                return this._offset;
+                return this._position;
             }
         },
         {
             key: "offset",
             get: function get() {
-                return this._offset + this._baseOffset;
+                return this._position + this._baseOffset;
             }
         }
     ]);
@@ -293,75 +293,74 @@ exports.MeshDecoder = /*#__PURE__*/ function() {
             var encodedMeshData = JSON.parse(jsonDataString);
             // @ts-ignore Vector3 is not compatible with {x: number, y: number, z: number}.
             encodedMeshData.bounds && modelMesh.bounds.copyFrom(encodedMeshData.bounds);
-            var offset = Math.ceil(bufferReader.offset / 4) * 4;
+            var offset = Math.ceil(bufferReader.offset / 4) * 4 + bufferReader.data.byteOffset;
             var buffer = bufferReader.data.buffer;
-            var byteOffset = bufferReader.data.byteOffset;
-            var float32Array = new Float32Array(buffer, encodedMeshData.positions.start + offset + byteOffset, (encodedMeshData.positions.end - encodedMeshData.positions.start) / 4);
+            var float32Array = new Float32Array(buffer, encodedMeshData.positions.start + offset, (encodedMeshData.positions.end - encodedMeshData.positions.start) / 4);
             var vertexCount = float32Array.length / 3;
             var positions = float32ArrayToVector3(float32Array, vertexCount);
             modelMesh.setPositions(positions);
             if (encodedMeshData.normals) {
-                var float32Array1 = new Float32Array(buffer, encodedMeshData.normals.start + offset + byteOffset, (encodedMeshData.normals.end - encodedMeshData.normals.start) / 4);
+                var float32Array1 = new Float32Array(buffer, encodedMeshData.normals.start + offset, (encodedMeshData.normals.end - encodedMeshData.normals.start) / 4);
                 var normals = float32ArrayToVector3(float32Array1, vertexCount);
                 modelMesh.setNormals(normals);
             }
             if (encodedMeshData.uvs) {
-                var float32Array2 = new Float32Array(buffer, encodedMeshData.uvs.start + offset + byteOffset, (encodedMeshData.uvs.end - encodedMeshData.uvs.start) / 4);
+                var float32Array2 = new Float32Array(buffer, encodedMeshData.uvs.start + offset, (encodedMeshData.uvs.end - encodedMeshData.uvs.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array2, vertexCount));
             }
             if (encodedMeshData.uv1) {
-                var float32Array3 = new Float32Array(buffer, encodedMeshData.uv1.start + offset + byteOffset, (encodedMeshData.uv1.end - encodedMeshData.uv1.start) / 4);
+                var float32Array3 = new Float32Array(buffer, encodedMeshData.uv1.start + offset, (encodedMeshData.uv1.end - encodedMeshData.uv1.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array3, vertexCount), 1);
             }
             if (encodedMeshData.uv2) {
-                var float32Array4 = new Float32Array(buffer, encodedMeshData.uv2.start + offset + byteOffset, (encodedMeshData.uv2.end - encodedMeshData.uv2.start) / 4);
+                var float32Array4 = new Float32Array(buffer, encodedMeshData.uv2.start + offset, (encodedMeshData.uv2.end - encodedMeshData.uv2.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array4, vertexCount), 2);
             }
             if (encodedMeshData.uv3) {
-                var float32Array5 = new Float32Array(buffer, encodedMeshData.uv3.start + offset + byteOffset, (encodedMeshData.uv3.end - encodedMeshData.uv3.start) / 4);
+                var float32Array5 = new Float32Array(buffer, encodedMeshData.uv3.start + offset, (encodedMeshData.uv3.end - encodedMeshData.uv3.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array5, vertexCount), 3);
             }
             if (encodedMeshData.uv4) {
-                var float32Array6 = new Float32Array(buffer, encodedMeshData.uv4.start + offset + byteOffset, (encodedMeshData.uv4.end - encodedMeshData.uv4.start) / 4);
+                var float32Array6 = new Float32Array(buffer, encodedMeshData.uv4.start + offset, (encodedMeshData.uv4.end - encodedMeshData.uv4.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array6, vertexCount), 4);
             }
             if (encodedMeshData.uv5) {
-                var float32Array7 = new Float32Array(buffer, encodedMeshData.uv5.start + offset + byteOffset, (encodedMeshData.uv5.end - encodedMeshData.uv5.start) / 4);
+                var float32Array7 = new Float32Array(buffer, encodedMeshData.uv5.start + offset, (encodedMeshData.uv5.end - encodedMeshData.uv5.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array7, vertexCount), 5);
             }
             if (encodedMeshData.uv6) {
-                var float32Array8 = new Float32Array(buffer, encodedMeshData.uv6.start + offset + byteOffset, (encodedMeshData.uv6.end - encodedMeshData.uv6.start) / 4);
+                var float32Array8 = new Float32Array(buffer, encodedMeshData.uv6.start + offset, (encodedMeshData.uv6.end - encodedMeshData.uv6.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array8, vertexCount), 6);
             }
             if (encodedMeshData.uv7) {
-                var float32Array9 = new Float32Array(buffer, encodedMeshData.uv7.start + offset + byteOffset, (encodedMeshData.uv7.end - encodedMeshData.uv7.start) / 4);
+                var float32Array9 = new Float32Array(buffer, encodedMeshData.uv7.start + offset, (encodedMeshData.uv7.end - encodedMeshData.uv7.start) / 4);
                 modelMesh.setUVs(float32ArrayToVector2(float32Array9, vertexCount), 7);
             }
             if (encodedMeshData.colors) {
-                var float32Array10 = new Float32Array(buffer, encodedMeshData.colors.start + offset + byteOffset, (encodedMeshData.colors.end - encodedMeshData.colors.start) / 4);
+                var float32Array10 = new Float32Array(buffer, encodedMeshData.colors.start + offset, (encodedMeshData.colors.end - encodedMeshData.colors.start) / 4);
                 modelMesh.setColors(float32ArrayToVColor(float32Array10, vertexCount));
             }
             if (encodedMeshData.boneWeights) {
-                var float32Array11 = new Float32Array(buffer, encodedMeshData.boneWeights.start + offset + byteOffset, (encodedMeshData.boneWeights.end - encodedMeshData.boneWeights.start) / 4);
+                var float32Array11 = new Float32Array(buffer, encodedMeshData.boneWeights.start + offset, (encodedMeshData.boneWeights.end - encodedMeshData.boneWeights.start) / 4);
                 modelMesh.setBoneWeights(float32ArrayToVector4(float32Array11, vertexCount));
             }
             if (encodedMeshData.boneIndices) {
-                var float32Array12 = new Float32Array(buffer, encodedMeshData.boneIndices.start + offset + byteOffset, (encodedMeshData.boneIndices.end - encodedMeshData.boneIndices.start) / 4);
+                var float32Array12 = new Float32Array(buffer, encodedMeshData.boneIndices.start + offset, (encodedMeshData.boneIndices.end - encodedMeshData.boneIndices.start) / 4);
                 modelMesh.setBoneIndices(float32ArrayToVector4(float32Array12, vertexCount));
             }
             if (encodedMeshData.blendShapes) {
                 encodedMeshData.blendShapes.forEach(function(blendShapeData) {
                     var blendShape = new engineCore.BlendShape(blendShapeData.name);
                     blendShapeData.frames.forEach(function(frameData) {
-                        var positionArray = new Float32Array(buffer, frameData.deltaPosition.start + offset + byteOffset, (frameData.deltaPosition.end - frameData.deltaPosition.start) / 4);
+                        var positionArray = new Float32Array(buffer, frameData.deltaPosition.start + offset, (frameData.deltaPosition.end - frameData.deltaPosition.start) / 4);
                         var count = positionArray.length / 3;
                         var deltaPosition = float32ArrayToVector3(positionArray, count);
                         if (frameData.deltaNormals) {
-                            var normalsArray = new Float32Array(buffer, frameData.deltaNormals.start + offset + byteOffset, (frameData.deltaNormals.end - frameData.deltaNormals.start) / 4);
+                            var normalsArray = new Float32Array(buffer, frameData.deltaNormals.start + offset, (frameData.deltaNormals.end - frameData.deltaNormals.start) / 4);
                             float32ArrayToVector3(normalsArray, count);
                         }
                         if (frameData.deltaTangents) {
-                            var tangentsArray = new Float32Array(buffer, frameData.deltaTangents.start + offset + byteOffset, (frameData.deltaTangents.end - frameData.deltaTangents.start) / 4);
+                            var tangentsArray = new Float32Array(buffer, frameData.deltaTangents.start + offset, (frameData.deltaTangents.end - frameData.deltaTangents.start) / 4);
                             float32ArrayToVector4(tangentsArray, count);
                         }
                         blendShape.addFrame(frameData.weight, deltaPosition);
@@ -372,9 +371,9 @@ exports.MeshDecoder = /*#__PURE__*/ function() {
             if (encodedMeshData.indices) {
                 var indices = null;
                 if (encodedMeshData.indices.type === 0) {
-                    indices = new Uint16Array(buffer, encodedMeshData.indices.start + offset + byteOffset, (encodedMeshData.indices.end - encodedMeshData.indices.start) / 2);
+                    indices = new Uint16Array(buffer, encodedMeshData.indices.start + offset, (encodedMeshData.indices.end - encodedMeshData.indices.start) / 2);
                 } else {
-                    indices = new Uint32Array(buffer, encodedMeshData.indices.start + offset + byteOffset, (encodedMeshData.indices.end - encodedMeshData.indices.start) / 4);
+                    indices = new Uint32Array(buffer, encodedMeshData.indices.start + offset, (encodedMeshData.indices.end - encodedMeshData.indices.start) / 4);
                 }
                 modelMesh.setIndices(indices);
             }
@@ -543,11 +542,17 @@ var ReflectionParser = /*#__PURE__*/ function() {
         });
     };
     _proto.parseClassObject = function parseClassObject(item) {
+        var _this = this;
         var Class = engineCore.Loader.getClass(item.class);
         var _item_constructParams;
         var params = (_item_constructParams = item.constructParams) != null ? _item_constructParams : [];
-        var instance = _construct(Class, [].concat(params));
-        return this.parsePropsAndMethods(instance, item);
+        return Promise.all(params.map(function(param) {
+            return _this.parseBasicType(param);
+        })).then(function(resultParams) {
+            return _construct(Class, [].concat(resultParams));
+        }).then(function(instance) {
+            return _this.parsePropsAndMethods(instance, item);
+        });
     };
     _proto.parsePropsAndMethods = function parsePropsAndMethods(instance, item) {
         var promises = [];
@@ -555,16 +560,14 @@ var ReflectionParser = /*#__PURE__*/ function() {
             for(var methodName in item.methods){
                 var methodParams = item.methods[methodName];
                 for(var i = 0, count = methodParams.length; i < count; i++){
-                    var params = methodParams[i];
-                    var promise = this.parseMethod(instance, methodName, params);
-                    promises.push(promise);
+                    promises.push(this.parseMethod(instance, methodName, methodParams[i]));
                 }
             }
         }
         if (item.props) {
             var _this = this, _loop = function(key) {
                 var value = item.props[key];
-                var promise = _this.parseBasicType(value).then(function(v) {
+                var promise = _this.parseBasicType(value, instance[key]).then(function(v) {
                     return instance[key] = v;
                 });
                 promises.push(promise);
@@ -586,7 +589,7 @@ var ReflectionParser = /*#__PURE__*/ function() {
             return (_instance = instance)[methodName].apply(_instance, [].concat(result));
         });
     };
-    _proto.parseBasicType = function parseBasicType(value) {
+    _proto.parseBasicType = function parseBasicType(value, originValue) {
         var _this = this;
         if (Array.isArray(value)) {
             return Promise.all(value.map(function(item) {
@@ -603,13 +606,33 @@ var ReflectionParser = /*#__PURE__*/ function() {
             } else if (ReflectionParser._isEntityRef(value)) {
                 // entity reference
                 return Promise.resolve(this._context.entityMap.get(value.entityId));
-            } else {
-                // basic type
-                return Promise.resolve(value);
+            } else if (originValue) {
+                var _this1 = this, _loop = function(key) {
+                    if (key === "methods") {
+                        var methods = value[key];
+                        for(var methodName in methods){
+                            var methodParams = methods[methodName];
+                            for(var i = 0, count = methodParams.length; i < count; i++){
+                                var params = methodParams[i];
+                                var promise = _this1.parseMethod(originValue, methodName, params);
+                                promises.push(promise);
+                            }
+                        }
+                    } else {
+                        promises.push(_this1.parseBasicType(value[key], originValue[key]).then(function(v) {
+                            return originValue[key] = v;
+                        }));
+                    }
+                };
+                var promises = [];
+                for(var key in value)_loop(key);
+                return Promise.all(promises).then(function() {
+                    return originValue;
+                });
             }
-        } else {
-            return Promise.resolve(value);
         }
+        // primitive type
+        return Promise.resolve(value);
     };
     _proto._getEntityByConfig = function _getEntityByConfig(entityConfig) {
         // @ts-ignore
@@ -714,6 +737,7 @@ exports.AnimationClipDecoder = /*#__PURE__*/ function() {
                 var componentStr = bufferReader.nextStr();
                 var componentType = ComponentMap[componentStr];
                 var property = bufferReader.nextStr();
+                var getProperty = bufferReader.nextStr();
                 var curve = void 0;
                 var interpolation = bufferReader.nextUint8();
                 var keysLen = bufferReader.nextUint16();
@@ -838,13 +862,42 @@ exports.AnimationClipDecoder = /*#__PURE__*/ function() {
                             for(var j7 = 0; j7 < keysLen; ++j7){
                                 var keyframe8 = new engineCore.Keyframe();
                                 keyframe8.time = bufferReader.nextFloat32();
-                                keyframe8.value = JSON.parse(bufferReader.nextStr());
+                                var str = bufferReader.nextStr();
+                                if (str) {
+                                    keyframe8.value = JSON.parse(str);
+                                } else {
+                                    keyframe8.value = null;
+                                }
                                 curve.addKey(keyframe8);
                             }
                             break;
                         }
+                    case "AnimationBoolCurve":
+                        {
+                            curve = new engineCore.AnimationBoolCurve();
+                            curve.interpolation = interpolation;
+                            for(var j8 = 0; j8 < keysLen; ++j8){
+                                var keyframe9 = new engineCore.Keyframe();
+                                keyframe9.time = bufferReader.nextFloat32();
+                                keyframe9.value = bufferReader.nextUint8() === 1;
+                                curve.addKey(keyframe9);
+                            }
+                            break;
+                        }
+                    case "AnimationStringCurve":
+                        {
+                            curve = new engineCore.AnimationStringCurve();
+                            curve.interpolation = interpolation;
+                            for(var j9 = 0; j9 < keysLen; ++j9){
+                                var keyframe10 = new engineCore.Keyframe();
+                                keyframe10.time = bufferReader.nextFloat32();
+                                keyframe10.value = bufferReader.nextStr();
+                                curve.addKey(keyframe10);
+                            }
+                            break;
+                        }
                 }
-                clip.addCurveBinding(relativePath, componentType, property, curve);
+                clip.addCurveBinding(relativePath, componentType, property, getProperty, curve);
             }
             resolve(clip);
         });
@@ -1098,26 +1151,34 @@ var AnimationClipLoader = /*#__PURE__*/ function(Loader1) {
                     var curveBindingPromises = clip.curveBindings.map(function(curveBinding) {
                         var curve = curveBinding.curve;
                         var promises = curve.keys.map(function(key) {
-                            var value = key.value;
-                            if (typeof value === "object" && value.refId) {
-                                return new Promise(function(resolve) {
-                                    resourceManager// @ts-ignore
-                                    .getResourceByRef(value).then(function(asset) {
-                                        key.value = asset;
-                                        resolve(key);
-                                    }).catch(reject);
-                                });
-                            }
+                            return _this._parseKeyframeValue(key, resourceManager).then(function(actualValue) {
+                                key.value = actualValue;
+                            });
                         });
                         return Promise.all(promises);
                     });
                     return Promise.all(curveBindingPromises).then(function() {
                         resolve(clip);
                     });
-                });
+                }).catch(reject);
             }).catch(reject);
         });
     };
+    _proto._parseKeyframeValue = function _parseKeyframeValue(keyframe, resourceManager) {
+        var _value;
+        var value = keyframe.value;
+        if (typeof value === "object" && ((_value = value) == null ? void 0 : _value.refId)) {
+            return new Promise(function(resolve) {
+                resourceManager// @ts-ignore
+                .getResourceByRef(value).then(function(asset) {
+                    keyframe.value = asset;
+                    resolve(keyframe);
+                });
+            });
+        } else {
+            return Promise.resolve(keyframe.value);
+        }
+    };
     return AnimationClipLoader;
 }(engineCore.Loader);
 AnimationClipLoader = __decorate([
@@ -1393,6 +1454,60 @@ FontLoader = __decorate([
         _this.url = url;
         return _this;
     }
+    var _proto = GLTFResource.prototype;
+    /**
+   * Instantiate scene root entity.
+   * @param sceneIndex - Scene index
+   * @returns Root entity
+   */ _proto.instantiateSceneRoot = function instantiateSceneRoot(sceneIndex) {
+        var sceneRoot = sceneIndex === undefined ? this._defaultSceneRoot : this._sceneRoots[sceneIndex];
+        return sceneRoot.clone();
+    };
+    _proto._onDestroy = function _onDestroy() {
+        ReferResource1.prototype._onDestroy.call(this);
+        var _this = this, textures = _this.textures, materials = _this.materials, meshes = _this.meshes;
+        textures && this._disassociationSuperResource(textures);
+        materials && this._disassociationSuperResource(materials);
+        if (meshes) {
+            for(var i = 0, n = meshes.length; i < n; i++){
+                this._disassociationSuperResource(meshes[i]);
+            }
+        }
+    };
+    _proto._disassociationSuperResource = function _disassociationSuperResource(resources) {
+        for(var i = 0, n = resources.length; i < n; i++){
+            // @ts-ignore
+            resources[i]._disassociationSuperResource(this);
+        }
+    };
+    _create_class(GLTFResource, [
+        {
+            key: "extensionsData",
+            get: /**
+   * Extensions data.
+   */ function get() {
+                return this._extensionsData;
+            }
+        },
+        {
+            key: "sceneRoots",
+            get: /**
+   * @deprecated Please use `instantiateSceneRoot` instead.
+   * RootEntities after SceneParser.
+   */ function get() {
+                return this._sceneRoots;
+            }
+        },
+        {
+            key: "defaultSceneRoot",
+            get: /**
+   * @deprecated Please use `instantiateSceneRoot` instead.
+   * RootEntity after SceneParser.
+   */ function get() {
+                return this._defaultSceneRoot;
+            }
+        }
+    ]);
     return GLTFResource;
 }(engineCore.ReferResource);
 
@@ -1546,12 +1661,29 @@ var TextureWrapMode;
 /**
  * @internal
  */ var GLTFParserContext = /*#__PURE__*/ function() {
-    function GLTFParserContext(glTFResource, resourceManager, keepMeshData) {
+    function GLTFParserContext(glTFResource, resourceManager, params) {
+        var _this = this;
         this.glTFResource = glTFResource;
         this.resourceManager = resourceManager;
-        this.keepMeshData = keepMeshData;
+        this.params = params;
         this.accessorBufferCache = {};
         this._resourceCache = new Map();
+        this._progress = {
+            taskDetail: {},
+            taskComplete: {
+                loaded: 0,
+                total: 0
+            }
+        };
+        this./**
+   * @internal
+   */ _onTaskDetail = function(url, loaded, total) {
+            var _this__progress_taskDetail, _url;
+            var detail = (_this__progress_taskDetail = _this._progress.taskDetail)[_url = url] || (_this__progress_taskDetail[_url] = {});
+            detail.loaded = loaded;
+            detail.total = total;
+            _this._setTaskDetailProgress(url, loaded, total);
+        };
         this.contentRestorer = new GLTFContentRestorer(glTFResource);
     }
     var _proto = GLTFParserContext.prototype;
@@ -1592,7 +1724,7 @@ var TextureWrapMode;
     };
     _proto.parse = function parse() {
         var _this = this;
-        return this.get(0).then(function(json) {
+        var promise = this.get(0).then(function(json) {
             _this.glTF = json;
             return Promise.all([
                 _this.get(1),
@@ -1603,10 +1735,48 @@ var TextureWrapMode;
                 _this.get(9),
                 _this.get(2)
             ]).then(function() {
+                var glTFResource = _this.glTFResource;
+                if (glTFResource.skins || glTFResource.animations) {
+                    _this._createAnimator(_this, glTFResource.animations);
+                }
                 _this.resourceManager.addContentRestorer(_this.contentRestorer);
-                return _this.glTFResource;
+                return glTFResource;
             });
         });
+        this._addTaskCompletePromise(promise);
+        return promise;
+    };
+    /**
+   * @internal
+   */ _proto._addTaskCompletePromise = function _addTaskCompletePromise(taskPromise) {
+        var _this = this;
+        var task = this._progress.taskComplete;
+        task.total += 1;
+        taskPromise.then(function() {
+            _this._setTaskCompleteProgress(++task.loaded, task.total);
+        });
+    };
+    _proto._createAnimator = function _createAnimator(context, animations) {
+        var defaultSceneRoot = context.glTFResource.defaultSceneRoot;
+        var animator = defaultSceneRoot.addComponent(engineCore.Animator);
+        var animatorController = new engineCore.AnimatorController();
+        var layer = new engineCore.AnimatorControllerLayer("layer");
+        var animatorStateMachine = new engineCore.AnimatorStateMachine();
+        animatorController.addLayer(layer);
+        animator.animatorController = animatorController;
+        layer.stateMachine = animatorStateMachine;
+        if (animations) {
+            for(var i = 0; i < animations.length; i++){
+                var animationClip = animations[i];
+                var name = animationClip.name;
+                var uniqueName = animatorStateMachine.makeUniqueStateName(name);
+                if (uniqueName !== name) {
+                    console.warn("AnimatorState name is existed, name: " + name + " reset to " + uniqueName);
+                }
+                var animatorState = animatorStateMachine.addState(uniqueName);
+                animatorState.clip = animationClip;
+            }
+        }
     };
     _proto._handleSubAsset = function _handleSubAsset(resource, type, index) {
         var _this = this;
@@ -1670,7 +1840,7 @@ exports.GLTFParserType = void 0;
 var _obj;
 var glTFSchemaMap = (_obj = {}, _obj[2] = "scenes", _obj[3] = "buffers", _obj[4] = "textures", _obj[5] = "materials", _obj[6] = "meshes", _obj[7] = "nodes", _obj[8] = "skins", _obj[9] = "animations", _obj);
 var _obj1;
-var glTFResourceMap = (_obj1 = {}, _obj1[2] = "sceneRoots", _obj1[4] = "textures", _obj1[5] = "materials", _obj1[6] = "meshes", _obj1[7] = "entities", _obj1[8] = "skins", _obj1[9] = "animations", _obj1);
+var glTFResourceMap = (_obj1 = {}, _obj1[2] = "_sceneRoots", _obj1[4] = "textures", _obj1[5] = "materials", _obj1[6] = "meshes", _obj1[7] = "entities", _obj1[8] = "skins", _obj1[9] = "animations", _obj1);
 function registerGLTFParser(pipeline) {
     return function(Parser) {
         var parser = new Parser();
@@ -2247,7 +2417,7 @@ var SupercompressionScheme;
                 alphaSliceByteLength: sgdReader.nextUint32()
             };
         }
-        var endpointsByteOffset = sgdByteOffset + sgdReader.offset;
+        var endpointsByteOffset = sgdByteOffset + sgdReader.position;
         var selectorsByteOffset = endpointsByteOffset + endpointsByteLength;
         var tablesByteOffset = selectorsByteOffset + selectorsByteLength;
         var extendedByteOffset = tablesByteOffset + tablesByteLength;
@@ -2439,6 +2609,25 @@ var AbstractTranscoder = /*#__PURE__*/ function() {
 }();
 
 /** @internal */ function TranscodeWorkerCode$1() {
+    var initPromise;
+    var init = function init(wasmBinary) {
+        if (!initPromise) {
+            initPromise = new Promise(function(resolve, reject) {
+                var BasisModule = {
+                    wasmBinary: wasmBinary,
+                    onRuntimeInitialized: function() {
+                        return resolve(BasisModule);
+                    },
+                    onAbort: reject
+                };
+                self["BASIS"](BasisModule);
+            }).then(function(BasisModule) {
+                BasisModule.initializeBasis();
+                return BasisModule.KTX2File;
+            });
+        }
+        return initPromise;
+    };
     self.onmessage = function onmessage(event) {
         var message = event.data;
         switch(message.type){
@@ -2565,6 +2754,7 @@ function transcode(buffer, targetFormat, KTX2File) {
     var faceCount = ktx2File.getFaces();
     var format = getTranscodeFormatFromTarget(targetFormat, hasAlpha);
     var faces = new Array(faceCount);
+    var isBC = format === 2 || format === 3 || format === 7;
     for(var face = 0; face < faceCount; face++){
         var mipmaps = new Array(levelCount);
         for(var mip = 0; mip < levelCount; mip++){
@@ -2572,8 +2762,15 @@ function transcode(buffer, targetFormat, KTX2File) {
             var mipWidth = void 0, mipHeight = void 0;
             for(var layer = 0; layer < layerCount; layer++){
                 var levelInfo = ktx2File.getImageLevelInfo(mip, layer, face);
-                mipWidth = levelInfo.origWidth;
-                mipHeight = levelInfo.origHeight;
+                // see: https://github.com/KhronosGroup/KTX-Software/issues/254
+                if (isBC && mip === 0 && (width !== levelInfo.width || height !== levelInfo.height)) {
+                    width = mipWidth = levelInfo.width;
+                    height = mipHeight = levelInfo.height;
+                    console.warn("KTX2 transcode to BC will resize to width: " + width + ", height: " + height + ". You'd better use an image whose size if multiple of 4.");
+                } else {
+                    mipWidth = levelInfo.origWidth;
+                    mipHeight = levelInfo.origHeight;
+                }
                 var dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, layer, 0, format));
                 var status = ktx2File.transcodeImage(dst, mip, layer, face, format, 0, -1, -1);
                 if (!status) {
@@ -2639,7 +2836,7 @@ function transcode(buffer, targetFormat, KTX2File) {
             } else {
                 var funcCode = TranscodeWorkerCode$1.toString();
                 var transcodeString = funcCode.substring(funcCode.indexOf("{"), funcCode.lastIndexOf("}") + 1);
-                var workerCode = "\n        " + jsCode + "\n        var init = (" + _init.toString() + ")();\n        " + transcode.toString() + "\n        " + transcodeString + "\n        ";
+                var workerCode = "\n        " + jsCode + "\n        " + transcode.toString() + "\n        " + transcodeString + "\n        ";
                 var workerURL = URL.createObjectURL(new Blob([
                     workerCode
                 ], {
@@ -2885,10 +3082,14 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
         return Loader1.apply(this, arguments);
     }
     var _proto = KTX2Loader1.prototype;
-    _proto.initialize = function initialize(engine, configuration) {
+    _proto.initialize = function initialize(_, configuration) {
         if (configuration.ktx2Loader) {
             var options = configuration.ktx2Loader;
-            if (this._isKhronosSupported(options.priorityFormats, engine) && options.workerCount !== 0) {
+            if (options.priorityFormats) {
+                exports.KTX2Loader._priorityFormats["etc1s"] = options.priorityFormats;
+                exports.KTX2Loader._priorityFormats["uastc"] = options.priorityFormats;
+            }
+            if (options.transcoder === /** Khronos transcoder. */ 1) {
                 return exports.KTX2Loader._getKhronosTranscoder(options.workerCount).init();
             } else {
                 return exports.KTX2Loader._getBinomialLLCTranscoder(options.workerCount).init();
@@ -2898,34 +3099,16 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
     /**
    * @internal
    */ _proto.load = function load(item, resourceManager) {
-        return this.request(item.url, {
-            type: "arraybuffer"
-        }).then(function(buffer) {
-            return exports.KTX2Loader._parseBuffer(new Uint8Array(buffer), resourceManager.engine, item.params).then(function(param) {
-                var engine = param.engine, result = param.result, targetFormat = param.targetFormat, params = param.params;
-                return exports.KTX2Loader._createTextureByBuffer(engine, result, targetFormat, params);
-            });
-        });
-    };
-    _proto._isKhronosSupported = function _isKhronosSupported(priorityFormats, engine) {
-        if (priorityFormats === void 0) priorityFormats = [
-            exports.KTX2TargetFormat.ASTC,
-            exports.KTX2TargetFormat.ETC,
-            exports.KTX2TargetFormat.BC7,
-            exports.KTX2TargetFormat.BC1_BC3,
-            exports.KTX2TargetFormat.PVRTC,
-            exports.KTX2TargetFormat.R8G8B8A8
-        ];
-        var supportedList = new Array();
-        if (Array.isArray(priorityFormats[0])) {
-            for(var i = 0; i < priorityFormats.length; i++){
-                supportedList.push(exports.KTX2Loader._detectSupportedFormat(engine._hardwareRenderer, priorityFormats[i]));
-            }
-        } else {
-            supportedList.push(exports.KTX2Loader._detectSupportedFormat(engine._hardwareRenderer, priorityFormats));
-        }
-        return supportedList.every(function(format) {
-            return KhronosTranscoder.transcoderMap[format];
+        var _this = this;
+        return new engineCore.AssetPromise(function(resolve, reject, setTaskCompleteProgress, setTaskDetailProgress) {
+            _this.request(item.url, {
+                type: "arraybuffer"
+            }).onProgress(setTaskCompleteProgress, setTaskDetailProgress).then(function(buffer) {
+                return exports.KTX2Loader._parseBuffer(new Uint8Array(buffer), resourceManager.engine, item.params).then(function(param) {
+                    var engine = param.engine, result = param.result, targetFormat = param.targetFormat, params = param.params;
+                    return exports.KTX2Loader._createTextureByBuffer(engine, result, targetFormat, params);
+                });
+            }).then(resolve).catch(reject);
         });
     };
     /**
@@ -2940,7 +3123,8 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
     /** @internal */ KTX2Loader1._parseBuffer = function _parseBuffer(buffer, engine, params) {
         var _params;
         var ktx2Container = new KTX2Container(buffer);
-        var formatPriorities = (_params = params) == null ? void 0 : _params.priorityFormats;
+        var _params_priorityFormats;
+        var formatPriorities = (_params_priorityFormats = (_params = params) == null ? void 0 : _params.priorityFormats) != null ? _params_priorityFormats : exports.KTX2Loader._priorityFormats[ktx2Container.isUASTC ? "uastc" : "etc1s"];
         var targetFormat = exports.KTX2Loader._decideTargetFormat(engine, ktx2Container, formatPriorities);
         var transcodeResultPromise;
         if (exports.KTX2Loader._isBinomialInit || !KhronosTranscoder.transcoderMap[targetFormat] || !ktx2Container.isUASTC) {
@@ -3007,18 +3191,22 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
         return targetFormat;
     };
     KTX2Loader1._detectSupportedFormat = function _detectSupportedFormat(renderer, priorityFormats) {
-        if (priorityFormats === void 0) priorityFormats = [
-            exports.KTX2TargetFormat.ASTC,
-            exports.KTX2TargetFormat.ETC,
-            exports.KTX2TargetFormat.BC7,
-            exports.KTX2TargetFormat.BC1_BC3,
-            exports.KTX2TargetFormat.PVRTC
-        ];
         for(var i = 0; i < priorityFormats.length; i++){
-            var capabilities = this._supportedMap[priorityFormats[i]];
-            for(var j = 0; j < capabilities.length; j++){
-                if (renderer.canIUse(capabilities[j])) {
-                    return priorityFormats[i];
+            var format = priorityFormats[i];
+            var capabilities = this._supportedMap[format];
+            if (capabilities) {
+                for(var j = 0; j < capabilities.length; j++){
+                    if (renderer.canIUse(capabilities[j])) {
+                        return format;
+                    }
+                }
+            } else {
+                switch(priorityFormats[i]){
+                    case exports.KTX2TargetFormat.R8G8B8A8:
+                        return format;
+                    case exports.KTX2TargetFormat.R8:
+                    case exports.KTX2TargetFormat.R8G8:
+                        if (renderer.isWebGL2) return format;
                 }
             }
         }
@@ -3055,6 +3243,23 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
     return KTX2Loader1;
 }(engineCore.Loader), function() {
     _KTX2Loader._isBinomialInit = false;
+}(), function() {
+    _KTX2Loader._priorityFormats = {
+        etc1s: [
+            exports.KTX2TargetFormat.ETC,
+            exports.KTX2TargetFormat.BC7,
+            exports.KTX2TargetFormat.ASTC,
+            exports.KTX2TargetFormat.BC1_BC3,
+            exports.KTX2TargetFormat.PVRTC
+        ],
+        uastc: [
+            exports.KTX2TargetFormat.ASTC,
+            exports.KTX2TargetFormat.BC7,
+            exports.KTX2TargetFormat.ETC,
+            exports.KTX2TargetFormat.BC1_BC3,
+            exports.KTX2TargetFormat.PVRTC
+        ]
+    };
 }(), function() {
     var _obj;
     _KTX2Loader._supportedMap = (_obj = {}, _obj[exports.KTX2TargetFormat.ASTC] = [
@@ -3075,6 +3280,11 @@ exports.KTX2Loader = __decorate([
         "ktx2"
     ])
 ], exports.KTX2Loader);
+exports.KTX2Transcoder = void 0;
+(function(KTX2Transcoder) {
+    KTX2Transcoder[KTX2Transcoder[/** BinomialLLC transcoder. */ "BinomialLLC"] = 0] = "BinomialLLC";
+    KTX2Transcoder[KTX2Transcoder["Khronos"] = 1] = "Khronos";
+})(exports.KTX2Transcoder || (exports.KTX2Transcoder = {}));
 
 /**
  * @internal
@@ -3425,7 +3635,7 @@ exports.GLTFSchemaParser = /*#__PURE__*/ function(GLTFParser1) {
         };
         var isGLB = this._isGLB(url);
         contentRestorer.isGLB = isGLB;
-        var promise = isGLB ? engineCore.request(url, requestConfig).then(function(glb) {
+        var promise = isGLB ? engineCore.request(url, requestConfig).onProgress(undefined, context._onTaskDetail).then(function(glb) {
             restoreBufferRequests.push(new BufferRequestInfo(url, requestConfig));
             return GLTFUtils.parseGLB(context, glb);
         }).then(function(param) {
@@ -3434,7 +3644,7 @@ exports.GLTFSchemaParser = /*#__PURE__*/ function(GLTFParser1) {
             return glTF;
         }) : engineCore.request(url, {
             type: "json"
-        });
+        }).onProgress(undefined, context._onTaskDetail);
         return promise;
     };
     _proto._isGLB = function _isGLB(url) {
@@ -3466,9 +3676,9 @@ exports.GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
    * @internal
    */ GLTFAnimationParser1._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 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)
@@ -3484,8 +3694,8 @@ exports.GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
                     output = scaled;
                 }
                 var outputStride = output.length / input.length;
-                var _gltfSampler_interpolation;
-                var interpolation = (_gltfSampler_interpolation = gltfSampler.interpolation) != null ? _gltfSampler_interpolation : AnimationSamplerInterpolation.Linear;
+                var _glTFSampler_interpolation;
+                var interpolation = (_glTFSampler_interpolation = glTFSampler.interpolation) != null ? _glTFSampler_interpolation : AnimationSamplerInterpolation.Linear;
                 var samplerInterpolation;
                 switch(interpolation){
                     case AnimationSamplerInterpolation.CubicSpine:
@@ -3518,10 +3728,11 @@ exports.GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
         var promises = new Array();
         // parse samplers
         for(var j = 0, m = samplers.length; j < m; j++)_loop(j);
+        promises.push(context.get(exports.GLTFParserType.Scene));
         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 glTFChannel = channels[j];
+                var target = glTFChannel.target;
                 var channelTargetEntity = entities[target.node];
                 var relativePath = "";
                 var entity = channelTargetEntity;
@@ -3529,6 +3740,10 @@ exports.GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
                     relativePath = relativePath === "" ? "" + entity.name : entity.name + "/" + relativePath;
                     entity = entity.parent;
                 }
+                // If the target node is in the default scene, relativePath will be empty
+                if (context.glTFResource.sceneRoots.indexOf(entity) === -1) {
+                    continue;
+                }
                 var ComponentType = void 0;
                 var propertyName = void 0;
                 switch(target.path){
@@ -3549,14 +3764,21 @@ exports.GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
                         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);
+                if (target.path === AnimationChannelTargetPath.WEIGHTS) {
+                    var mesh = glTF.nodes[target.node].mesh;
+                    for(var i = 0, n = glTF.meshes[mesh].primitives.length; i < n; i++){
+                        animationClip.addCurveBinding(relativePath, ComponentType, i, propertyName, curve);
+                    }
+                } else {
+                    animationClip.addCurveBinding(relativePath, ComponentType, propertyName, curve);
+                }
             }
             return animationClip;
         });
     };
-    GLTFAnimationParser1._addCurve = function _addCurve(animationChannelTargetPath, gltfChannel, sampleDataCollection) {
-        var sampleData = sampleDataCollection[gltfChannel.sampler];
+    GLTFAnimationParser1._addCurve = function _addCurve(animationChannelTargetPath, glTFChannel, sampleDataCollection) {
+        var sampleData = sampleDataCollection[glTFChannel.sampler];
         var input = sampleData.input, output = sampleData.output, outputSize = sampleData.outputSize;
         switch(animationChannelTargetPath){
             case AnimationChannelTargetPath.TRANSLATION:
@@ -3648,7 +3870,9 @@ exports.GLTFBufferParser = /*#__PURE__*/ function(GLTFParser1) {
         };
         var absoluteUrl = engineCore.Utils.resolveAbsoluteUrl(url, bufferInfo.uri);
         restoreBufferRequests.push(new BufferRequestInfo(absoluteUrl, requestConfig));
-        return engineCore.request(absoluteUrl, requestConfig);
+        var promise = engineCore.request(absoluteUrl, requestConfig).onProgress(undefined, context._onTaskDetail);
+        context._addTaskCompletePromise(promise);
+        return promise;
     };
     return GLTFBufferParser;
 }(GLTFParser);
@@ -3663,10 +3887,13 @@ exports.GLTFEntityParser = /*#__PURE__*/ function(GLTFParser1) {
     }
     var _proto = GLTFEntityParser.prototype;
     _proto.parse = function parse(context, index) {
+        var glTFResource = context.glTFResource;
         var entityInfo = context.glTF.nodes[index];
-        var engine = context.glTFResource.engine;
+        var engine = glTFResource.engine;
         var matrix = entityInfo.matrix, translation = entityInfo.translation, rotation = entityInfo.rotation, scale = entityInfo.scale, extensions = entityInfo.extensions;
         var entity = new engineCore.Entity(engine, entityInfo.name || "_GLTF_ENTITY_" + index);
+        // @ts-ignore
+        entity._markAsTemplate(glTFResource);
         var transform = entity.transform;
         if (matrix) {
             var localMatrix = transform.localMatrix;
@@ -3708,7 +3935,8 @@ exports.GLTFMaterialParser = /*#__PURE__*/ function(GLTFParser1) {
     var _proto = GLTFMaterialParser1.prototype;
     _proto.parse = function parse(context, index) {
         var materialInfo = context.glTF.materials[index];
-        var engine = context.glTFResource.engine;
+        var glTFResource = context.glTFResource;
+        var engine = glTFResource.engine;
         var material = GLTFParser.executeExtensionsCreateAndParse(materialInfo.extensions, context, materialInfo);
         if (!material) {
             material = new engineCore.PBRMaterial(engine);
@@ -3716,8 +3944,10 @@ exports.GLTFMaterialParser = /*#__PURE__*/ function(GLTFParser1) {
             exports.GLTFMaterialParser._parseStandardProperty(context, material, materialInfo);
         }
         return Promise.resolve(material).then(function(material) {
-            material || (material = exports.GLTFMaterialParser._getDefaultMaterial(context.glTFResource.engine));
+            material || (material = exports.GLTFMaterialParser._getDefaultMaterial(engine));
             GLTFParser.executeExtensionsAdditiveAndParse(materialInfo.extensions, context, material, materialInfo);
+            // @ts-ignore
+            material._associationSuperResource(glTFResource);
             return material;
         });
     };
@@ -3838,14 +4068,20 @@ exports.GLTFMeshParser = (_GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1)
                 var mesh = GLTFParser.executeExtensionsCreateAndParse(gltfPrimitive.extensions, context, gltfPrimitive, meshInfo);
                 if (mesh) {
                     if (_instanceof(mesh, engineCore.ModelMesh)) {
+                        // @ts-ignore
+                        mesh._associationSuperResource(glTFResource);
                         resolve(mesh);
                     } else {
                         mesh.then(function(mesh) {
-                            return resolve(mesh);
+                            // @ts-ignore
+                            mesh._associationSuperResource(glTFResource);
+                            resolve(mesh);
                         });
                     }
                 } else {
                     var mesh1 = new engineCore.ModelMesh(engine, meshInfo.name || i + "");
+                    // @ts-ignore
+                    mesh1._associationSuperResource(glTFResource);
                     var meshRestoreInfo = new ModelMeshRestoreInfo();
                     meshRestoreInfo.mesh = mesh1;
                     context.contentRestorer.meshes.push(meshRestoreInfo);
@@ -3865,12 +4101,13 @@ exports.GLTFMeshParser = (_GLTFMeshParser = /*#__PURE__*/ function(GLTFParser1)
                         return context.get(exports.GLTFParserType.Buffer).then(function(buffers) {
                             return GLTFUtils.getAccessorData(glTF, indexAccessor, buffers);
                         });
-                    }, context.keepMeshData).then(resolve);
+                    }, context.params.keepMeshData).then(resolve);
                 }
             });
         };
         var meshInfo = context.glTF.meshes[index];
-        var glTF = context.glTF, engine = context.glTFResource.engine;
+        var glTF = context.glTF, glTFResource = context.glTFResource;
+        var engine = glTFResource.engine;
         var primitivePromises = new Array();
         for(var i = 0, length = meshInfo.primitives.length; i < length; i++)_loop(i);
         return Promise.all(primitivePromises);
@@ -4043,9 +4280,9 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
     }
     var _proto = GLTFSceneParser.prototype;
     _proto.parse = function parse(context, index) {
-        var _this = this;
         var _context_glTF = context.glTF, scenes = _context_glTF.scenes, _context_glTF_scene = _context_glTF.scene, scene = _context_glTF_scene === void 0 ? 0 : _context_glTF_scene, glTFResource = context.glTFResource;
         var sceneInfo = scenes[index];
+        var sceneExtensions = sceneInfo.extensions;
         var engine = glTFResource.engine;
         var isDefaultScene = scene === index;
         var sceneNodes = sceneInfo.nodes;
@@ -4059,30 +4296,15 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
                 sceneRoot.addChild(childEntity);
             }
         }
-        // @ts-ignore
-        sceneRoot._hookResource = glTFResource;
-        // @ts-ignore
-        glTFResource._addReferCount(1);
         if (isDefaultScene) {
-            glTFResource.defaultSceneRoot = sceneRoot;
+            glTFResource._defaultSceneRoot = sceneRoot;
         }
         var promises = new Array();
         for(var i1 = 0; i1 < sceneNodes.length; i1++){
             promises.push(this._parseEntityComponent(context, sceneNodes[i1]));
         }
         return Promise.all(promises).then(function() {
-            if (isDefaultScene) {
-                return Promise.all([
-                    context.get(exports.GLTFParserType.Skin),
-                    context.get(exports.GLTFParserType.Animation)
-                ]).then(function(param) {
-                    var skins = param[0], animations = param[1];
-                    if (skins || animations) {
-                        _this._createAnimator(context, animations);
-                    }
-                    return sceneRoot;
-                });
-            }
+            GLTFParser.executeExtensionsAdditiveAndParse(sceneExtensions, context, sceneRoot, sceneInfo);
             return sceneRoot;
         });
     };
@@ -4194,28 +4416,6 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
         for(var i = 0; i < glTFMeshPrimitives.length; i++)_loop(i);
         return Promise.all(promises);
     };
-    _proto._createAnimator = function _createAnimator(context, animations) {
-        var defaultSceneRoot = context.glTFResource.defaultSceneRoot;
-        var animator = defaultSceneRoot.addComponent(engineCore.Animator);
-        var animatorController = new engineCore.AnimatorController();
-        var layer = new engineCore.AnimatorControllerLayer("layer");
-        var animatorStateMachine = new engineCore.AnimatorStateMachine();
-        animatorController.addLayer(layer);
-        animator.animatorController = animatorController;
-        layer.stateMachine = animatorStateMachine;
-        if (animations) {
-            for(var i = 0; i < animations.length; i++){
-                var animationClip = animations[i];
-                var name = animationClip.name;
-                var uniqueName = animatorStateMachine.makeUniqueStateName(name);
-                if (uniqueName !== name) {
-                    console.warn("AnimatorState name is existed, name: " + name + " reset to " + uniqueName);
-                }
-                var animatorState = animatorStateMachine.addState(uniqueName);
-                animatorState.clip = animationClip;
-            }
-        }
-    };
     _proto._computeLocalBounds = function _computeLocalBounds(skinnedMeshRenderer, mesh, bones, rootBone, inverseBindMatrices) {
         var rootBoneIndex = bones.indexOf(rootBone);
         if (rootBoneIndex !== -1) {
@@ -4364,11 +4564,12 @@ exports.GLTFTextureParser = (_GLTFTextureParser = /*#__PURE__*/ function(GLTFPar
                     params: {
                         mipmap: (_samplerInfo = samplerInfo) == null ? void 0 : _samplerInfo.mipmap
                     }
-                }).then(function(texture) {
+                }).onProgress(undefined, context._onTaskDetail).then(function(texture) {
                     texture.name = textureName || imageName || texture.name || "texture_" + index;
                     useSampler && GLTFUtils.parseSampler(texture, samplerInfo);
                     return texture;
                 });
+                context._addTaskCompletePromise(texture);
             } else {
                 var bufferView = glTF.bufferViews[bufferViewIndex];
                 texture = context.get(exports.GLTFParserType.Buffer).then(function(buffers) {
@@ -4390,6 +4591,8 @@ exports.GLTFTextureParser = (_GLTFTextureParser = /*#__PURE__*/ function(GLTFPar
         }
         return Promise.resolve(texture).then(function(texture) {
             GLTFParser.executeExtensionsAdditiveAndParse(extensions, context, texture, textureInfo);
+            // @ts-ignore
+            texture._associationSuperResource(glTFResource);
             return texture;
         });
     };
@@ -4447,12 +4650,17 @@ var GLTFLoader = /*#__PURE__*/ function(Loader1) {
     }
     var _proto = GLTFLoader.prototype;
     _proto.load = function load(item, resourceManager) {
-        var _params;
         var url = item.url;
         var params = item.params;
         var glTFResource = new GLTFResource(resourceManager.engine, url);
-        var context = new GLTFParserContext(glTFResource, resourceManager, !!((_params = params) == null ? void 0 : _params.keepMeshData));
-        return context.parse();
+        var context = new GLTFParserContext(glTFResource, resourceManager, _extends({
+            keepMeshData: false
+        }, params));
+        return new engineCore.AssetPromise(function(resolve, reject, setTaskCompleteProgress, setTaskDetailProgress) {
+            context._setTaskCompleteProgress = setTaskCompleteProgress;
+            context._setTaskDetailProgress = setTaskDetailProgress;
+            context.parse().then(resolve).catch(reject);
+        });
     };
     return GLTFLoader;
 }(engineCore.Loader);
@@ -5099,6 +5307,12 @@ var MaterialLoader = /*#__PURE__*/ function(Loader1) {
                                 materialShaderData.setTexture(key, texture);
                             }));
                             break;
+                        case "Boolean":
+                            materialShaderData.setInt(key, value ? 1 : 0);
+                            break;
+                        case "Integer":
+                            materialShaderData.setInt(key, Number(value));
+                            break;
                     }
                 };
                 var engine = resourceManager.engine;
@@ -5219,7 +5433,7 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader1) {
     var _proto = SpriteAtlasLoader.prototype;
     _proto.load = function load(item, resourceManager) {
         var _this = this;
-        return new engineCore.AssetPromise(function(resolve, reject, _, onCancel) {
+        return new engineCore.AssetPromise(function(resolve, reject, _, __, onCancel) {
             var chainPromises = [];
             onCancel(function() {
                 for(var i = 0; i < chainPromises.length; i++){
@@ -5234,9 +5448,10 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader1) {
                 var _loop = function(i) {
                     var atlasItem = atlasItems[i];
                     if (atlasItem.img) {
+                        var _atlasItem_type;
                         chainPromises.push(resourceManager.load({
                             url: engineCore.Utils.resolveAbsoluteUrl(item.url, atlasItem.img),
-                            type: engineCore.AssetType.Texture2D,
+                            type: (_atlasItem_type = atlasItem.type) != null ? _atlasItem_type : engineCore.AssetType.Texture2D,
                             params: {
                                 format: format,
                                 mipmap: mipmap
@@ -5366,15 +5581,19 @@ var Texture2DLoader = /*#__PURE__*/ function(Loader1) {
     var _proto = Texture2DLoader.prototype;
     _proto.load = function load(item, resourceManager) {
         var _this = this;
-        return new engineCore.AssetPromise(function(resolve, reject) {
+        return new engineCore.AssetPromise(function(resolve, reject, setTaskCompleteProgress, setTaskDetailProgress) {
             var url = item.url;
             var requestConfig = _extends({}, item, {
                 type: "image"
             });
-            _this.request(url, requestConfig).then(function(image) {
-                var _params, _params1;
-                var params = item.params;
-                var texture = new engineCore.Texture2D(resourceManager.engine, image.width, image.height, (_params = params) == null ? void 0 : _params.format, (_params1 = params) == null ? void 0 : _params1.mipmap);
+            _this.request(url, requestConfig).onProgress(setTaskCompleteProgress, setTaskDetailProgress).then(function(image) {
+                var _item_params;
+                var _ref = (_item_params = item.params) != null ? _item_params : {}, format = _ref.format, mipmap = _ref.mipmap, anisoLevel = _ref.anisoLevel, wrapModeU = _ref.wrapModeU, wrapModeV = _ref.wrapModeV, filterMode = _ref.filterMode;
+                var texture = new engineCore.Texture2D(resourceManager.engine, image.width, image.height, format, mipmap);
+                texture.anisoLevel = anisoLevel != null ? anisoLevel : texture.anisoLevel;
+                texture.filterMode = filterMode != null ? filterMode : texture.filterMode;
+                texture.wrapModeU = wrapModeU != null ? wrapModeU : texture.wrapModeU;
+                texture.wrapModeV = wrapModeV != null ? wrapModeV : texture.wrapModeV;
                 texture.setImageSource(image);
                 texture.generateMipmaps();
                 if (url.indexOf("data:") !== 0) {
@@ -5522,33 +5741,34 @@ var SceneLoader = /*#__PURE__*/ function(Loader1) {
                     var promises = [];
                     // parse ambient light
                     var ambient = data.scene.ambient;
-                    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 {
+                    if (ambient) {
+                        var useCustomAmbient = ambient.specularMode === "Custom";
+                        var useSH = ambient.diffuseMode === engineCore.DiffuseMode.SphericalHarmonics;
                         scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
                         scene.ambientLight.specularIntensity = ambient.specularIntensity;
+                        scene.ambientLight.diffuseMode = ambient.diffuseMode;
                         scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
+                        scene.ambientLight.specularTextureDecodeRGBM = true;
+                        if (useCustomAmbient && ambient.customAmbientLight) {
+                            promises.push(// @ts-ignore
+                            resourceManager.getResourceByRef(ambient.customAmbientLight).then(function(ambientLight) {
+                                var _ambientLight;
+                                scene.ambientLight.specularTexture = (_ambientLight = ambientLight) == null ? void 0 : _ambientLight.specularTexture;
+                            }));
+                        }
+                        if (ambient.ambientLight && (!useCustomAmbient || useSH)) {
+                            promises.push(// @ts-ignore
+                            resourceManager.getResourceByRef(ambient.ambientLight).then(function(ambientLight) {
+                                if (!useCustomAmbient) {
+                                    var _ambientLight;
+                                    scene.ambientLight.specularTexture = (_ambientLight = ambientLight) == null ? void 0 : _ambientLight.specularTexture;
+                                }
+                                if (useSH) {
+                                    var _ambientLight1;
+                                    scene.ambientLight.diffuseSphericalHarmonics = (_ambientLight1 = ambientLight) == null ? void 0 : _ambientLight1.diffuseSphericalHarmonics;
+                                }
+                            }));
+                        }
                     }
                     var background = data.scene.background;
                     scene.background.mode = background.mode;
@@ -5590,6 +5810,9 @@ var SceneLoader = /*#__PURE__*/ function(Loader1) {
                         if (shadow.shadowResolution != undefined) scene.shadowResolution = shadow.shadowResolution;
                         if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
                         if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
+                        var _shadow_shadowTwoCascadeSplits;
+                        scene.shadowTwoCascadeSplits = (_shadow_shadowTwoCascadeSplits = shadow.shadowTwoCascadeSplits) != null ? _shadow_shadowTwoCascadeSplits : scene.shadowTwoCascadeSplits;
+                        shadow.shadowFourCascadeSplits && scene.shadowFourCascadeSplits.copyFrom(shadow.shadowFourCascadeSplits);
                     }
                     return Promise.all(promises).then(function() {
                         resolve(scene);
@@ -5605,13 +5828,13 @@ SceneLoader = __decorate([
         "scene"
     ], true)
 ], SceneLoader);
-ReflectionParser.registerCustomParseComponent("TextRenderer", /*#__PURE__*/ _async_to_generator(function(instance, item, engine) {
+ReflectionParser.registerCustomParseComponent("TextRenderer", /*#__PURE__*/ _async_to_generator(function(instance, item) {
     var props;
     return __generator(this, function(_state) {
         props = item.props;
         if (!props.font) {
             // @ts-ignore
-            instance.font = engineCore.Font.createFromOS(engine, props.fontFamily || "Arial");
+            instance.font = engineCore.Font.createFromOS(instance.engine, props.fontFamily || "Arial");
         }
         return [
             2,
@@ -5667,7 +5890,7 @@ var KHR_draco_mesh_compression = (_KHR_draco_mesh_compression = /*#__PURE__*/ fu
                     throw "BlendShape animation is not supported when using draco.";
                 }, function() {
                     return decodedGeometry.index.array;
-                }, context.keepMeshData);
+                }, context.params.keepMeshData);
             });
         });
     };
@@ -5958,7 +6181,7 @@ var KHR_materials_variants = /*#__PURE__*/ function(GLTFExtensionParser1) {
         var _glTFResource;
         var _context_glTF = context.glTF, _context_glTF_extensions = _context_glTF.extensions, _context_glTF_extensions_KHR_materials_variants = _context_glTF_extensions.KHR_materials_variants, variantNames = _context_glTF_extensions_KHR_materials_variants.variants, glTFResource = context.glTFResource;
         var mappings = schema.mappings;
-        (_glTFResource = glTFResource).extensionsData || (_glTFResource.extensionsData = {});
+        (_glTFResource = glTFResource)._extensionsData || (_glTFResource._extensionsData = {});
         var extensionData = [];
         glTFResource.extensionsData.variants = extensionData;
         for(var i = 0; i < mappings.length; i++)_loop(i);
@@ -5988,7 +6211,7 @@ var KHR_texture_basisu = /*#__PURE__*/ function(GLTFExtensionParser1) {
     var _proto = KHR_texture_basisu.prototype;
     _proto.createAndParse = function createAndParse(context, schema, textureInfo) {
         return _async_to_generator(function() {
-            var glTF, glTFResource, engine, url, sampler, textureName, source, _glTF_images_source, uri, bufferViewIndex, mimeType, imageName, samplerInfo, index, bufferView;
+            var glTF, glTFResource, engine, url, sampler, textureName, source, _glTF_images_source, uri, bufferViewIndex, mimeType, imageName, samplerInfo, index, promise, bufferView;
             return __generator(this, function(_state) {
                 glTF = context.glTF, glTFResource = context.glTFResource;
                 engine = glTFResource.engine, url = glTFResource.url;
@@ -5998,20 +6221,22 @@ var KHR_texture_basisu = /*#__PURE__*/ function(GLTFExtensionParser1) {
                 samplerInfo = sampler !== undefined && GLTFUtils.getSamplerInfo(glTF.samplers[sampler]);
                 if (uri) {
                     index = uri.lastIndexOf(".");
+                    promise = engine.resourceManager.load({
+                        url: engineCore.Utils.resolveAbsoluteUrl(url, uri),
+                        type: engineCore.AssetType.KTX2
+                    }).onProgress(undefined, context._onTaskDetail).then(function(texture) {
+                        if (!texture.name) {
+                            texture.name = textureName || imageName || "texture_" + index;
+                        }
+                        if (sampler !== undefined) {
+                            GLTFUtils.parseSampler(texture, samplerInfo);
+                        }
+                        return texture;
+                    });
+                    context._addTaskCompletePromise(promise);
                     return [
                         2,
-                        engine.resourceManager.load({
-                            url: engineCore.Utils.resolveAbsoluteUrl(url, uri),
-                            type: engineCore.AssetType.KTX2
-                        }).then(function(texture) {
-                            if (!texture.name) {
-                                texture.name = textureName || imageName || "texture_" + index;
-                            }
-                            if (sampler !== undefined) {
-                                GLTFUtils.parseSampler(texture, samplerInfo);
-                            }
-                            return texture;
-                        })
+                        promise
                     ];
                 } else {
                     bufferView = glTF.bufferViews[bufferViewIndex];
@@ -6081,7 +6306,9 @@ var GALACEAN_materials_remap = /*#__PURE__*/ function(GLTFExtensionParser1) {
     _proto.createAndParse = function createAndParse(context, schema) {
         var engine = context.glTFResource.engine;
         // @ts-ignore
-        return engine.resourceManager.getResourceByRef(schema);
+        var promise = engine.resourceManager.getResourceByRef(schema);
+        context._addTaskCompletePromise(promise);
+        return promise;
     };
     return GALACEAN_materials_remap;
 }(GLTFExtensionParser);
@@ -6112,6 +6339,29 @@ GALACEAN_animation_event = __decorate([
     registerGLTFExtension("GALACEAN_animation_event", exports.GLTFExtensionMode.AdditiveParse)
 ], GALACEAN_animation_event);
 
+var KHR_materials_anisotropy = /*#__PURE__*/ function(GLTFExtensionParser1) {
+    _inherits(KHR_materials_anisotropy, GLTFExtensionParser1);
+    function KHR_materials_anisotropy() {
+        return GLTFExtensionParser1.apply(this, arguments);
+    }
+    var _proto = KHR_materials_anisotropy.prototype;
+    _proto.additiveParse = function additiveParse(context, material, schema) {
+        var _schema_anisotropyStrength = schema.anisotropyStrength, anisotropyStrength = _schema_anisotropyStrength === void 0 ? 0 : _schema_anisotropyStrength, _schema_anisotropyRotation = schema.anisotropyRotation, anisotropyRotation = _schema_anisotropyRotation === void 0 ? 0 : _schema_anisotropyRotation, anisotropyTexture = schema.anisotropyTexture;
+        material.anisotropy = anisotropyStrength;
+        material.anisotropyRotation = anisotropyRotation;
+        if (anisotropyTexture) {
+            exports.GLTFMaterialParser._checkOtherTextureTransform(anisotropyTexture, "Anisotropy texture");
+            context.get(exports.GLTFParserType.Texture, anisotropyTexture.index).then(function(texture) {
+                material.anisotropyTexture = texture;
+            });
+        }
+    };
+    return KHR_materials_anisotropy;
+}(GLTFExtensionParser);
+KHR_materials_anisotropy = __decorate([
+    registerGLTFExtension("KHR_materials_anisotropy", exports.GLTFExtensionMode.AdditiveParse)
+], KHR_materials_anisotropy);
+
 exports.ComponentMap = ComponentMap;
 exports.GLTFExtensionParser = GLTFExtensionParser;
 exports.GLTFParser = GLTFParser;