@galacean/engine-loader 1.1.0-beta.5 → 1.1.0-beta.50

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);
             }
@@ -539,15 +538,23 @@ var ReflectionParser = /*#__PURE__*/ function() {
             if (position) entity.transform.position.copyFrom(position);
             if (rotation) entity.transform.rotation.copyFrom(rotation);
             if (scale) entity.transform.scale.copyFrom(scale);
+            var _entityConfig_layer;
+            entity.layer = (_entityConfig_layer = entityConfig.layer) != null ? _entityConfig_layer : entity.layer;
             return entity;
         });
     };
     _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 +562,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 +591,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 +608,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
@@ -1546,10 +1571,10 @@ var TextureWrapMode;
 /**
  * @internal
  */ var GLTFParserContext = /*#__PURE__*/ function() {
-    function GLTFParserContext(glTFResource, resourceManager, keepMeshData) {
+    function GLTFParserContext(glTFResource, resourceManager, params) {
         this.glTFResource = glTFResource;
         this.resourceManager = resourceManager;
-        this.keepMeshData = keepMeshData;
+        this.params = params;
         this.accessorBufferCache = {};
         this._resourceCache = new Map();
         this.contentRestorer = new GLTFContentRestorer(glTFResource);
@@ -1603,11 +1628,37 @@ 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;
             });
         });
     };
+    _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;
         var glTFResourceKey = glTFResourceMap[type];
@@ -1775,7 +1826,9 @@ function registerGLTFParser(pipeline) {
     };
     GLTFUtils.getAccessorBuffer = function getAccessorBuffer(context, bufferViews, accessor) {
         var componentType = accessor.componentType;
-        var bufferView = bufferViews[accessor.bufferView];
+        var _accessor_bufferView;
+        var bufferViewIndex = (_accessor_bufferView = accessor.bufferView) != null ? _accessor_bufferView : 0;
+        var bufferView = bufferViews[bufferViewIndex];
         return context.get(exports.GLTFParserType.Buffer).then(function(buffers) {
             var bufferIndex = bufferView.buffer;
             var buffer = buffers[bufferIndex];
@@ -1793,7 +1846,7 @@ function registerGLTFParser(pipeline) {
             // 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 bufferCacheKey = bufferViewIndex + ":" + componentType + ":" + bufferSlice + ":" + accessorCount;
                 var accessorBufferCache = context.accessorBufferCache;
                 bufferInfo = accessorBufferCache[bufferCacheKey];
                 if (!bufferInfo) {
@@ -1832,7 +1885,8 @@ function registerGLTFParser(pipeline) {
    * Get accessor data.
    */ GLTFUtils.getAccessorData = function getAccessorData(glTF, accessor, buffers) {
         var bufferViews = glTF.bufferViews;
-        var bufferView = bufferViews[accessor.bufferView];
+        var _accessor_bufferView;
+        var bufferView = bufferViews[(_accessor_bufferView = accessor.bufferView) != null ? _accessor_bufferView : 0];
         var arrayBuffer = buffers[bufferView.buffer];
         var accessorByteOffset = accessor.hasOwnProperty("byteOffset") ? accessor.byteOffset : 0;
         var bufferViewByteOffset = bufferView.hasOwnProperty("byteOffset") ? bufferView.byteOffset : 0;
@@ -2009,7 +2063,7 @@ function registerGLTFParser(pipeline) {
     };
     /**
    * Parse the glb format.
-   */ GLTFUtils.parseGLB = function parseGLB(context, glb) {
+   */ GLTFUtils.parseGLB = function parseGLB(context, originBuffer) {
         var UINT32_LENGTH = 4;
         var GLB_HEADER_MAGIC = 0x46546c67; // 'glTF'
         var GLB_HEADER_LENGTH = 12;
@@ -2017,7 +2071,7 @@ function registerGLTFParser(pipeline) {
             JSON: 0x4e4f534a,
             BIN: 0x004e4942
         };
-        var dataView = new DataView(glb);
+        var dataView = new DataView(originBuffer);
         // read header
         var header = {
             magic: dataView.getUint32(0, true),
@@ -2025,8 +2079,9 @@ function registerGLTFParser(pipeline) {
             length: dataView.getUint32(2 * UINT32_LENGTH, true)
         };
         if (header.magic !== GLB_HEADER_MAGIC) {
-            console.error("Invalid glb magic number. Expected 0x46546C67, found 0x" + header.magic.toString(16));
-            return null;
+            return {
+                originBuffer: originBuffer
+            };
         }
         // read main data
         var chunkLength = dataView.getUint32(GLB_HEADER_LENGTH, true);
@@ -2036,7 +2091,7 @@ function registerGLTFParser(pipeline) {
             console.error("Invalid glb chunk type. Expected 0x4E4F534A, found 0x" + chunkType.toString(16));
             return null;
         }
-        var glTFData = new Uint8Array(glb, GLB_HEADER_LENGTH + 2 * UINT32_LENGTH, chunkLength);
+        var glTFData = new Uint8Array(originBuffer, GLB_HEADER_LENGTH + 2 * UINT32_LENGTH, chunkLength);
         var glTF = JSON.parse(engineCore.Utils.decodeText(glTFData));
         // read all buffers
         var buffers = [];
@@ -2050,7 +2105,7 @@ function registerGLTFParser(pipeline) {
                 return null;
             }
             var currentOffset = byteOffset + 2 * UINT32_LENGTH;
-            var buffer = glb.slice(currentOffset, currentOffset + chunkLength);
+            var buffer = originBuffer.slice(currentOffset, currentOffset + chunkLength);
             buffers.push(buffer);
             restoreGLBBufferSlice.push(new engineMath.Vector2(currentOffset, chunkLength));
             byteOffset += chunkLength + 2 * UINT32_LENGTH;
@@ -2247,7 +2302,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 +2494,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){
@@ -2553,6 +2627,10 @@ function transcode(buffer, targetFormat, KTX2File) {
         cleanup();
         throw new Error("Invalid or unsupported .ktx2 file");
     }
+    if (!ktx2File.startTranscoding()) {
+        cleanup();
+        throw new Error("KTX2 startTranscoding failed");
+    }
     var width = ktx2File.getWidth();
     var height = ktx2File.getHeight();
     var layerCount = ktx2File.getLayers() || 1;
@@ -2561,6 +2639,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++){
@@ -2568,8 +2647,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) {
@@ -2635,7 +2721,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
                 ], {
@@ -2881,10 +2967,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();
@@ -2903,27 +2993,6 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
             });
         });
     };
-    _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];
-        });
-    };
     /**
    * Destroy ktx2 transcoder worker.
    */ KTX2Loader1.destroy = function destroy() {
@@ -2936,7 +3005,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) {
@@ -3003,18 +3073,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;
                 }
             }
         }
