@galacean/engine-loader 2.0.0-alpha.29 → 2.0.0-alpha.31

package/dist/main.js

@@ -643,37 +643,27 @@ function float32ArrayToVector2(float32Array, vertexCount) {
     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() {
-        return !!result;
-    })();
-}
-
-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();
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
 
-            if (Class) _set_prototype_of(instance, Class.prototype);
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
 
-            return instance;
-        };
+    for (i = 0; i < sourceKeys.length; i++) {
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
     }
 
-    return _construct.apply(null, arguments);
+    return target;
+}
+
+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 refs[index];
 }
 
 var ParserType = /*#__PURE__*/ function(ParserType) {
@@ -689,32 +679,20 @@ var ParserType = /*#__PURE__*/ function(ParserType) {
         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);
@@ -724,230 +702,214 @@ var ParserType = /*#__PURE__*/ function(ParserType) {
 }();
 
 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 = engineCore.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, $class, $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(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(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_of(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 engineCore.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. { $class }     → registered class constructor
+   * 6. { $entity }    → entity reference by path (flat index + optional children descent)
+   * 7. { $component } → component reference
+   * 8. { $signal }    → signal binding
+   * 9. plain object   → recurse values (modify originValue in place if exists)
+   */ _proto._resolveValue = function _resolveValue(value, originValue) {
+        var _this, _loop = function(key) {
+            promises.push(_this._resolveValue(obj[key], target[key]).then(function(v) {
+                return target[key] = v;
             }));
-        } else if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value != null) {
-            if (ReflectionParser._isClassType(value)) {
-                return Promise.resolve(engineCore.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 = engineCore.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(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_of(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 engineCore.Entity(engine, entityConfig.name, transform ? engineCore.Loader.getClass(transform.class) : engineCore.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"
+            ]);
+            return this._resolveRegisteredClass($type, "$type").then(function(Class) {
+                var instance = new Class();
+                return Object.keys(rest).length > 0 ? _this1.parseProps(instance, rest) : instance;
+            });
         }
-        return entity;
-    };
-    ReflectionParser._isClass = function _isClass(value) {
-        return value["class"] !== undefined;
-    };
-    ReflectionParser._isClassType = function _isClassType(value) {
-        return value["classType"] !== undefined;
+        // $class — registered class constructor for factory-style methods.
+        if ("$class" in obj) {
+            return this._resolveRegisteredClass(obj.$class, "$class");
+        }
+        // $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_of(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._isAssetRef = function _isAssetRef(value) {
-        return value["url"] !== undefined;
+    _proto._getRegisteredClass = function _getRegisteredClass(value, sentinel) {
+        if (typeof value !== "string" || value.length === 0) {
+            throw new Error("" + sentinel + " must be a non-empty registered class name string");
+        }
+        var Class = engineCore.Loader.getClass(value);
+        if (!Class) throw new Error('Loader.getClass: class "' + value + '" is not registered');
+        return Class;
     };
-    ReflectionParser._isEntityRef = function _isEntityRef(value) {
-        return Array.isArray(value["entityPath"]) && value["componentType"] === undefined;
+    /** Promise-adapt {@link _getRegisteredClass} so $type/$class branches can fold into the resolver chain. */ _proto._resolveRegisteredClass = function _resolveRegisteredClass(value, sentinel) {
+        try {
+            return Promise.resolve(this._getRegisteredClass(value, sentinel));
+        } catch (error) {
+            return Promise.reject(error);
+        }
     };
-    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 = engineCore.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.
@@ -1249,45 +1211,6 @@ function _instanceof(left, right) {
     } else return left instanceof 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) {
@@ -1319,8 +1242,9 @@ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
     };
     _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 (_instanceof(asset, engineCore.ReferResource)) {
                 // @ts-ignore
@@ -1336,319 +1260,260 @@ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
         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(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(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 engineCore.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 engineCore.Entity(engine, entityConfig.name, transform ? engineCore.Loader.getClass(transform.class) : engineCore.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 = _instanceof(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(engineCore.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 = engineCore.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 = engineCore.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 = engineCore.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) {
@@ -1662,91 +1527,43 @@ var SpecularMode = /*#__PURE__*/ function(SpecularMode) {
    */ _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 === engineCore.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 === engineCore.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 === engineCore.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_of(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[SpecularMode["Sky"] = 0] = "Sky";
+    SpecularMode[SpecularMode["Custom"] = 1] = "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
@@ -3228,6 +3045,45 @@ function getMeshoptDecoder() {
     return GLTFResource;
 }(engineCore.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
  */ /**
@@ -5497,15 +5353,17 @@ var PrefabParser = /*#__PURE__*/ function(HierarchyParser) {
         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();
@@ -5516,9 +5374,7 @@ var PrefabParser = /*#__PURE__*/ function(HierarchyParser) {
         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);
@@ -5858,15 +5714,6 @@ var KTXContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
     return KTXContentRestorer;
 }(engineCore.ContentRestorer);
 
-function parseProperty(object, key, value) {
-    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === "object") {
-        for(var subKey in value){
-            parseProperty(object[key], subKey, value[subKey]);
-        }
-    } else {
-        object[key] = value;
-    }
-}
 var MaterialLoader = /*#__PURE__*/ function(Loader) {
     _inherits(MaterialLoader, Loader);
     function MaterialLoader() {
@@ -5927,7 +5774,7 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                     break;
             }
         };
-        var name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros, renderState = materialSchema.renderState;
+        var name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros;
         var material = new engineCore.Material(engine, shader);
         material.name = name;
         var texturePromises = new Array();
@@ -5941,7 +5788,6 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                 materialShaderData.enableMacro(name1, value);
             }
         }
-        parseProperty(material, "renderState", renderState);
         return Promise.all(texturePromises).then(function() {
             return material;
         });
@@ -6483,51 +6329,6 @@ AudioLoader = __decorate([
     ])
 ], AudioLoader);
 
-var ShaderChunkLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(ShaderChunkLoader, Loader);
-    function ShaderChunkLoader() {
-        return Loader.apply(this, arguments) || this;
-    }
-    var _proto = ShaderChunkLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        var url = item.url;
-        // @ts-ignore
-        return resourceManager._request(url, _extends({}, item, {
-            type: "text"
-        })).then(function(code) {
-            engineCore.ShaderFactory.registerInclude(url.substring(1), code);
-            return ShaderChunkLoader._loadChunksInCode(code, url, resourceManager);
-        });
-    };
-    /**
-   * @internal
-   */ ShaderChunkLoader._loadChunksInCode = function _loadChunksInCode(code, basePath, resourceManager) {
-        var shaderChunkPaths = new Array();
-        var matches = code.matchAll(ShaderChunkLoader._shaderIncludeRegex);
-        for(var _iterator = _create_for_of_iterator_helper_loose(matches), _step; !(_step = _iterator()).done;){
-            var match = _step.value;
-            var chunkPath = engineCore.Utils.resolveAbsoluteUrl(basePath, match[1]);
-            if (!engineCore.ShaderLib[chunkPath.substring(1)]) {
-                shaderChunkPaths.push(chunkPath);
-            }
-        }
-        return Promise.all(shaderChunkPaths.map(function(chunkPath) {
-            // @ts-ignore
-            return resourceManager.load({
-                type: "ShaderChunk",
-                url: chunkPath
-            });
-        }));
-    };
-    return ShaderChunkLoader;
-}(engineCore.Loader);
-ShaderChunkLoader._shaderIncludeRegex = /#include\s+"([./][^\\"]+)"/gm;
-ShaderChunkLoader = __decorate([
-    engineCore.resourceLoader("ShaderChunk", [
-        "glsl"
-    ])
-], ShaderChunkLoader);
-
 var ShaderLoader = /*#__PURE__*/ function(Loader) {
     _inherits(ShaderLoader, Loader);
     function ShaderLoader() {
@@ -6537,7 +6338,7 @@ var ShaderLoader = /*#__PURE__*/ function(Loader) {
     _proto.load = function load(item, resourceManager) {
         var _this = this;
         var url = item.url;
-        if (url.endsWith(".gsp")) {
+        if (url.endsWith(".shaderc")) {
             // @ts-ignore
             return resourceManager._request(url, _extends({}, item, {
                 type: "json"
@@ -6554,10 +6355,7 @@ var ShaderLoader = /*#__PURE__*/ function(Loader) {
             if (builtinShader) {
                 return engineCore.Shader.find(builtinShader);
             }
-            return ShaderChunkLoader._loadChunksInCode(code, url, resourceManager).then(function() {
-                var shader = engineCore.Shader.create(code, undefined, url);
-                return shader;
-            });
+            return engineCore.Shader.create(code, undefined, url);
         });
     };
     _proto._getBuiltinShader = function _getBuiltinShader(code) {
@@ -6569,7 +6367,8 @@ var ShaderLoader = /*#__PURE__*/ function(Loader) {
 ShaderLoader._builtinRegex = /^\s*\/\/\s*@builtin\s+(\w+)/;
 ShaderLoader = __decorate([
     engineCore.resourceLoader(engineCore.AssetType.Shader, [
-        "shader"
+        "shader",
+        "shaderc"
     ])
 ], ShaderLoader);
 
@@ -6649,6 +6448,122 @@ RenderTargetLoader = __decorate([
     ])
 ], 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 === engineCore.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 engineCore.BackgroundMode.SolidColor:
+                {
+                    var color = background.color;
+                    scene.background.solidColor.set(color[0], color[1], color[2], color[3]);
+                    break;
+                }
+            case engineCore.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 {
+                    engineCore.Logger.warn("Sky background mode requires skyMesh and skyMaterial");
+                }
+                break;
+            case engineCore.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) {
+        engineCore.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() {
@@ -6662,122 +6577,15 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
             ._request(item.url, _extends({}, item, {
                 type: "json"
             })).then(function(data) {
-                var _data_name;
-                var scene = new engineCore.Scene(engine, (_data_name = data.name) != null ? _data_name : "");
+                var _data_scene_name;
+                var scene = new engineCore.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 === engineCore.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(// @ts-ignore
-                            resourceManager.getResourceByRef(ambient.customAmbientLight).then(function(ambientLight) {
-                                scene.ambientLight.specularTexture = ambientLight == null ? void 0 : ambientLight.specularTexture;
-                            }));
-                        }
-                        if (ambient.ambientLight && (!useCustomAmbient || useSH)) {
-                            promises.push(// @ts-ignore
-                            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 engineCore.BackgroundMode.SolidColor:
-                            scene.background.solidColor.copyFrom(background.color);
-                            break;
-                        case engineCore.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 {
-                                engineCore.Logger.warn("Sky background mode requires skyMesh and skyMaterial");
-                            }
-                            break;
-                        case engineCore.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) {
-                        engineCore.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);
                     });
                 });