@galacean/engine-loader 1.1.0-beta.2 → 1.1.0-beta.20

package/dist/miniprogram.js

@@ -121,116 +121,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 miniprogram.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;
             }
         }
     ]);
@@ -294,75 +294,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 miniprogram.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);
@@ -373,9 +372,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);
             }
@@ -528,12 +527,12 @@ function _construct(Parent, args, Class) {
 }
 
 var ReflectionParser = /*#__PURE__*/ function() {
-    function ReflectionParser() {}
-    ReflectionParser.registerCustomParseComponent = function registerCustomParseComponent(componentType, handle) {
-        this.customParseComponentHandles[componentType] = handle;
-    };
-    ReflectionParser.parseEntity = function parseEntity(entityConfig, engine) {
-        return ReflectionParser.getEntityByConfig(entityConfig, engine).then(function(entity) {
+    function ReflectionParser(_context) {
+        this._context = _context;
+    }
+    var _proto = ReflectionParser.prototype;
+    _proto.parseEntity = function parseEntity(entityConfig) {
+        return this._getEntityByConfig(entityConfig).then(function(entity) {
             var _entityConfig_isActive;
             entity.isActive = (_entityConfig_isActive = entityConfig.isActive) != null ? _entityConfig_isActive : true;
             var position = entityConfig.position, rotation = entityConfig.rotation, scale = entityConfig.scale;
@@ -543,72 +542,33 @@ var ReflectionParser = /*#__PURE__*/ function() {
             return entity;
         });
     };
-    ReflectionParser.getEntityByConfig = function getEntityByConfig(entityConfig, engine) {
-        // @ts-ignore
-        var assetRefId = entityConfig.assetRefId;
-        if (assetRefId) {
-            return engine.resourceManager// @ts-ignore
-            .getResourceByRef({
-                refId: assetRefId,
-                key: entityConfig.key,
-                isClone: entityConfig.isClone
-            }).then(function(entity) {
-                entity.name = entityConfig.name;
-                return entity;
-            });
-        } else {
-            var entity = new miniprogram.Entity(engine, entityConfig.name);
-            return Promise.resolve(entity);
-        }
-    };
-    ReflectionParser.parseClassObject = function parseClassObject(item, engine, resourceManager) {
-        if (resourceManager === void 0) resourceManager = engine.resourceManager;
+    _proto.parseClassObject = function parseClassObject(item) {
+        var _this = this;
         var Class = miniprogram.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, engine, resourceManager);
-    };
-    ReflectionParser.parseBasicType = function parseBasicType(value, engine, resourceManager) {
-        if (resourceManager === void 0) resourceManager = engine.resourceManager;
-        var _this = this;
-        if (Array.isArray(value)) {
-            return Promise.all(value.map(function(item) {
-                return _this.parseBasicType(item, engine, resourceManager);
-            }));
-        } else if (typeof value === "object" && value != null) {
-            if (this._isClass(value)) {
-                // class object
-                return this.parseClassObject(value, engine, resourceManager);
-            } else if (this._isRef(value)) {
-                // reference object
-                return resourceManager.getResourceByRef(value);
-            } else {
-                // basic type
-                return Promise.resolve(value);
-            }
-        } else {
-            return Promise.resolve(value);
-        }
+        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);
+        });
     };
-    ReflectionParser.parsePropsAndMethods = function parsePropsAndMethods(instance, item, engine, resourceManager) {
-        if (resourceManager === void 0) resourceManager = engine.resourceManager;
-        var _this = this;
+    _proto.parsePropsAndMethods = function parsePropsAndMethods(instance, item) {
         var promises = [];
         if (item.methods) {
             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, engine, resourceManager);
-                    promises.push(promise);
+                    promises.push(this.parseMethod(instance, methodName, methodParams[i]));
                 }
             }
         }
         if (item.props) {
-            var _this1 = this, _loop = function(key) {
+            var _this = this, _loop = function(key) {
                 var value = item.props[key];
-                var promise = _this1.parseBasicType(value, engine).then(function(v) {
+                var promise = _this.parseBasicType(value, instance[key]).then(function(v) {
                     return instance[key] = v;
                 });
                 promises.push(promise);
@@ -616,27 +576,96 @@ var ReflectionParser = /*#__PURE__*/ function() {
             for(var key in item.props)_loop(key);
         }
         return Promise.all(promises).then(function() {
-            var handle = _this.customParseComponentHandles[instance.constructor.name];
-            if (handle) return handle(instance, item, engine);
+            var handle = ReflectionParser.customParseComponentHandles[instance.constructor.name];
+            if (handle) return handle(instance, item);
             else return instance;
         });
     };
-    ReflectionParser.parseMethod = function parseMethod(instance, methodName, methodParams, engine, resourceManager) {
-        if (resourceManager === void 0) resourceManager = engine.resourceManager;
+    _proto.parseMethod = function parseMethod(instance, methodName, methodParams) {
         var _this = this;
         return Promise.all(methodParams.map(function(param) {
-            return _this.parseBasicType(param, engine, resourceManager);
+            return _this.parseBasicType(param);
         })).then(function(result) {
             var _instance;
             return (_instance = instance)[methodName].apply(_instance, [].concat(result));
         });
     };
+    _proto.parseBasicType = function parseBasicType(value, originValue) {
+        var _this = this;
+        if (Array.isArray(value)) {
+            return Promise.all(value.map(function(item) {
+                return _this.parseBasicType(item);
+            }));
+        } else if (typeof value === "object" && value != null) {
+            if (ReflectionParser._isClass(value)) {
+                // class object
+                return this.parseClassObject(value);
+            } else if (ReflectionParser._isAssetRef(value)) {
+                // reference object
+                // @ts-ignore
+                return this._context.resourceManager.getResourceByRef(value);
+            } else if (ReflectionParser._isEntityRef(value)) {
+                // entity reference
+                return Promise.resolve(this._context.entityMap.get(value.entityId));
+            } 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;
+                });
+            }
+        }
+        // primitive type
+        return Promise.resolve(value);
+    };
+    _proto._getEntityByConfig = function _getEntityByConfig(entityConfig) {
+        // @ts-ignore
+        var assetRefId = entityConfig.assetRefId;
+        var engine = this._context.engine;
+        if (assetRefId) {
+            return engine.resourceManager// @ts-ignore
+            .getResourceByRef({
+                refId: assetRefId,
+                key: entityConfig.key,
+                isClone: entityConfig.isClone
+            }).then(function(entity) {
+                entity.name = entityConfig.name;
+                return entity;
+            });
+        } else {
+            var entity = new miniprogram.Entity(engine, entityConfig.name);
+            return Promise.resolve(entity);
+        }
+    };
+    ReflectionParser.registerCustomParseComponent = function registerCustomParseComponent(componentType, handle) {
+        this.customParseComponentHandles[componentType] = handle;
+    };
     ReflectionParser._isClass = function _isClass(value) {
         return value["class"] != undefined;
     };
-    ReflectionParser._isRef = function _isRef(value) {
+    ReflectionParser._isAssetRef = function _isAssetRef(value) {
         return value["refId"] != undefined;
     };
+    ReflectionParser._isEntityRef = function _isEntityRef(value) {
+        return value["entityId"] != undefined;
+    };
     return ReflectionParser;
 }();
 (function() {
@@ -904,6 +933,8 @@ var SceneParserContext = /*#__PURE__*/ function() {
         this.assets = new Map();
         this.entityConfigMap = new Map();
         this.rootIds = [];
+        this.engine = scene.engine;
+        this.resourceManager = scene.engine.resourceManager;
     }
     var _proto = SceneParserContext.prototype;
     _proto.destroy = function destroy() {
@@ -920,7 +951,7 @@ var SceneParserContext = /*#__PURE__*/ function() {
     function SceneParser(context) {
         var _this = this;
         this.context = context;
-        this._engine = this.context.scene.engine;
+        this._engine = context.scene.engine;
         this._organizeEntities = this._organizeEntities.bind(this);
         this._parseComponents = this._parseComponents.bind(this);
         this._clearAndResolveScene = this._clearAndResolveScene.bind(this);
@@ -928,22 +959,24 @@ var SceneParserContext = /*#__PURE__*/ function() {
             _this._reject = reject;
             _this._resolve = resolve;
         });
+        this._reflectionParser = new ReflectionParser(context);
     }
     var _proto = SceneParser.prototype;
     /** start parse the scene */ _proto.start = function start() {
         this._parseEntities().then(this._organizeEntities).then(this._parseComponents).then(this._clearAndResolveScene).then(this._resolve).catch(this._reject);
     };
     _proto._parseEntities = function _parseEntities() {
+        var _this = this;
         var entitiesConfig = this.context.originalData.entities;
         var entityConfigMap = this.context.entityConfigMap;
         var entitiesMap = this.context.entityMap;
         var rootIds = this.context.rootIds;
-        var engine = this._engine;
+        this._engine;
         var promises = entitiesConfig.map(function(entityConfig) {
             entityConfigMap.set(entityConfig.id, entityConfig);
             // record root entities
             if (!entityConfig.parent) rootIds.push(entityConfig.id);
-            return ReflectionParser.parseEntity(entityConfig, engine);
+            return _this._reflectionParser.parseEntity(entityConfig);
         });
         return Promise.all(promises).then(function(entities) {
             for(var i = 0, l = entities.length; i < l; i++){
@@ -981,7 +1014,7 @@ var SceneParserContext = /*#__PURE__*/ function() {
                     component = entity.getComponent(miniprogram.Loader.getClass(key));
                 }
                 component = component || entity.addComponent(miniprogram.Loader.getClass(key));
-                var promise = ReflectionParser.parsePropsAndMethods(component, componentConfig, entity.engine);
+                var promise = this._reflectionParser.parsePropsAndMethods(component, componentConfig);
                 promises.push(promise);
             }
         }
@@ -1537,10 +1570,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);
@@ -1594,11 +1627,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(miniprogram.Animator);
+        var animatorController = new miniprogram.AnimatorController();
+        var layer = new miniprogram.AnimatorControllerLayer("layer");
+        var animatorStateMachine = new miniprogram.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];
@@ -2238,7 +2297,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;
@@ -2430,6 +2489,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){
@@ -2544,6 +2622,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;
@@ -2552,6 +2634,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++){
@@ -2559,8 +2642,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) {
@@ -2626,7 +2716,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 = engineMiniprogramAdapter.URL.createObjectURL(new engineMiniprogramAdapter.Blob([
                     workerCode
                 ], {
@@ -2875,6 +2965,7 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
     _proto.initialize = function initialize(engine, configuration) {
         if (configuration.ktx2Loader) {
             var options = configuration.ktx2Loader;
+            if (options.priorityFormats) exports.KTX2Loader._priorityFormats = options.priorityFormats;
             if (this._isKhronosSupported(options.priorityFormats, engine) && options.workerCount !== 0) {
                 return exports.KTX2Loader._getKhronosTranscoder(options.workerCount).init();
             } else {
@@ -2895,25 +2986,7 @@ 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];
-        });
+        return !!KhronosTranscoder.transcoderMap[exports.KTX2Loader._detectSupportedFormat(engine._hardwareRenderer, priorityFormats)];
     };
     /**
    * Destroy ktx2 transcoder worker.
@@ -2927,7 +3000,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;
         var targetFormat = exports.KTX2Loader._decideTargetFormat(engine, ktx2Container, formatPriorities);
         var transcodeResultPromise;
         if (exports.KTX2Loader._isBinomialInit || !KhronosTranscoder.transcoderMap[targetFormat] || !ktx2Container.isUASTC) {
@@ -2994,18 +3068,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;
                 }
             }
         }
@@ -3042,6 +3120,14 @@ exports.KTX2Loader = (_KTX2Loader = /*#__PURE__*/ function(Loader1) {
     return KTX2Loader1;
 }(miniprogram.Loader), function() {
     _KTX2Loader._isBinomialInit = false;
+}(), function() {
+    _KTX2Loader._priorityFormats = [
+        exports.KTX2TargetFormat.BC7,
+        exports.KTX2TargetFormat.ASTC,
+        exports.KTX2TargetFormat.BC1_BC3,
+        exports.KTX2TargetFormat.ETC,
+        exports.KTX2TargetFormat.PVRTC
+    ];
 }(), function() {
     var _obj;
     _KTX2Loader._supportedMap = (_obj = {}, _obj[exports.KTX2TargetFormat.ASTC] = [
@@ -3505,6 +3591,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];
@@ -3516,6 +3603,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){
@@ -3596,12 +3687,12 @@ exports.GLTFAnimationParser = /*#__PURE__*/ function(GLTFParser1) {
                         if (curve2.interpolation === miniprogram.InterpolationType.CubicSpine) {
                             keyframe2.inTangent = Array.from(output.subarray(offset2, offset2 + outputSize));
                             offset2 += outputSize;
-                            keyframe2.value = output.subarray(offset2, offset2 + outputSize);
+                            keyframe2.value = output.slice(offset2, offset2 + outputSize);
                             offset2 += outputSize;
                             keyframe2.outTangent = Array.from(output.subarray(offset2, offset2 + outputSize));
                             offset2 += outputSize;
                         } else {
-                            keyframe2.value = output.subarray(offset2, offset2 + outputSize);
+                            keyframe2.value = output.slice(offset2, offset2 + outputSize);
                             offset2 += outputSize;
                         }
                         curve2.addKey(keyframe2);
@@ -3852,7 +3943,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);
                 }
             });
         };
@@ -4030,9 +4121,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;
@@ -4058,18 +4149,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;
         });
     };
@@ -4181,28 +4261,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(miniprogram.Animator);
-        var animatorController = new miniprogram.AnimatorController();
-        var layer = new miniprogram.AnimatorControllerLayer("layer");
-        var animatorStateMachine = new miniprogram.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) {
@@ -4352,8 +4410,7 @@ exports.GLTFTextureParser = (_GLTFTextureParser = /*#__PURE__*/ function(GLTFPar
                         mipmap: (_samplerInfo = samplerInfo) == null ? void 0 : _samplerInfo.mipmap
                     }
                 }).then(function(texture) {
-                    var _texture;
-                    (_texture = texture).name || (_texture.name = textureName || imageName || "texture_" + index);
+                    texture.name = textureName || imageName || texture.name || "texture_" + index;
                     useSampler && GLTFUtils.parseSampler(texture, samplerInfo);
                     return texture;
                 });
@@ -4435,11 +4492,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;
@@ -5087,6 +5145,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;
@@ -5222,9 +5286,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: miniprogram.Utils.resolveAbsoluteUrl(item.url, atlasItem.img),
-                            type: miniprogram.AssetType.Texture2D,
+                            type: (_atlasItem_type = atlasItem.type) != null ? _atlasItem_type : miniprogram.AssetType.Texture2D,
                             params: {
                                 format: format,
                                 mipmap: mipmap
@@ -5460,6 +5525,39 @@ TextureCubeLoader = __decorate([
     ])
 ], TextureCubeLoader);
 
+var ProjectLoader = /*#__PURE__*/ function(Loader1) {
+    _inherits(ProjectLoader, Loader1);
+    function ProjectLoader() {
+        return Loader1.apply(this, arguments);
+    }
+    var _proto = ProjectLoader.prototype;
+    _proto.load = function load(item, resourceManager) {
+        var _this = this;
+        var engine = resourceManager.engine;
+        return new miniprogram.AssetPromise(function(resolve, reject) {
+            _this.request(item.url, {
+                type: "json"
+            }).then(function(data) {
+                // @ts-ignore
+                engine.resourceManager.initVirtualResources(data.files);
+                return resourceManager.load({
+                    type: miniprogram.AssetType.Scene,
+                    url: data.scene
+                }).then(function(scene) {
+                    engine.sceneManager.activeScene = scene;
+                    resolve();
+                });
+            }).catch(reject);
+        });
+    };
+    return ProjectLoader;
+}(miniprogram.Loader);
+ProjectLoader = __decorate([
+    miniprogram.resourceLoader(miniprogram.AssetType.Project, [
+        "proj"
+    ], false)
+], ProjectLoader);
+
 var SceneLoader = /*#__PURE__*/ function(Loader1) {
     _inherits(SceneLoader, Loader1);
     function SceneLoader() {
@@ -5477,33 +5575,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 === miniprogram.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;
@@ -5560,13 +5659,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 = miniprogram.Font.createFromOS(engine, props.fontFamily || "Arial");
+            instance.font = miniprogram.Font.createFromOS(instance.engine, props.fontFamily || "Arial");
         }
         return [
             2,
@@ -5622,7 +5721,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);
             });
         });
     };