@@ -3051,6 +3125,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] = [
@@ -3071,6 +3162,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
@@ -3419,23 +3515,20 @@ exports.GLTFSchemaParser = /*#__PURE__*/ function(GLTFParser1) {
         var requestConfig = {
             type: "arraybuffer"
         };
-        var isGLB = this._isGLB(url);
-        contentRestorer.isGLB = isGLB;
-        var promise = isGLB ? engineCore.request(url, requestConfig).then(function(glb) {
+        return engineCore.request(url, requestConfig).then(function(buffer) {
             restoreBufferRequests.push(new BufferRequestInfo(url, requestConfig));
-            return GLTFUtils.parseGLB(context, glb);
-        }).then(function(param) {
-            var glTF = param.glTF, buffers = param.buffers;
-            context.buffers = buffers;
-            return glTF;
-        }) : engineCore.request(url, {
-            type: "json"
+            return GLTFUtils.parseGLB(context, buffer);
+        }).then(function(result) {
+            var _result;
+            if ((_result = result) == null ? void 0 : _result.glTF) {
+                contentRestorer.isGLB = true;
+                context.buffers = result.buffers;
+                return result.glTF;
+            } else {
+                contentRestorer.isGLB = false;
+                return JSON.parse(engineCore.Utils.decodeText(new Uint8Array(result.originBuffer)));
+            }
         });
-        return promise;
-    };
-    _proto._isGLB = function _isGLB(url) {
-        var index = url.lastIndexOf(".");
-        return url.substring(index + 1, index + 4) === "glb";
     };
     return GLTFSchemaParser;
 }(GLTFParser);
@@ -3514,6 +3607,7 @@ 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];
@@ -3525,6 +3619,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){
@@ -3861,7 +3959,7 @@ 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);
                 }
             });
         };
@@ -4039,9 +4137,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;
@@ -4067,18 +4165,7 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
             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;
         });
     };
@@ -4190,28 +4277,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) {
@@ -4443,11 +4508,12 @@ 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));
+        var context = new GLTFParserContext(glTFResource, resourceManager, _extends({
+            keepMeshData: false
+        }, params));
         return context.parse();
     };
     return GLTFLoader;
