@galacean/engine 2.0.0-alpha.29 → 2.0.0-alpha.30

package/dist/browser.js

@@ -28278,7 +28278,7 @@
     BasicResources._maskReadOutsideRenderStates = null;
     BasicResources._maskWriteIncrementRenderStates = null;
     BasicResources._maskWriteDecrementRenderStates = null;
-    function _is_native_reflect_construct$1() {
+    function _is_native_reflect_construct() {
         // Since Reflect.construct can't be properly polyfilled, some
         // implementations (e.g. core-js@2) don't set the correct internal slots.
         // Those polyfills don't allow us to subclass built-ins, so we need to
@@ -28288,14 +28288,14 @@
             //   TypeError: this is not a Boolean object.
             var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
         } catch (_) {}
-        return (_is_native_reflect_construct$1 = function _is_native_reflect_construct() {
+        return (_is_native_reflect_construct = function _is_native_reflect_construct() {
             return !!result;
         })();
     }
-    function _construct$1(Parent, args, Class) {
-        if (_is_native_reflect_construct$1()) _construct$1 = Reflect.construct;
+    function _construct(Parent, args, Class) {
+        if (_is_native_reflect_construct()) _construct = Reflect.construct;
         else {
-            _construct$1 = function construct(Parent, args, Class) {
+            _construct = function construct(Parent, args, Class) {
                 var a = [
                     null
                 ];
@@ -28306,7 +28306,7 @@
                 return instance;
             };
         }
-        return _construct$1.apply(null, arguments);
+        return _construct.apply(null, arguments);
     }
     var ComponentCloner = /*#__PURE__*/ function() {
         function ComponentCloner() {}
@@ -28359,7 +28359,7 @@
                 args[_key - 1] = arguments[_key];
             }
             ComponentsDependencies._addCheck(this, type);
-            var component = _construct$1(type, [].concat([
+            var component = _construct(type, [].concat([
                 this
             ], args));
             this._components.push(component);
@@ -28518,7 +28518,7 @@
             for(var i = 0, n = components.length; i < n; i++){
                 componentConstructors[i] = components[i].constructor;
             }
-            var cloneEntity = _construct$1(Entity, [].concat([
+            var cloneEntity = _construct(Entity, [].concat([
                 this.engine,
                 this.name
             ], componentConstructors));
@@ -39766,30 +39766,48 @@
                 }
                 this._emitBySubBurst(middleTime, playTime, duration);
             } else {
-                this._emitBySubBurst(lastPlayTime, playTime, duration);
+                if (lastPlayTime < duration) {
+                    this._emitBySubBurst(lastPlayTime, Math.min(playTime, duration), duration);
+                }
             }
         };
         _proto._emitBySubBurst = function _emitBySubBurst(lastPlayTime, playTime, duration) {
-            var generator = this._generator;
-            var rand = this._burstRand;
-            var bursts = this.bursts;
-            // Calculate the relative time of the burst
+            var _this = this, generator = _this._generator, rand = _this._burstRand, bursts = _this.bursts;
             var baseTime = Math.floor(lastPlayTime / duration) * duration;
             var startTime = lastPlayTime % duration;
             var endTime = startTime + (playTime - lastPlayTime);
+            var pendingIndex = -1;
             var index = this._currentBurstIndex;
             for(var n = bursts.length; index < n; index++){
                 var burst = bursts[index];
                 var burstTime = burst.time;
-                if (burstTime > endTime) {
-                    break;
-                }
-                if (burstTime >= startTime) {
-                    var count = burst.count.evaluate(undefined, rand.random());
-                    generator._emit(baseTime + burstTime, count);
+                if (burstTime >= endTime) break;
+                var cycles = burst.cycles, repeatInterval = burst.repeatInterval;
+                if (cycles === 1) {
+                    if (burstTime >= startTime) {
+                        generator._emit(baseTime + burstTime, burst.count.evaluate(undefined, rand.random()));
+                    }
+                } else {
+                    var maxCycles = cycles === Infinity ? Math.ceil((duration - burstTime) / repeatInterval) : cycles;
+                    // Absorb float drift: (startTime - burstTime) / repeatInterval may land at cycle + 1e-15
+                    // when it should be exactly cycle, and ceil would then skip ahead to cycle + 1.
+                    var tolerance = MathUtil.zeroTolerance;
+                    var lastCycle = Math.ceil((endTime - burstTime) / repeatInterval - tolerance) - 1;
+                    var first = Math.max(0, Math.ceil((startTime - burstTime) / repeatInterval - tolerance));
+                    var last = Math.min(maxCycles - 1, lastCycle);
+                    for(var c = first; c <= last; c++){
+                        var effectiveTime = burstTime + c * repeatInterval;
+                        if (effectiveTime >= duration) break;
+                        generator._emit(baseTime + effectiveTime, burst.count.evaluate(undefined, rand.random()));
+                    }
+                    // `_currentBurstIndex` caches next frame's scan start, so only the earliest unfinished
+                    // burst can be the entry point — skipping past it would drop its remaining cycles
+                    if (pendingIndex < 0 && lastCycle < maxCycles - 1) {
+                        pendingIndex = index;
+                    }
                 }
             }
-            this._currentBurstIndex = index;
+            this._currentBurstIndex = pendingIndex >= 0 ? pendingIndex : index;
         };
         _create_class$2(EmissionModule, [
             {
@@ -42922,10 +42940,39 @@
     }(EffectMaterial);
     /**
      * A burst is a particle emission event, where a number of particles are all emitted at the same time
-     */ var Burst = function Burst(time, count) {
-        this.time = time;
-        this.count = count;
-    };
+     */ var Burst = /*#__PURE__*/ function() {
+        function Burst(time, count, cycles, repeatInterval) {
+            this.time = time;
+            this.count = count;
+            this._cycles = Math.max(cycles != null ? cycles : 1, 1);
+            this._repeatInterval = Math.max(repeatInterval != null ? repeatInterval : 0.01, 0.01);
+        }
+        _create_class$2(Burst, [
+            {
+                key: "cycles",
+                get: /**
+       * Number of times to repeat the burst.
+       */ function get() {
+                    return this._cycles;
+                },
+                set: function set(value) {
+                    this._cycles = Math.max(value, 1);
+                }
+            },
+            {
+                key: "repeatInterval",
+                get: /**
+       * Time interval between each repeated burst.
+       */ function get() {
+                    return this._repeatInterval;
+                },
+                set: function set(value) {
+                    this._repeatInterval = Math.max(value, 0.01);
+                }
+            }
+        ]);
+        return Burst;
+    }();
     __decorate$1([
         deepClone
     ], Burst.prototype, "count", void 0);
@@ -48301,35 +48348,23 @@
         }
         return array;
     }
-    function _is_native_reflect_construct() {
-        // Since Reflect.construct can't be properly polyfilled, some
-        // implementations (e.g. core-js@2) don't set the correct internal slots.
-        // Those polyfills don't allow us to subclass built-ins, so we need to
-        // use our fallback implementation.
-        try {
-            // If the internal slots aren't set, this throws an error similar to
-            //   TypeError: this is not a Boolean object.
-            var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-        } catch (_) {}
-        return (_is_native_reflect_construct = function _is_native_reflect_construct() {
-            return !!result;
-        })();
+    function _object_without_properties_loose(source, excluded) {
+        if (source == null) return {};
+        var target = {};
+        var sourceKeys = Object.keys(source);
+        var key, i;
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            target[key] = source[key];
+        }
+        return target;
     }
-    function _construct(Parent, args, Class) {
-        if (_is_native_reflect_construct()) _construct = Reflect.construct;
-        else {
-            _construct = function construct(Parent, args, Class) {
-                var a = [
-                    null
-                ];
-                a.push.apply(a, args);
-                var Constructor = Function.bind.apply(Parent, a);
-                var instance = new Constructor();
-                if (Class) _set_prototype_of(instance, Class.prototype);
-                return instance;
-            };
+    function resolveRefItem(refs, index, owner, label) {
+        if (!Number.isInteger(index) || index < 0 || index >= refs.length) {
+            throw new Error(owner + ": invalid ref index " + index + " for " + label);
         }
-        return _construct.apply(null, arguments);
+        return refs[index];
     }
     var ParserType = /*#__PURE__*/ function(ParserType) {
         ParserType[ParserType["Prefab"] = 0] = "Prefab";
@@ -48344,32 +48379,20 @@
             this.engine = engine;
             this.type = type;
             this.resource = resource;
-            this.entityMap = new Map();
-            this.entityConfigMap = new Map();
-            this.components = new Map();
-            this.componentConfigMap = new Map();
-            this.rootIds = [];
-            this.strippedIds = [];
-            this._tasks = new Set();
+            this./** Runtime Entity instances, indexed by the flat entities[] position. */ entityInstances = [];
+            this./** Components waiting for props/calls application (Stage 4). */ pendingComponents = [];
             this._loaded = 0;
             this._total = 0;
             this.resourceManager = engine.resourceManager;
         }
         var _proto = ParserContext.prototype;
         _proto.clear = function clear() {
-            this.entityMap.clear();
-            this.components.clear();
-            this.componentConfigMap.clear();
-            this.entityConfigMap.clear();
-            this.rootIds.length = 0;
-            this.strippedIds.length = 0;
-        };
-        /** @internal */ _proto._addDependentAsset = function _addDependentAsset(url, promise) {
+            this.entityInstances.length = 0;
+            this.pendingComponents.length = 0;
+        };
+        /** @internal */ _proto._addDependentAsset = function _addDependentAsset(promise) {
             var _this = this;
-            var tasks = this._tasks;
-            if (tasks.has(url)) return;
             ++this._total;
-            tasks.add(url);
             promise.finally(function() {
                 ++_this._loaded;
                 _this._setTaskCompleteProgress(_this._loaded, _this._total);
@@ -48378,230 +48401,198 @@
         return ParserContext;
     }();
     var ReflectionParser = /*#__PURE__*/ function() {
-        function ReflectionParser(_context) {
+        function ReflectionParser(_context, _refs) {
             this._context = _context;
+            this._refs = _refs;
         }
         var _proto = ReflectionParser.prototype;
-        _proto.parseEntity = function parseEntity(entityConfig) {
-            var _this = this;
-            return this._getEntityByConfig(entityConfig).then(function(entity) {
-                var _entityConfig_isActive;
-                entity.isActive = (_entityConfig_isActive = entityConfig.isActive) != null ? _entityConfig_isActive : true;
-                var transform = entity.transform;
-                var transformConfig = entityConfig.transform;
-                if (transformConfig) {
-                    _this.parsePropsAndMethods(transform, transformConfig);
-                } else {
-                    var position = entityConfig.position, rotation = entityConfig.rotation, scale = entityConfig.scale;
-                    if (position) transform.position.copyFrom(position);
-                    if (rotation) transform.rotation.copyFrom(rotation);
-                    if (scale) transform.scale.copyFrom(scale);
-                }
-                var _entityConfig_layer;
-                entity.layer = (_entityConfig_layer = entityConfig.layer) != null ? _entityConfig_layer : entity.layer;
-                // @ts-ignore
-                _this._context.type === ParserType.Prefab && entity._markAsTemplate(_this._context.resource);
-                return entity;
-            });
-        };
-        _proto.parseClassObject = function parseClassObject(item) {
-            var _this = this;
-            var Class = Loader.getClass(item.class);
-            var _item_constructParams;
-            var params = (_item_constructParams = item.constructParams) != null ? _item_constructParams : [];
-            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) {
+        /**
+       * Apply v2 props to a component/object instance.
+       * Each prop value is resolved recursively (handling $ref, $type, $entity, $component, $signal).
+       */ _proto.parseProps = function parseProps(instance, props) {
             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++){
-                        promises.push(this.parseMethod(instance, methodName, methodParams[i]));
-                    }
-                }
-            }
-            if (item.props) {
+            if (props) {
                 var _this, _loop = function _loop(key) {
-                    var value = item.props[key];
-                    var promise = _this.parseBasicType(value, instance[key]).then(function(v) {
-                        return instance[key] = v;
+                    var promise = _this._resolveValue(props[key], instance[key]).then(function(v) {
+                        instance[key] = v;
                     });
                     promises.push(promise);
                 };
-                for(var key in item.props)_this = this, _loop(key);
+                for(var key in props)_this = this, _loop(key);
             }
             return Promise.all(promises).then(function() {
                 return instance;
             });
         };
-        _proto.parseMethod = function parseMethod(instance, methodName, methodParams) {
+        /**
+       * Execute calls sequentially on a target instance.
+       * Call args are resolved with the same v2 value rules as props.
+       */ _proto.parseCalls = function parseCalls(instance, calls) {
+            var _loop = function _loop(i, n) {
+                var call = calls[i];
+                chain = chain.then(function() {
+                    var method = instance == null ? void 0 : instance[call.method];
+                    if (typeof method !== "function") {
+                        return Promise.reject(new Error('Call target does not have method "' + call.method + '"'));
+                    }
+                    var _call_args;
+                    return Promise.all(((_call_args = call.args) != null ? _call_args : []).map(function(arg) {
+                        return _this._resolveValue(arg);
+                    })).then(function(resolvedArgs) {
+                        return Promise.resolve(method.apply(instance, resolvedArgs));
+                    }).then(function(result) {
+                        if (!call.result) return result;
+                        if (result == null || (typeof result === "undefined" ? "undefined" : _type_of1(result)) !== "object" && typeof result !== "function") {
+                            return Promise.reject(new Error('Call "' + call.method + '" returned ' + result + " and cannot be mutated by result"));
+                        }
+                        return _this.parseMutationBlock(result, call.result);
+                    });
+                });
+            };
             var _this = this;
-            var isMethodObject = ReflectionParser._isMethodObject(methodParams);
-            var params = isMethodObject ? methodParams.params : methodParams;
-            return Promise.all(params.map(function(param) {
-                return _this.parseBasicType(param);
-            })).then(function(result) {
-                var _instance;
-                var methodResult = (_instance = instance)[methodName].apply(_instance, [].concat(result));
-                if (isMethodObject && methodParams.result) {
-                    return _this.parsePropsAndMethods(methodResult, methodParams.result);
-                } else {
-                    return methodResult;
-                }
+            if (!(calls == null ? void 0 : calls.length)) return Promise.resolve(instance);
+            var chain = Promise.resolve();
+            for(var i = 0, n = calls.length; i < n; i++)_loop(i);
+            return chain.then(function() {
+                return instance;
             });
         };
-        _proto.parseSignal = function parseSignal(signalRef) {
-            var _this = this;
-            var signal = new Signal();
-            return Promise.all(signalRef.listeners.map(function(listener) {
-                return Promise.all([
-                    _this.parseBasicType(listener.target),
-                    listener.arguments ? Promise.all(listener.arguments.map(function(a) {
-                        return _this.parseBasicType(a);
-                    })) : Promise.resolve([])
-                ]).then(function(param) {
-                    var target = param[0], resolvedArgs = param[1];
-                    if (target) {
-                        var _signal;
-                        (_signal = signal).on.apply(_signal, [].concat([
-                            target,
-                            listener.methodName
-                        ], resolvedArgs));
-                    }
-                });
-            })).then(function() {
-                return signal;
+        /**
+       * Apply props and calls from the same mutation block without imposing ordering between them.
+       */ _proto.parseMutationBlock = function parseMutationBlock(target, block) {
+            if (!block) return Promise.resolve(target);
+            return Promise.all([
+                this.parseProps(target, block.props),
+                this.parseCalls(target, block.calls)
+            ]).then(function() {
+                return target;
             });
         };
-        _proto.parseBasicType = function parseBasicType(value, originValue) {
-            var _this = this;
-            if (Array.isArray(value)) {
-                return Promise.all(value.map(function(item) {
-                    return _this.parseBasicType(item);
+        /**
+       * Resolve a v2 value with $ prefix detection.
+       *
+       * Priority:
+       * 1. null/undefined/primitive → passthrough
+       * 2. Array → recurse each element
+       * 3. { $ref }       → asset reference
+       * 4. { $type }      → polymorphic type construct
+       * 5. { $entity }    → entity reference by path (flat index + optional children descent)
+       * 6. { $component } → component reference
+       * 7. { $signal }    → signal binding
+       * 8. plain object   → recurse values (modify originValue in place if exists)
+       */ _proto._resolveValue = function _resolveValue(value, originValue) {
+            var _this, _loop = function _loop(key) {
+                promises.push(_this._resolveValue(obj[key], target[key]).then(function(v) {
+                    return target[key] = v;
                 }));
-            } else if ((typeof value === "undefined" ? "undefined" : _type_of1(value)) === "object" && value != null) {
-                if (ReflectionParser._isClassType(value)) {
-                    return Promise.resolve(Loader.getClass(value["classType"]));
-                } else if (ReflectionParser._isClass(value)) {
-                    // class object
-                    return this.parseClassObject(value);
-                } else if (ReflectionParser._isAssetRef(value)) {
-                    var _this1 = this, context = _this1._context;
-                    // reference object
-                    // @ts-ignore
-                    return context.resourceManager.getResourceByRef(value).then(function(resource) {
-                        if (resource && context.type === ParserType.Prefab) {
-                            // @ts-ignore
-                            context.resource._addDependenceAsset(resource);
-                        }
-                        return resource;
-                    });
-                } else if (ReflectionParser._isComponentRef(value)) {
-                    var entity = this._resolveEntityByPath(value.entityPath);
-                    if (!entity) return Promise.resolve(null);
-                    var type = Loader.getClass(value.componentType);
-                    if (!type) return Promise.resolve(null);
-                    var _entity_getComponents_value_componentIndex;
-                    return Promise.resolve((_entity_getComponents_value_componentIndex = entity.getComponents(type, [])[value.componentIndex]) != null ? _entity_getComponents_value_componentIndex : null);
-                } else if (ReflectionParser._isEntityRef(value)) {
-                    return Promise.resolve(this._resolveEntityByPath(value.entityPath));
-                } else if (ReflectionParser._isSignalRef(value)) {
-                    return this.parseSignal(value);
-                } else if (originValue) {
-                    var _this2, _loop = function _loop(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 = _this2.parseMethod(originValue, methodName, params);
-                                    promises.push(promise);
-                                }
-                            }
-                        } else {
-                            promises.push(_this2.parseBasicType(value[key], originValue[key]).then(function(v) {
-                                return originValue[key] = v;
-                            }));
-                        }
-                    };
-                    var promises = [];
-                    for(var key in value)_this2 = this, _loop(key);
-                    return Promise.all(promises).then(function() {
-                        return originValue;
-                    });
+            };
+            var _this1 = this;
+            if (value == null || (typeof value === "undefined" ? "undefined" : _type_of1(value)) !== "object") return Promise.resolve(value);
+            if (Array.isArray(value)) return Promise.all(value.map(function(v) {
+                return _this1._resolveValue(v);
+            }));
+            var obj = value;
+            // $ref — asset reference (index into refs array)
+            if ("$ref" in obj) {
+                var _this2 = this, context = _this2._context;
+                var refItem;
+                try {
+                    refItem = resolveRefItem(this._refs, obj.$ref, "ReflectionParser", "$ref");
+                } catch (error) {
+                    return Promise.reject(error);
                 }
-            }
-            // primitive type
-            return Promise.resolve(value);
-        };
-        _proto._getEntityByConfig = function _getEntityByConfig(entityConfig) {
-            var _this = this;
-            // @ts-ignore
-            var assetUrl = entityConfig.assetUrl;
-            var engine = this._context.engine;
-            if (assetUrl) {
-                return engine.resourceManager // @ts-ignore
-                .getResourceByRef({
-                    url: assetUrl,
-                    key: entityConfig.key,
-                    isClone: entityConfig.isClone
-                }).then(function(entity) {
-                    // @ts-ignore
-                    var resource = engine.resourceManager._objectPool[assetUrl];
-                    if (resource && _this._context.type === ParserType.Prefab) {
+                // @ts-ignore
+                return context.resourceManager.getResourceByRef(refItem).then(function(resource) {
+                    if (resource && context.type === ParserType.Prefab) {
                         // @ts-ignore
-                        _this._context.resource._addDependenceAsset(resource);
+                        context.resource._addDependenceAsset(resource);
                     }
-                    entity.name = entityConfig.name;
-                    return entity;
+                    return resource;
                 });
-            } else {
-                var transform = entityConfig.transform;
-                var entity = new Entity(engine, entityConfig.name, transform ? Loader.getClass(transform.class) : Transform);
-                return Promise.resolve(entity);
             }
-        };
-        _proto._resolveEntityByPath = function _resolveEntityByPath(entityPath) {
-            var _this__context = this._context, rootIds = _this__context.rootIds, entityMap = _this__context.entityMap;
-            if (!entityPath.length || entityPath[0] >= rootIds.length) return null;
-            var entity = entityMap.get(rootIds[entityPath[0]]);
-            for(var i = 1; i < entityPath.length; i++){
-                if (!entity || entityPath[i] >= entity.children.length) return null;
-                entity = entity.children[entityPath[i]];
+            // $type — polymorphic type: construct instance and apply remaining props
+            if ("$type" in obj) {
+                var $type = obj.$type, rest = _object_without_properties_loose(obj, [
+                    "$type"
+                ]);
+                var typeName = $type;
+                var Class = Loader.getClass(typeName);
+                if (!Class) return Promise.reject(new Error('Loader.getClass: class "' + typeName + '" is not registered'));
+                var instance = new Class();
+                if (Object.keys(rest).length > 0) {
+                    return this.parseProps(instance, rest);
+                }
+                return Promise.resolve(instance);
             }
-            return entity;
-        };
-        ReflectionParser._isClass = function _isClass(value) {
-            return value["class"] !== undefined;
-        };
-        ReflectionParser._isClassType = function _isClassType(value) {
-            return value["classType"] !== undefined;
-        };
-        ReflectionParser._isAssetRef = function _isAssetRef(value) {
-            return value["url"] !== undefined;
-        };
-        ReflectionParser._isEntityRef = function _isEntityRef(value) {
-            return Array.isArray(value["entityPath"]) && value["componentType"] === undefined;
+            // $entity — entity reference by path (first element = flat index, subsequent = children indices)
+            if ("$entity" in obj) {
+                return Promise.resolve(this._resolveEntityRef(obj.$entity));
+            }
+            // $component — component reference: { entity, type, index }
+            if ("$component" in obj) {
+                return Promise.resolve(this._resolveComponent(obj.$component));
+            }
+            // $signal — signal binding: register listeners on the existing Signal instance
+            if ("$signal" in obj) {
+                return this._resolveSignal(originValue, obj.$signal);
+            }
+            // Plain object — recurse each value, modifying originValue in place or building a new object
+            var target = originValue && (typeof originValue === "undefined" ? "undefined" : _type_of1(originValue)) === "object" && !Array.isArray(originValue) ? originValue : {};
+            var promises = [];
+            for(var key in obj)_this = this, _loop(key);
+            return Promise.all(promises).then(function() {
+                return target;
+            });
         };
-        ReflectionParser._isComponentRef = function _isComponentRef(value) {
-            return Array.isArray(value["entityPath"]) && value["componentType"] !== undefined;
+        _proto._resolveSignal = function _resolveSignal(signal, listeners) {
+            var _this = this;
+            if (!signal || typeof signal.on !== "function") {
+                return Promise.reject(new Error("$signal requires a pre-initialized Signal instance on the target property"));
+            }
+            var promises = listeners.map(function(listener) {
+                var targetComponent = _this._resolveComponent(listener.target.$component);
+                if (!targetComponent) return Promise.resolve();
+                var _listener_args;
+                return Promise.all(((_listener_args = listener.args) != null ? _listener_args : []).map(function(a) {
+                    return _this._resolveValue(a);
+                })).then(function(resolvedArgs) {
+                    var _signal;
+                    (_signal = signal).on.apply(_signal, [].concat([
+                        targetComponent,
+                        listener.methodName
+                    ], resolvedArgs));
+                });
+            });
+            return Promise.all(promises).then(function() {
+                return signal;
+            });
         };
-        ReflectionParser._isSignalRef = function _isSignalRef(value) {
-            return value["listeners"] !== undefined;
+        _proto._resolveComponent = function _resolveComponent(comp) {
+            var entity = this._resolveEntityRef(comp.entity);
+            if (!entity) return null;
+            var type = Loader.getClass(comp.type);
+            if (!type) return null;
+            var buffer = ReflectionParser._componentBuffer;
+            buffer.length = 0;
+            entity.getComponents(type, buffer);
+            var _buffer_comp_index;
+            var result = (_buffer_comp_index = buffer[comp.index]) != null ? _buffer_comp_index : null;
+            buffer.length = 0;
+            return result;
         };
-        ReflectionParser._isMethodObject = function _isMethodObject(value) {
-            return Array.isArray(value == null ? void 0 : value.params);
+        _proto._resolveEntityRef = function _resolveEntityRef(path) {
+            if (!path || path.length === 0) return null;
+            var _this__context_entityInstances_path_;
+            var entity = (_this__context_entityInstances_path_ = this._context.entityInstances[path[0]]) != null ? _this__context_entityInstances_path_ : null;
+            for(var i = 1, n = path.length; entity && i < n; i++){
+                var _entity_children_path_i;
+                entity = (_entity_children_path_i = entity.children[path[i]]) != null ? _entity_children_path_i : null;
+            }
+            return entity;
         };
         return ReflectionParser;
     }();
+    /** @internal shared with HierarchyParser; each use must length=0 -> getComponents -> read -> length=0 synchronously. */ ReflectionParser._componentBuffer = [];
     /**
      * HDR (Radiance RGBE) image decoder.
      *
@@ -48898,38 +48889,6 @@
             return !!right[Symbol.hasInstance](left);
         } else return _instanceof(left, right);
     }
-    function _array_like_to_array(arr, len) {
-        if (len == null || len > arr.length) len = arr.length;
-        for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-        return arr2;
-    }
-    function _unsupported_iterable_to_array(o, minLen) {
-        if (!o) return;
-        if (typeof o === "string") return _array_like_to_array(o, minLen);
-        var n = Object.prototype.toString.call(o).slice(8, -1);
-        if (n === "Object" && o.constructor) n = o.constructor.name;
-        if (n === "Map" || n === "Set") return Array.from(n);
-        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-    }
-    function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
-        var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-        if (it) return (it = it.call(o)).next.bind(it);
-        // Fallback for engines without symbol support
-        if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
-            if (it) o = it;
-            var i = 0;
-            return function() {
-                if (i >= o.length) return {
-                    done: true
-                };
-                return {
-                    done: false,
-                    value: o[i++]
-                };
-            };
-        }
-        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
     /**
      * The Prefab resource.
      */ var PrefabResource = /*#__PURE__*/ function(ReferResource1) {
@@ -48961,8 +48920,9 @@
         };
         _proto._onDestroy = function _onDestroy() {
             var _this = this;
+            var _this__root;
             ReferResource1.prototype._onDestroy.call(this);
-            this._root.destroy();
+            (_this__root = this._root) == null ? void 0 : _this__root.destroy();
             this._dependenceAssets.forEach(function(asset) {
                 if (_instanceof1(asset, ReferResource)) {
                     // @ts-ignore
@@ -48977,316 +48937,259 @@
             var _this = this;
             this.data = data;
             this.context = context;
-            this._prefabContextMap = new WeakMap();
-            this._prefabPromiseMap = new Map();
+            if (data.version !== "2.0") {
+                var resourceType = context.type === ParserType.Scene ? "scene" : "prefab";
+                throw new Error("Unsupported " + resourceType + ' format version "' + data.version + '". Expected "2.0".');
+            }
             this._engine = this.context.engine;
-            this._organizeEntities = this._organizeEntities.bind(this);
-            this._parseComponents = this._parseComponents.bind(this);
-            this._parsePrefabModification = this._parsePrefabModification.bind(this);
-            this._parseAddedComponents = this._parseAddedComponents.bind(this);
-            this._parseComponentsPropsAndMethods = this._parseComponentsPropsAndMethods.bind(this);
-            this._parsePrefabRemovedEntities = this._parsePrefabRemovedEntities.bind(this);
-            this._parsePrefabRemovedComponents = this._parsePrefabRemovedComponents.bind(this);
-            this._clearAndResolve = this._clearAndResolve.bind(this);
             this.promise = new Promise(function(resolve, reject) {
                 _this._reject = reject;
                 _this._resolve = resolve;
             });
-            this._reflectionParser = new ReflectionParser(context);
+            this._reflectionParser = new ReflectionParser(context, data.refs);
         }
         var _proto = HierarchyParser.prototype;
-        /** start parse the scene or prefab or others */ _proto.start = function start() {
-            this._parseEntities().then(this._organizeEntities).then(this._parseComponents).then(this._parseAddedComponents).then(this._parseComponentsPropsAndMethods).then(this._parsePrefabModification).then(this._parsePrefabRemovedEntities).then(this._parsePrefabRemovedComponents).then(this._clearAndResolve).then(this._resolve).catch(this._reject);
-        };
-        _proto._applyEntityData = function _applyEntityData(entity, entityConfig) {
-            if (entityConfig === void 0) entityConfig = {};
-            var _entityConfig_isActive;
-            entity.isActive = (_entityConfig_isActive = entityConfig.isActive) != null ? _entityConfig_isActive : entity.isActive;
-            var _entityConfig_name;
-            entity.name = (_entityConfig_name = entityConfig.name) != null ? _entityConfig_name : entity.name;
-            var transform = entity.transform;
-            var transformConfig = entityConfig.transform;
-            if (transformConfig) {
-                this._reflectionParser.parsePropsAndMethods(transform, transformConfig);
-            } else {
-                var position = entityConfig.position, rotation = entityConfig.rotation, scale = entityConfig.scale;
-                if (position) transform.position.copyFrom(position);
-                if (rotation) transform.rotation.copyFrom(rotation);
-                if (scale) transform.scale.copyFrom(scale);
-            }
-            if (entityConfig.layer) entity.layer = entityConfig.layer;
-            return entity;
-        };
-        _proto._parseEntities = function _parseEntities() {
+        _proto.start = function start() {
             var _this = this;
-            var entitiesConfig = this.data.entities;
-            var entityConfigMap = this.context.entityConfigMap;
-            var entityMap = this.context.entityMap;
-            var engine = this._engine;
-            var promises = entitiesConfig.map(function(entityConfig) {
-                var _entityConfig_strippedId;
-                var id = (_entityConfig_strippedId = entityConfig.strippedId) != null ? _entityConfig_strippedId : entityConfig.id;
-                entityConfig.id = id;
-                entityConfigMap.set(id, entityConfig);
-                return _this._getEntityByConfig(entityConfig, engine);
-            });
-            return Promise.all(promises).then(function(entities) {
-                for(var i = 0, l = entities.length; i < l; i++){
-                    entityMap.set(entitiesConfig[i].id, entities[i]);
-                }
-                // Build rootIds in serialization order (not async completion order)
-                var rootIds = _this.context.rootIds;
-                for(var i1 = 0, l1 = entitiesConfig.length; i1 < l1; i1++){
-                    if (!entitiesConfig[i1].parent && !entitiesConfig[i1].strippedId) {
-                        rootIds.push(entitiesConfig[i1].id);
-                    }
-                }
-                return entities;
-            });
-        };
-        _proto._parseComponents = function _parseComponents() {
-            var entitiesConfig = this.data.entities;
-            var entityMap = this.context.entityMap;
-            for(var i = 0, l = entitiesConfig.length; i < l; i++){
-                var entityConfig = entitiesConfig[i];
-                if (entityConfig.strippedId) {
-                    continue;
-                }
-                var entity = entityMap.get(entityConfig.id);
-                this._addComponents(entity, entityConfig.components);
-            }
-        };
-        _proto._parsePrefabModification = function _parsePrefabModification() {
-            var _loop = function _loop(i, l) {
-                var entityConfig = entitiesConfig[i];
-                var id = entityConfig.id, modifications = entityConfig.modifications;
-                if (modifications == null ? void 0 : modifications.length) {
-                    var _promises;
-                    var rootEntity = entityMap.get(id);
-                    (_promises = promises).push.apply(_promises, [].concat(modifications.map(function(modification) {
-                        var target = modification.target, props = modification.props, methods = modification.methods;
-                        var entityId = target.entityId, componentId = target.componentId;
-                        var context = _this._prefabContextMap.get(rootEntity);
-                        var targetEntity = context.entityMap.get(entityId);
-                        var targetComponent = context.components.get(componentId);
-                        if (targetComponent) {
-                            return _this._reflectionParser.parsePropsAndMethods(targetComponent, {
-                                props: props,
-                                methods: methods
-                            });
-                        } else if (targetEntity) {
-                            return Promise.resolve(_this._applyEntityData(targetEntity, props));
-                        }
-                    })));
+            this._parseEntities().then(function() {
+                return _this._organizeEntities();
+            }).then(function() {
+                return _this._parseComponents();
+            }).then(function() {
+                return _this._parseComponentsPropsAndCalls();
+            }).then(function() {
+                return _this._parsePrefabOverrides();
+            }).then(function() {
+                return _this._clearAndResolve();
+            }).then(this._resolve).catch(this._reject);
+        };
+        _proto._onEntityCreated = function _onEntityCreated(_entity) {};
+        // ---------------------------------------------------------------------------
+        // Stage 1: Create entity instances
+        // ---------------------------------------------------------------------------
+        _proto._parseEntities = function _parseEntities() {
+            var _this, _loop = function _loop(i, n) {
+                var entityConfig = entities[i];
+                if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) {
+                    promises.push(_this._loadPrefabInstance(entityConfig, engine).then(function(entity) {
+                        entityInstances[i] = entity;
+                    }));
+                } else {
+                    var entity = new Entity(engine, entityConfig.name);
+                    HierarchyParser._applyEntityProps(entity, entityConfig);
+                    _this._onEntityCreated(entity);
+                    entityInstances[i] = entity;
                 }
             };
-            var _this = this;
-            var entitiesConfig = this.data.entities;
-            var entityMap = this.context.entityMap;
+            var entities = this.data.entities;
+            var entityInstances = this.context.entityInstances;
+            var engine = this._engine;
             var promises = [];
-            for(var i = 0, l = entitiesConfig.length; i < l; i++)_loop(i);
+            for(var i = 0, n = entities.length; i < n; i++)_this = this, _loop(i);
             return Promise.all(promises);
         };
-        _proto._parseAddedComponents = function _parseAddedComponents() {
-            var entityMap = this.context.entityMap;
-            var entityConfigMap = this.context.entityConfigMap;
-            var strippedIds = this.context.strippedIds;
-            for(var i = 0, n = strippedIds.length; i < n; i++){
-                var entityConfig = entityConfigMap.get(strippedIds[i]);
-                var prefabContext = this._prefabContextMap.get(entityMap.get(entityConfig.prefabInstanceId));
-                var entity = prefabContext.entityMap.get(entityConfig.prefabSource.entityId);
-                this._addComponents(entity, entityConfig.components);
-            }
-        };
-        _proto._parsePrefabRemovedEntities = function _parsePrefabRemovedEntities() {
-            var entitiesConfig = this.data.entities;
-            var entityMap = this.context.entityMap;
-            for(var i = 0, l = entitiesConfig.length; i < l; i++){
-                var entityConfig = entitiesConfig[i];
-                var id = entityConfig.id, removedEntities = entityConfig.removedEntities;
-                if (removedEntities == null ? void 0 : removedEntities.length) {
-                    var rootEntity = entityMap.get(id);
-                    for(var j = 0, m = removedEntities.length; j < m; j++){
-                        var target = removedEntities[j];
-                        var entityId = target.entityId;
-                        var context = this._prefabContextMap.get(rootEntity);
-                        var targetEntity = context.entityMap.get(entityId);
-                        if (targetEntity) {
-                            targetEntity.destroy();
-                        }
-                    }
+        // ---------------------------------------------------------------------------
+        // Stage 2: Build parent-child hierarchy
+        // ---------------------------------------------------------------------------
+        _proto._organizeEntities = function _organizeEntities() {
+            var entities = this.data.entities;
+            var entityInstances = this.context.entityInstances;
+            for(var i = 0, n = entities.length; i < n; i++){
+                var entityConfig = entities[i];
+                // Prefab instance entities manage their own children.
+                if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
+                var children = entityConfig.children;
+                if (!children) continue;
+                var parent = entityInstances[i];
+                for(var j = 0, m = children.length; j < m; j++){
+                    parent.addChild(entityInstances[children[j]]);
                 }
             }
+            var rootIndices = this._getRootIndices();
+            for(var i1 = 0, n1 = rootIndices.length; i1 < n1; i1++){
+                this._handleRootEntity(rootIndices[i1]);
+            }
         };
-        _proto._parsePrefabRemovedComponents = function _parsePrefabRemovedComponents() {
-            var entitiesConfig = this.data.entities;
-            var entityMap = this.context.entityMap;
-            var prefabContextMap = this._prefabContextMap;
-            for(var i = 0, l = entitiesConfig.length; i < l; i++){
-                var entityConfig = entitiesConfig[i];
-                var id = entityConfig.id, removedComponents = entityConfig.removedComponents;
-                if (removedComponents == null ? void 0 : removedComponents.length) {
-                    var rootEntity = entityMap.get(id);
-                    for(var j = 0, m = removedComponents.length; j < m; j++){
-                        var target = removedComponents[j];
-                        var componentId = target.componentId;
-                        var context = prefabContextMap.get(rootEntity);
-                        var targetComponent = context.components.get(componentId);
-                        if (targetComponent) {
-                            targetComponent.destroy();
-                        }
-                    }
+        // ---------------------------------------------------------------------------
+        // Stage 3: Add components to entities
+        // ---------------------------------------------------------------------------
+        _proto._parseComponents = function _parseComponents() {
+            var entities = this.data.entities;
+            var allComponents = this.data.components;
+            var entityInstances = this.context.entityInstances;
+            var pendingComponents = this.context.pendingComponents;
+            var refs = this.data.refs;
+            for(var i = 0, n = entities.length; i < n; i++){
+                var entityConfig = entities[i];
+                if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
+                var entity = entityInstances[i];
+                var componentIndices = entityConfig.components;
+                if (!componentIndices) continue;
+                for(var j = 0, m = componentIndices.length; j < m; j++){
+                    var config = allComponents[componentIndices[j]];
+                    var instance = HierarchyParser._addComponentFromConfig(entity, config, refs);
+                    pendingComponents.push({
+                        instance: instance,
+                        config: config
+                    });
                 }
             }
         };
-        _proto._organizeEntities = function _organizeEntities() {
-            var _this_context = this.context, rootIds = _this_context.rootIds, strippedIds = _this_context.strippedIds;
-            var parentIds = rootIds.concat(strippedIds);
-            for(var i = 0, l = parentIds.length; i < l; i++){
-                this._parseChildren(parentIds[i]);
-            }
-            for(var i1 = 0; i1 < rootIds.length; i1++){
-                this._handleRootEntity(rootIds[i1]);
+        // ---------------------------------------------------------------------------
+        // Stage 4: Apply props and execute calls on components
+        // ---------------------------------------------------------------------------
+        _proto._parseComponentsPropsAndCalls = function _parseComponentsPropsAndCalls() {
+            var pendingComponents = this.context.pendingComponents;
+            var reflectionParser = this._reflectionParser;
+            var promises = [];
+            for(var i = 0, n = pendingComponents.length; i < n; i++){
+                var _pendingComponents_i = pendingComponents[i], instance = _pendingComponents_i.instance, config = _pendingComponents_i.config;
+                promises.push(reflectionParser.parseMutationBlock(instance, config));
             }
+            return Promise.all(promises);
         };
-        _proto._getEntityByConfig = function _getEntityByConfig(entityConfig, engine) {
-            var _this = this;
-            var entityPromise;
-            if (entityConfig.assetUrl) {
-                entityPromise = this._parsePrefab(entityConfig, engine);
-            } else if (entityConfig.strippedId) {
-                entityPromise = this._parseStrippedEntity(entityConfig);
-            } else {
-                entityPromise = this._parseEntity(entityConfig, engine);
+        // ---------------------------------------------------------------------------
+        // Stage 5: Apply prefab instance overrides
+        // ---------------------------------------------------------------------------
+        _proto._parsePrefabOverrides = function _parsePrefabOverrides() {
+            var entities = this.data.entities;
+            var entityInstances = this.context.entityInstances;
+            var promises = [];
+            for(var i = 0, n = entities.length; i < n; i++){
+                var entityConfig = entities[i];
+                if (!HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
+                var overrides = entityConfig.instance.overrides;
+                if (!overrides) continue;
+                this._applyOverrides(entityInstances[i], overrides, promises);
             }
-            return entityPromise.then(function(entity) {
-                return _this._applyEntityData(entity, entityConfig);
-            });
+            return Promise.all(promises);
         };
-        _proto._parseEntity = function _parseEntity(entityConfig, engine) {
-            var transform = entityConfig.transform;
-            var entity = new Entity(engine, entityConfig.name, transform ? Loader.getClass(transform.class) : Transform);
-            this._addEntityPlugin(entityConfig.id, entity);
-            return Promise.resolve(entity);
+        _proto._applyOverrides = function _applyOverrides(rootEntity, overrides, promises) {
+            var refs = this.data.refs;
+            var reflectionParser = this._reflectionParser;
+            // entityProps — entity-level property overrides
+            if (overrides.entityProps) {
+                for(var j = 0, m = overrides.entityProps.length; j < m; j++){
+                    var override = overrides.entityProps[j];
+                    HierarchyParser._applyEntityProps(HierarchyParser._resolveEntity(rootEntity, override.path), override);
+                }
+            }
+            // componentProps — component-level property overrides
+            if (overrides.componentProps) {
+                for(var j1 = 0, m1 = overrides.componentProps.length; j1 < m1; j1++){
+                    var override1 = overrides.componentProps[j1];
+                    var entity = HierarchyParser._resolveEntity(rootEntity, override1.path);
+                    var target = HierarchyParser._resolveComponent(entity, override1.selector);
+                    promises.push(reflectionParser.parseMutationBlock(target, override1));
+                }
+            }
+            // addedComponents — attach top-level components[index] to a prefab entity and parse props
+            if (overrides.addedComponents) {
+                var allComponents = this.data.components;
+                for(var j2 = 0, m2 = overrides.addedComponents.length; j2 < m2; j2++){
+                    var added = overrides.addedComponents[j2];
+                    var entity1 = HierarchyParser._resolveEntity(rootEntity, added.target);
+                    var config = allComponents[added.component];
+                    var component = HierarchyParser._addComponentFromConfig(entity1, config, refs);
+                    promises.push(reflectionParser.parseMutationBlock(component, config));
+                }
+            }
+            // addedEntities — attach already-created top-level entityInstances[index] as a child
+            if (overrides.addedEntities) {
+                var entityInstances = this.context.entityInstances;
+                for(var j3 = 0, m3 = overrides.addedEntities.length; j3 < m3; j3++){
+                    var added1 = overrides.addedEntities[j3];
+                    var parent = HierarchyParser._resolveEntity(rootEntity, added1.parent);
+                    parent.addChild(entityInstances[added1.entity]);
+                }
+            }
+            // removedEntities — pre-resolve all targets then destroy (destroy shifts sibling indices)
+            if (overrides.removedEntities) {
+                var removed = overrides.removedEntities;
+                var targets = new Array(removed.length);
+                for(var j4 = 0, m4 = removed.length; j4 < m4; j4++){
+                    targets[j4] = HierarchyParser._resolveEntity(rootEntity, removed[j4]);
+                }
+                for(var j5 = 0, m5 = targets.length; j5 < m5; j5++){
+                    targets[j5].destroy();
+                }
+            }
+            // removedComponents — pre-resolve all targets then destroy (destroy shifts component indices)
+            if (overrides.removedComponents) {
+                var targets1 = [];
+                for(var j6 = 0, m6 = overrides.removedComponents.length; j6 < m6; j6++){
+                    var override2 = overrides.removedComponents[j6];
+                    var entity2 = HierarchyParser._resolveEntity(rootEntity, override2.path);
+                    var selectors = override2.selectors;
+                    for(var k = 0, p = selectors.length; k < p; k++){
+                        targets1.push(HierarchyParser._resolveComponent(entity2, selectors[k]));
+                    }
+                }
+                for(var j7 = 0, m7 = targets1.length; j7 < m7; j7++){
+                    targets1[j7].destroy();
+                }
+            }
         };
-        _proto._parsePrefab = function _parsePrefab(entityConfig, engine) {
+        // ---------------------------------------------------------------------------
+        // Prefab instance loading
+        // ---------------------------------------------------------------------------
+        _proto._loadPrefabInstance = function _loadPrefabInstance(entityConfig, engine) {
             var _this = this;
-            var assetUrl = entityConfig.assetUrl;
+            var instance = entityConfig.instance;
+            var refItem;
+            try {
+                refItem = resolveRefItem(this.data.refs, instance.asset, "HierarchyParser", "instance.asset");
+            } catch (error) {
+                return Promise.reject(error);
+            }
             return engine.resourceManager // @ts-ignore
-            .getResourceByRef({
-                url: assetUrl
-            }).then(function(prefabResource) {
+            .getResourceByRef(refItem).then(function(prefabResource) {
                 var entity = _instanceof1(prefabResource, PrefabResource) ? prefabResource.instantiate() : prefabResource.instantiateSceneRoot();
-                var instanceContext = new ParserContext(engine, ParserType.Prefab, null);
-                _this._generateInstanceContext(entity, instanceContext, "");
-                _this._prefabContextMap.set(entity, instanceContext);
-                var cbArray = _this._prefabPromiseMap.get(entityConfig.id);
-                if (cbArray) {
-                    for(var i = 0, n = cbArray.length; i < n; i++){
-                        cbArray[i].resolve(instanceContext);
-                    }
-                }
+                _this._onEntityCreated(entity);
                 return entity;
             });
         };
-        _proto._parseStrippedEntity = function _parseStrippedEntity(entityConfig) {
-            var _this = this;
-            this.context.strippedIds.push(entityConfig.id);
-            return new Promise(function(resolve, reject) {
-                var _this__prefabPromiseMap_get;
-                var cbArray = (_this__prefabPromiseMap_get = _this._prefabPromiseMap.get(entityConfig.prefabInstanceId)) != null ? _this__prefabPromiseMap_get : [];
-                cbArray.push({
-                    resolve: resolve,
-                    reject: reject
-                });
-                _this._prefabPromiseMap.set(entityConfig.prefabInstanceId, cbArray);
-            }).then(function(context) {
-                var entityId = entityConfig.prefabSource.entityId;
-                return context.entityMap.get(entityId);
-            });
-        };
-        _proto._parseChildren = function _parseChildren(parentId) {
-            var _this_context = this.context, entityConfigMap = _this_context.entityConfigMap, entityMap = _this_context.entityMap;
-            var children = entityConfigMap.get(parentId).children;
-            if (children && children.length > 0) {
-                var parent = entityMap.get(parentId);
-                for(var i = 0; i < children.length; i++){
-                    var childId = children[i];
-                    var entity = entityMap.get(childId);
-                    parent.addChild(entity);
-                    this._parseChildren(childId);
-                }
+        // ---------------------------------------------------------------------------
+        // Utilities
+        // ---------------------------------------------------------------------------
+        /** Resolve an entity inside a prefab instance by walking the child-index path from root */ HierarchyParser._resolveEntity = function _resolveEntity(root, path) {
+            var entity = root;
+            for(var i = 0, n = path.length; i < n; i++){
+                entity = entity.children[path[i]];
+                if (!entity) throw new Error("HierarchyParser: override target entity not found at path [" + path + "], failed at depth " + i);
             }
+            return entity;
         };
-        _proto._addComponents = function _addComponents(entity, components) {
-            var context = this.context;
-            var componentMap = context.components;
-            var componentConfigMap = context.componentConfigMap;
-            for(var i = 0, n = components.length; i < n; i++){
-                var componentConfig = components[i];
-                var key = !componentConfig.url ? componentConfig.class : componentConfig.url;
-                var componentId = componentConfig.id;
-                var component = entity.addComponent(Loader.getClass(key));
-                componentMap.set(componentId, component);
-                componentConfigMap.set(componentId, componentConfig);
-                this._addComponentPlugin(componentId, component);
-            }
-        };
-        _proto._generateInstanceContext = function _generateInstanceContext(entity, context, path) {
-            var entityMap = context.entityMap, components = context.components;
-            var componentsMap = {};
-            var componentIndexMap = {};
-            entityMap.set(path, entity);
-            // @ts-ignore
-            entity._components.forEach(function(component) {
-                // @ts-ignore
-                var name = Loader.getClassName(component.constructor);
-                if (!componentsMap[name]) {
-                    componentsMap[name] = entity.getComponents(component.constructor, []);
-                    componentIndexMap[name] = 0;
-                }
-                components.set(path + ":" + name + "/" + componentIndexMap[name]++, component);
-            });
-            for(var i = 0, n = entity.children.length; i < n; i++){
-                var child = entity.children[i];
-                var childPath = path ? path + "/" + i : "" + i;
-                this._generateInstanceContext(child, context, childPath);
-            }
+        /** Resolve a component on an entity by type name + per-type index */ HierarchyParser._resolveComponent = function _resolveComponent(entity, selector) {
+            var type = Loader.getClass(selector.type);
+            if (!type) throw new Error('HierarchyParser: override target component type "' + selector.type + '" is not registered');
+            var buffer = ReflectionParser._componentBuffer;
+            buffer.length = 0;
+            entity.getComponents(type, buffer);
+            var result = buffer[selector.index];
+            buffer.length = 0;
+            if (!result) throw new Error("HierarchyParser: override target component not found: " + selector.type + "/" + selector.index);
+            return result;
         };
-        _proto._parseComponentsPropsAndMethods = function _parseComponentsPropsAndMethods() {
-            var context = this.context;
-            var componentConfigMap = context.componentConfigMap;
-            var reflectionParser = this._reflectionParser;
-            var promises = [];
-            for(var _iterator = _create_for_of_iterator_helper_loose(context.components), _step; !(_step = _iterator()).done;){
-                var _step_value = _step.value, componentId = _step_value[0], component = _step_value[1];
-                var componentConfig = componentConfigMap.get(componentId);
-                if (componentConfig) {
-                    promises.push(reflectionParser.parsePropsAndMethods(component, componentConfig));
-                }
-            }
-            return Promise.all(promises);
+        /** Resolve component class from config and add to entity. Throws if class is not registered. */ HierarchyParser._addComponentFromConfig = function _addComponentFromConfig(entity, config, refs) {
+            var key = config.script != null ? resolveRefItem(refs, config.script, "HierarchyParser", "component.script").url : config.type;
+            var Class = Loader.getClass(key);
+            if (!Class) throw new Error('Loader.getClass: class "' + key + '" is not registered');
+            return entity.addComponent(Class);
+        };
+        HierarchyParser._isPrefabInstanceEntity = function _isPrefabInstanceEntity(entityConfig) {
+            return "instance" in entityConfig;
+        };
+        /** Apply entity-level props (name, isActive, layer, transform) to an entity. */ HierarchyParser._applyEntityProps = function _applyEntityProps(entity, props) {
+            if (props.name != null) entity.name = props.name;
+            if (props.isActive != null) entity.isActive = props.isActive;
+            if (props.layer != null) entity.layer = props.layer;
+            if (props.position) entity.transform.position.set(props.position[0], props.position[1], props.position[2]);
+            if (props.rotation) entity.transform.rotation.set(props.rotation[0], props.rotation[1], props.rotation[2]);
+            if (props.scale) entity.transform.scale.set(props.scale[0], props.scale[1], props.scale[2]);
         };
-        _proto._addComponentPlugin = function _addComponentPlugin(componentId, component) {};
-        _proto._addEntityPlugin = function _addEntityPlugin(entityId, entity) {};
         return HierarchyParser;
     }();
-    var MaterialLoaderType = /*#__PURE__*/ function(MaterialLoaderType) {
-        MaterialLoaderType["Vector2"] = "Vector2";
-        MaterialLoaderType["Vector3"] = "Vector3";
-        MaterialLoaderType["Vector4"] = "Vector4";
-        MaterialLoaderType["Color"] = "Color";
-        MaterialLoaderType["Float"] = "Float";
-        MaterialLoaderType["Texture"] = "Texture";
-        MaterialLoaderType["Boolean"] = "Boolean";
-        MaterialLoaderType["Integer"] = "Integer";
-        return MaterialLoaderType;
-    }({});
-    var SpecularMode = /*#__PURE__*/ function(SpecularMode) {
-        SpecularMode["Sky"] = "Sky";
-        SpecularMode["Custom"] = "Custom";
-        return SpecularMode;
-    }({});
     /** @Internal */ var SceneParser = /*#__PURE__*/ function(HierarchyParser) {
         _inherits(SceneParser, HierarchyParser);
         function SceneParser(data, context, scene) {
@@ -49300,90 +49203,40 @@
        */ _proto._collectDependentAssets = function _collectDependentAssets(data) {
             var context = this.context;
             var resourceManager = context.resourceManager;
-            this._parseDependentAssets(data);
-            var scene = data.scene;
-            var ambient = scene.ambient;
-            if (ambient) {
-                var useCustomAmbient = ambient.specularMode === SpecularMode.Custom;
-                var useSH = ambient.diffuseMode === DiffuseMode.SphericalHarmonics;
-                var customAmbientLight = ambient.customAmbientLight, ambientLight = ambient.ambientLight;
-                if (useCustomAmbient && customAmbientLight) {
-                    // @ts-ignore
-                    context._addDependentAsset(customAmbientLight.url, resourceManager.getResourceByRef(customAmbientLight));
-                }
-                if (ambientLight && (!useCustomAmbient || useSH)) {
-                    // @ts-ignore
-                    context._addDependentAsset(ambientLight.url, resourceManager.getResourceByRef(ambientLight));
-                }
-            }
-            var background = scene.background;
-            var backgroundMode = background.mode;
-            if (backgroundMode === BackgroundMode.Texture) {
-                var texture = background.texture;
+            var refs = data.refs;
+            for(var i = 0, n = refs.length; i < n; i++){
                 // @ts-ignore
-                texture && context._addDependentAsset(texture.url, resourceManager.getResourceByRef(texture));
-            } else if (backgroundMode === BackgroundMode.Sky) {
-                var skyMesh = background.skyMesh, skyMaterial = background.skyMaterial;
-                if (skyMesh && skyMaterial) {
-                    // @ts-ignore
-                    context._addDependentAsset(skyMesh.url, resourceManager.getResourceByRef(skyMesh));
-                    // @ts-ignore
-                    context._addDependentAsset(skyMaterial.url, resourceManager.getResourceByRef(skyMaterial));
-                }
+                context._addDependentAsset(resourceManager.getResourceByRef(refs[i]));
             }
         };
-        _proto._handleRootEntity = function _handleRootEntity(id) {
-            var entityMap = this.context.entityMap;
-            this.scene.addRootEntity(entityMap.get(id));
+        _proto._getRootIndices = function _getRootIndices() {
+            return this.data.scene.entities;
+        };
+        _proto._handleRootEntity = function _handleRootEntity(index) {
+            this.scene.addRootEntity(this.context.entityInstances[index]);
         };
         _proto._clearAndResolve = function _clearAndResolve() {
             this.context.clear();
             return this.scene;
         };
-        _proto._parseDependentAssets = function _parseDependentAssets(file) {
-            var entities = file.entities;
-            for(var i = 0, n = entities.length; i < n; i++){
-                var entity = entities[i];
-                if (!!entity.assetUrl) {
-                    var context = this.context;
-                    var url = entity.assetUrl, key = entity.key;
-                    // @ts-ignore
-                    context._addDependentAsset(url, context.resourceManager.getResourceByRef({
-                        url: url,
-                        key: key
-                    }));
-                } else if (entity.strippedId) {
-                    continue;
-                } else {
-                    var components = entity.components;
-                    for(var j = 0, m = components.length; j < m; j++){
-                        var component = components[j];
-                        this._searchDependentAssets(component.methods);
-                        this._searchDependentAssets(component.props);
-                    }
-                }
-            }
-        };
-        _proto._searchDependentAssets = function _searchDependentAssets(value) {
-            if (Array.isArray(value)) {
-                for(var i = 0, n = value.length; i < n; i++){
-                    this._searchDependentAssets(value[i]);
-                }
-            } else if (!!value && (typeof value === "undefined" ? "undefined" : _type_of1(value)) === "object") {
-                // @ts-ignore
-                if (ReflectionParser._isAssetRef(value)) {
-                    var context = this.context;
-                    // @ts-ignore
-                    context._addDependentAsset(value.url, context.resourceManager.getResourceByRef(value));
-                } else {
-                    for(var key in value){
-                        this._searchDependentAssets(value[key]);
-                    }
-                }
-            }
-        };
         return SceneParser;
     }(HierarchyParser);
+    var SpecularMode = /*#__PURE__*/ function(SpecularMode) {
+        SpecularMode["Sky"] = "Sky";
+        SpecularMode["Custom"] = "Custom";
+        return SpecularMode;
+    }({});
+    var MaterialLoaderType = /*#__PURE__*/ function(MaterialLoaderType) {
+        MaterialLoaderType["Vector2"] = "Vector2";
+        MaterialLoaderType["Vector3"] = "Vector3";
+        MaterialLoaderType["Vector4"] = "Vector4";
+        MaterialLoaderType["Color"] = "Color";
+        MaterialLoaderType["Float"] = "Float";
+        MaterialLoaderType["Texture"] = "Texture";
+        MaterialLoaderType["Boolean"] = "Boolean";
+        MaterialLoaderType["Integer"] = "Integer";
+        return MaterialLoaderType;
+    }({});
     /**
      * Decode engine binary resource.
      * @param arrayBuffer - array buffer of decode binary file
@@ -50844,6 +50697,38 @@
         ]);
         return GLTFResource;
     }(ReferResource);
+    function _array_like_to_array(arr, len) {
+        if (len == null || len > arr.length) len = arr.length;
+        for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+        return arr2;
+    }
+    function _unsupported_iterable_to_array(o, minLen) {
+        if (!o) return;
+        if (typeof o === "string") return _array_like_to_array(o, minLen);
+        var n = Object.prototype.toString.call(o).slice(8, -1);
+        if (n === "Object" && o.constructor) n = o.constructor.name;
+        if (n === "Map" || n === "Set") return Array.from(n);
+        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+    }
+    function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+        var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+        if (it) return (it = it.call(o)).next.bind(it);
+        // Fallback for engines without symbol support
+        if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
+            if (it) o = it;
+            var i = 0;
+            return function() {
+                if (i >= o.length) return {
+                    done: true
+                };
+                return {
+                    done: false,
+                    value: o[i++]
+                };
+            };
+        }
+        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
     /**
      * Module for glTF 2.0 Interface
      */ /**
@@ -53094,15 +52979,17 @@
             return _this;
         }
         var _proto = PrefabParser.prototype;
-        _proto._applyEntityData = function _applyEntityData(entity, entityConfig) {
-            if (entityConfig === void 0) entityConfig = {};
-            HierarchyParser.prototype._applyEntityData.call(this, entity, entityConfig);
+        _proto._onEntityCreated = function _onEntityCreated(entity) {
             // @ts-ignore
             entity._markAsTemplate(this.context.resource);
-            return entity;
         };
-        _proto._handleRootEntity = function _handleRootEntity(id) {
-            this.prefabResource._root = this.context.entityMap.get(id);
+        _proto._getRootIndices = function _getRootIndices() {
+            return [
+                this.data.root
+            ];
+        };
+        _proto._handleRootEntity = function _handleRootEntity(index) {
+            this.prefabResource._root = this.context.entityInstances[index];
         };
         _proto._clearAndResolve = function _clearAndResolve() {
             this.context.clear();
@@ -53113,9 +53000,7 @@
             var context = new ParserContext(engine, ParserType.Prefab, prefabResource);
             var parser = new PrefabParser(data, context, prefabResource);
             parser.start();
-            return parser.promise.then(function() {
-                return prefabResource;
-            });
+            return parser.promise;
         };
         return PrefabParser;
     }(HierarchyParser);
@@ -54223,6 +54108,122 @@
             "renderTarget"
         ])
     ], RenderTargetLoader);
+    function loadRef(refs, index, resourceManager, label) {
+        var ref = resolveRefItem(refs, index, "SceneLoader", label);
+        // @ts-ignore
+        return resourceManager.getResourceByRef(ref);
+    }
+    /**
+     * Apply scene-level data (ambient, background, shadow, fog, AO) to a Scene.
+     * @internal
+     */ function applySceneData(scene, sceneData, resourceManager, refs) {
+        var promises = [];
+        try {
+            // parse ambient light
+            var ambient = sceneData.ambient;
+            if (ambient) {
+                var useCustomAmbient = ambient.specularMode === SpecularMode.Custom;
+                var useSH = ambient.diffuseMode === DiffuseMode.SphericalHarmonics;
+                scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
+                scene.ambientLight.specularIntensity = ambient.specularIntensity;
+                scene.ambientLight.diffuseMode = ambient.diffuseMode;
+                var solidColor = ambient.diffuseSolidColor;
+                if (solidColor) {
+                    scene.ambientLight.diffuseSolidColor.set(solidColor[0], solidColor[1], solidColor[2], solidColor[3]);
+                }
+                if (useCustomAmbient && ambient.customAmbientLight != null) {
+                    promises.push(loadRef(refs, ambient.customAmbientLight, resourceManager, "scene.ambient.customAmbientLight").then(function(ambientLight) {
+                        scene.ambientLight.specularTexture = ambientLight == null ? void 0 : ambientLight.specularTexture;
+                    }));
+                }
+                if (ambient.ambientLight != null && (!useCustomAmbient || useSH)) {
+                    promises.push(loadRef(refs, ambient.ambientLight, resourceManager, "scene.ambient.ambientLight").then(function(ambientLight) {
+                        if (!useCustomAmbient) {
+                            scene.ambientLight.specularTexture = ambientLight == null ? void 0 : ambientLight.specularTexture;
+                        }
+                        if (useSH) {
+                            scene.ambientLight.diffuseSphericalHarmonics = ambientLight == null ? void 0 : ambientLight.diffuseSphericalHarmonics;
+                        }
+                    }));
+                }
+            }
+            // parse background
+            var background = sceneData.background;
+            scene.background.mode = background.mode;
+            switch(scene.background.mode){
+                case BackgroundMode.SolidColor:
+                    {
+                        var color = background.color;
+                        scene.background.solidColor.set(color[0], color[1], color[2], color[3]);
+                        break;
+                    }
+                case BackgroundMode.Sky:
+                    if (background.skyMesh != null && background.skyMaterial != null) {
+                        promises.push(loadRef(refs, background.skyMesh, resourceManager, "scene.background.skyMesh").then(function(mesh) {
+                            scene.background.sky.mesh = mesh;
+                        }), loadRef(refs, background.skyMaterial, resourceManager, "scene.background.skyMaterial").then(function(material) {
+                            scene.background.sky.material = material;
+                        }));
+                    } else {
+                        Logger.warn("Sky background mode requires skyMesh and skyMaterial");
+                    }
+                    break;
+                case BackgroundMode.Texture:
+                    if (background.texture != null) {
+                        promises.push(loadRef(refs, background.texture, resourceManager, "scene.background.texture").then(function(texture) {
+                            scene.background.texture = texture;
+                        }));
+                        var _background_textureFillMode;
+                        scene.background.textureFillMode = (_background_textureFillMode = background.textureFillMode) != null ? _background_textureFillMode : scene.background.textureFillMode;
+                    }
+                    break;
+            }
+        } catch (error) {
+            return Promise.reject(error);
+        }
+        // parse shadow
+        var shadow = sceneData.shadow;
+        if (shadow) {
+            if (shadow.castShadows != undefined) scene.castShadows = shadow.castShadows;
+            if (shadow.shadowResolution != undefined) scene.shadowResolution = shadow.shadowResolution;
+            if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
+            if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
+            if (shadow.enableTransparentShadow != undefined) scene.enableTransparentShadow = shadow.enableTransparentShadow;
+            if (shadow.shadowTwoCascadeSplits != undefined) scene.shadowTwoCascadeSplits = shadow.shadowTwoCascadeSplits;
+            if (shadow.shadowFourCascadeSplits) {
+                var splits = shadow.shadowFourCascadeSplits;
+                scene.shadowFourCascadeSplits.set(splits[0], splits[1], splits[2]);
+            }
+            if (shadow.shadowFadeBorder != undefined) scene.shadowFadeBorder = shadow.shadowFadeBorder;
+        }
+        // parse fog
+        var fog = sceneData.fog;
+        if (fog) {
+            if (fog.fogMode != undefined) scene.fogMode = fog.fogMode;
+            if (fog.fogStart != undefined) scene.fogStart = fog.fogStart;
+            if (fog.fogEnd != undefined) scene.fogEnd = fog.fogEnd;
+            if (fog.fogDensity != undefined) scene.fogDensity = fog.fogDensity;
+            if (fog.fogColor) scene.fogColor.set(fog.fogColor[0], fog.fogColor[1], fog.fogColor[2], fog.fogColor[3]);
+        }
+        // Post Process
+        if (sceneData.postProcess) {
+            Logger.warn("Post Process is not supported in scene yet, please add PostProcess component in entity instead.");
+        }
+        // Ambient Occlusion
+        var ambientOcclusion = sceneData.ambientOcclusion;
+        if (ambientOcclusion) {
+            var sceneAO = scene.ambientOcclusion;
+            if (ambientOcclusion.enabledAmbientOcclusion != undefined) sceneAO.enabled = ambientOcclusion.enabledAmbientOcclusion;
+            if (ambientOcclusion.quality != undefined) sceneAO.quality = ambientOcclusion.quality;
+            if (ambientOcclusion.intensity != undefined) sceneAO.intensity = ambientOcclusion.intensity;
+            if (ambientOcclusion.radius != undefined) sceneAO.radius = ambientOcclusion.radius;
+            if (ambientOcclusion.bias != undefined) sceneAO.bias = ambientOcclusion.bias;
+            if (ambientOcclusion.power != undefined) sceneAO.power = ambientOcclusion.power;
+            if (ambientOcclusion.bilateralThreshold != undefined) sceneAO.bilateralThreshold = ambientOcclusion.bilateralThreshold;
+            if (ambientOcclusion.minHorizonAngle != undefined) sceneAO.minHorizonAngle = ambientOcclusion.minHorizonAngle;
+        }
+        return Promise.all(promises).then(function() {});
+    }
     var SceneLoader = /*#__PURE__*/ function(Loader) {
         _inherits(SceneLoader, Loader);
         function SceneLoader() {
@@ -54236,120 +54237,15 @@
                 ._request(item.url, _extends({}, item, {
                     type: "json"
                 })).then(function(data) {
-                    var _data_name;
-                    var scene = new Scene(engine, (_data_name = data.name) != null ? _data_name : "");
+                    var _data_scene_name;
+                    var scene = new Scene(engine, (_data_scene_name = data.scene.name) != null ? _data_scene_name : "");
                     var context = new ParserContext(engine, ParserType.Scene, scene);
                     var parser = new SceneParser(data, context, scene);
                     parser._collectDependentAssets(data);
                     context._setTaskCompleteProgress = setTaskCompleteProgress;
                     parser.start();
                     return parser.promise.then(function() {
-                        var promises = [];
-                        // parse ambient light
-                        var ambient = data.scene.ambient;
-                        if (ambient) {
-                            var useCustomAmbient = ambient.specularMode === SpecularMode.Custom;
-                            var useSH = ambient.diffuseMode === DiffuseMode.SphericalHarmonics;
-                            scene.ambientLight.diffuseIntensity = ambient.diffuseIntensity;
-                            scene.ambientLight.specularIntensity = ambient.specularIntensity;
-                            scene.ambientLight.diffuseMode = ambient.diffuseMode;
-                            scene.ambientLight.diffuseSolidColor.copyFrom(ambient.diffuseSolidColor);
-                            if (useCustomAmbient && ambient.customAmbientLight) {
-                                promises.push(resourceManager.getResourceByRef(ambient.customAmbientLight).then(function(ambientLight) {
-                                    scene.ambientLight.specularTexture = ambientLight == null ? void 0 : ambientLight.specularTexture;
-                                }));
-                            }
-                            if (ambient.ambientLight && (!useCustomAmbient || useSH)) {
-                                promises.push(resourceManager.getResourceByRef(ambient.ambientLight).then(function(ambientLight) {
-                                    if (!useCustomAmbient) {
-                                        scene.ambientLight.specularTexture = ambientLight == null ? void 0 : ambientLight.specularTexture;
-                                    }
-                                    if (useSH) {
-                                        scene.ambientLight.diffuseSphericalHarmonics = ambientLight == null ? void 0 : ambientLight.diffuseSphericalHarmonics;
-                                    }
-                                }));
-                            }
-                        }
-                        // parse background
-                        var background = data.scene.background;
-                        scene.background.mode = background.mode;
-                        switch(scene.background.mode){
-                            case BackgroundMode.SolidColor:
-                                scene.background.solidColor.copyFrom(background.color);
-                                break;
-                            case BackgroundMode.Sky:
-                                if (background.skyMesh && background.skyMaterial) {
-                                    // @ts-ignore
-                                    var skyMeshPromise = resourceManager.getResourceByRef(background.skyMesh).then(function(mesh) {
-                                        scene.background.sky.mesh = mesh;
-                                    });
-                                    // @ts-ignore
-                                    // prettier-ignore
-                                    var skyMaterialPromise = resourceManager.getResourceByRef(background.skyMaterial).then(function(material) {
-                                        scene.background.sky.material = material;
-                                    });
-                                    promises.push(skyMeshPromise, skyMaterialPromise);
-                                } else {
-                                    Logger.warn("Sky background mode requires skyMesh and skyMaterial");
-                                }
-                                break;
-                            case BackgroundMode.Texture:
-                                if (background.texture) {
-                                    // @ts-ignore
-                                    // prettier-ignore
-                                    var backgroundPromise = resourceManager.getResourceByRef(background.texture).then(function(texture) {
-                                        scene.background.texture = texture;
-                                    });
-                                    promises.push(backgroundPromise);
-                                    var _background_textureFillMode;
-                                    scene.background.textureFillMode = (_background_textureFillMode = background.textureFillMode) != null ? _background_textureFillMode : scene.background.textureFillMode;
-                                }
-                                break;
-                        }
-                        // parse shadow
-                        var shadow = data.scene.shadow;
-                        if (shadow) {
-                            if (shadow.castShadows != undefined) scene.castShadows = shadow.castShadows;
-                            if (shadow.shadowResolution != undefined) scene.shadowResolution = shadow.shadowResolution;
-                            if (shadow.shadowDistance != undefined) scene.shadowDistance = shadow.shadowDistance;
-                            if (shadow.shadowCascades != undefined) scene.shadowCascades = shadow.shadowCascades;
-                            if (shadow.enableTransparentShadow != undefined) {
-                                scene.enableTransparentShadow = shadow.enableTransparentShadow;
-                            }
-                            var _shadow_shadowTwoCascadeSplits;
-                            scene.shadowTwoCascadeSplits = (_shadow_shadowTwoCascadeSplits = shadow.shadowTwoCascadeSplits) != null ? _shadow_shadowTwoCascadeSplits : scene.shadowTwoCascadeSplits;
-                            shadow.shadowFourCascadeSplits && scene.shadowFourCascadeSplits.copyFrom(shadow.shadowFourCascadeSplits);
-                            var _shadow_shadowFadeBorder;
-                            scene.shadowFadeBorder = (_shadow_shadowFadeBorder = shadow.shadowFadeBorder) != null ? _shadow_shadowFadeBorder : scene.shadowFadeBorder;
-                        }
-                        // parse fog
-                        var fog = data.scene.fog;
-                        if (fog) {
-                            if (fog.fogMode != undefined) scene.fogMode = fog.fogMode;
-                            if (fog.fogStart != undefined) scene.fogStart = fog.fogStart;
-                            if (fog.fogEnd != undefined) scene.fogEnd = fog.fogEnd;
-                            if (fog.fogDensity != undefined) scene.fogDensity = fog.fogDensity;
-                            if (fog.fogColor != undefined) scene.fogColor.copyFrom(fog.fogColor);
-                        }
-                        // Post Process
-                        var postProcessData = data.scene.postProcess;
-                        if (postProcessData) {
-                            Logger.warn("Post Process is not supported in scene yet, please add PostProcess component in entity instead.");
-                        }
-                        // Ambient Occlusion
-                        var ambientOcclusion = data.scene.ambientOcclusion;
-                        if (ambientOcclusion) {
-                            var sceneAmbientOcclusion = scene.ambientOcclusion;
-                            sceneAmbientOcclusion.enabled = ambientOcclusion.enabledAmbientOcclusion;
-                            sceneAmbientOcclusion.intensity = ambientOcclusion.intensity;
-                            sceneAmbientOcclusion.radius = ambientOcclusion.radius;
-                            sceneAmbientOcclusion.bias = ambientOcclusion.bias;
-                            sceneAmbientOcclusion.power = ambientOcclusion.power;
-                            sceneAmbientOcclusion.quality = ambientOcclusion.quality;
-                            sceneAmbientOcclusion.bilateralThreshold = ambientOcclusion.bilateralThreshold;
-                            sceneAmbientOcclusion.minHorizonAngle = ambientOcclusion.minHorizonAngle;
-                        }
-                        return Promise.all(promises).then(function() {
+                        return applySceneData(scene, data.scene, resourceManager, data.refs).then(function() {
                             resolve(scene);
                         });
                     });
@@ -54857,7 +54753,7 @@
     ], EXT_texture_webp);
 
     //@ts-ignore
-    var version = "2.0.0-alpha.29";
+    var version = "2.0.0-alpha.30";
     console.log("Galacean Engine Version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);