@@ -5095,6 +5161,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;
@@ -5230,9 +5302,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
@@ -5272,7 +5345,7 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader1) {
     };
     _proto._makeSprite = function _makeSprite(engine, config, texture) {
         // Generate a SpriteAtlas object.
-        var region = config.region, atlasRegionOffset = config.atlasRegionOffset, atlasRegion = config.atlasRegion, pivot = config.pivot, border = config.border;
+        var region = config.region, atlasRegionOffset = config.atlasRegionOffset, atlasRegion = config.atlasRegion, pivot = config.pivot, border = config.border, width = config.width, height = config.height;
         var sprite = new engineCore.Sprite(engine, texture, region ? this._tempRect.set(region.x, region.y, region.w, region.h) : undefined, pivot ? this._tempVec2.set(pivot.x, pivot.y) : undefined, border ? this._tempVec4.set(border.x, border.y, border.z, border.w) : undefined, config.name);
         if (texture) {
             var invW = 1 / texture.width;
@@ -5284,6 +5357,8 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader1) {
             }
             config.atlasRotated && (sprite.atlasRotated = true);
         }
+        isNaN(width) || (sprite.width = width);
+        isNaN(height) || (sprite.height = height);
         return sprite;
     };
     return SpriteAtlasLoader;
@@ -5302,26 +5377,39 @@ var SpriteLoader = /*#__PURE__*/ function(Loader1) {
     var _proto = SpriteLoader.prototype;
     _proto.load = function load(item, resourceManager) {
         var _this = this;
-        return new engineCore.AssetPromise(function(resolve, reject) {
-            _this.request(item.url, _extends({}, item, {
-                type: "json"
-            })).then(function(data) {
-                if (data.belongToAtlas) {
-                    resourceManager// @ts-ignore
-                    .getResourceByRef(data.belongToAtlas).then(function(atlas) {
-                        resolve(atlas.getSprite(data.fullPath));
-                    }).catch(reject);
-                } else if (data.texture) {
-                    resourceManager// @ts-ignore
-                    .getResourceByRef(data.texture).then(function(texture) {
-                        resolve(new engineCore.Sprite(resourceManager.engine, texture, data.region, data.pivot, data.border));
-                    }).catch(reject);
-                } else {
-                    resolve(new engineCore.Sprite(resourceManager.engine, null, data.region, data.pivot, data.border));
-                }
-            }).catch(reject);
+        return this.request(item.url, _extends({}, item, {
+            type: "json"
+        })).then(function(data) {
+            return data.belongToAtlas ? _this._loadFromAtlas(resourceManager, data) : _this._loadFromTexture(resourceManager, data);
+        });
+    };
+    _proto._loadFromAtlas = function _loadFromAtlas(resourceManager, data) {
+        var _this = this;
+        return resourceManager// @ts-ignore
+        .getResourceByRef(data.belongToAtlas).then(function(atlas) {
+            return atlas.getSprite(data.fullPath) || _this._loadFromTexture(resourceManager, data);
         });
     };
+    _proto._loadFromTexture = function _loadFromTexture(resourceManager, data) {
+        if (data.texture) {
+            return resourceManager// @ts-ignore
+            .getResourceByRef(data.texture).then(function(texture) {
+                var sprite = new engineCore.Sprite(resourceManager.engine, texture, data.region, data.pivot, data.border);
+                var width = data.width, height = data.height;
+                isNaN(width) || (sprite.width = width);
+                isNaN(height) || (sprite.height = height);
+                return sprite;
+            });
+        } else {
+            return new engineCore.AssetPromise(function(resolve) {
+                var sprite = new engineCore.Sprite(resourceManager.engine, null, data.region, data.pivot, data.border);
+                var width = data.width, height = data.height;
+                isNaN(width) || (sprite.width = width);
+                isNaN(height) || (sprite.height = height);
+                resolve(sprite);
+            });
+        }
+    };
     return SpriteLoader;
 }(engineCore.Loader);
 SpriteLoader = __decorate([
@@ -5368,9 +5456,13 @@ var Texture2DLoader = /*#__PURE__*/ function(Loader1) {
                 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);
+                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) {
@@ -5498,7 +5590,7 @@ var ProjectLoader = /*#__PURE__*/ function(Loader1) {
 ProjectLoader = __decorate([
     engineCore.resourceLoader(engineCore.AssetType.Project, [
         "proj"
-    ], true)
+    ], false)
 ], ProjectLoader);
 
 var SceneLoader = /*#__PURE__*/ function(Loader1) {
@@ -5518,33 +5610,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;
@@ -5586,6 +5679,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);
@@ -5601,13 +5697,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,
@@ -5663,7 +5759,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);
             });
         });
     };