@galacean/engine-loader 0.0.0-experimental-2.0-game.18 → 0.0.0-experimental-2.0-spine.1

package/dist/main.js

@@ -676,6 +676,29 @@ function _construct(Parent, args, Class) {
     return _construct.apply(null, arguments);
 }
 
+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 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) {
     ParserType[ParserType["Prefab"] = 0] = "Prefab";
     ParserType[ParserType["Scene"] = 1] = "Scene";
@@ -689,32 +712,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,243 +735,446 @@ 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; optional $args are constructor args
+   * 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. { $props/$calls } → mutate the existing target object
+   * 10. 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], target1[key]).then(function(v) {
+                return target1[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);
-                // Try direct components first, fallback to children search (for GLB clone entities
-                // where the component lives on a child entity inside the clone)
-                var direct = entity.getComponents(type, []);
-                var result = direct[value.componentIndex];
-                if (result) return Promise.resolve(result);
-                var includeChildren = [];
-                entity.getComponentsIncludeChildren(type, includeChildren);
-                var _includeChildren_value_componentIndex;
-                return Promise.resolve((_includeChildren_value_componentIndex = includeChildren[value.componentIndex]) != null ? _includeChildren_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);
         }
+        // $type — polymorphic type: construct instance and apply remaining props
+        if ("$type" in obj) {
+            var $type = obj.$type, $args = obj.$args, $props = obj.$props, $calls = obj.$calls, rest = _object_without_properties_loose(obj, [
+                "$type",
+                "$args",
+                "$props",
+                "$calls"
+            ]);
+            return this._resolveRegisteredClass($type, "$type").then(function(Class) {
+                if ($args !== undefined && !Array.isArray($args)) {
+                    return Promise.reject(new Error("$type.$args must be an array"));
+                }
+                return Promise.all(($args != null ? $args : []).map(function(arg) {
+                    return _this1._resolveValue(arg);
+                })).then(function(resolvedArgs) {
+                    var instance = _construct(Class, [].concat(resolvedArgs));
+                    return _this1._applyRuntimeMutation(instance, Object.keys(rest).length > 0 ? rest : undefined, $props, $calls);
+                });
+            });
+        }
+        // $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);
+        }
+        // Runtime mutation block for existing nested objects.
+        if ("$props" in obj || "$calls" in obj) {
+            var target = originValue && (typeof originValue === "undefined" ? "undefined" : _type_of(originValue)) === "object" && !Array.isArray(originValue) ? originValue : {};
+            return this._applyRuntimeMutation(target, undefined, obj.$props, obj.$calls);
+        }
+        // Plain object — recurse each value, modifying originValue in place or building a new object
+        var target1 = 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 target1;
+        });
     };
-    _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]];
+    _proto._applyRuntimeMutation = function _applyRuntimeMutation(target, directProps, runtimeProps, runtimeCalls) {
+        var props = directProps ? _extends({}, directProps) : undefined;
+        var calls;
+        try {
+            var normalizedProps = this._normalizeRuntimeProps(runtimeProps);
+            if (normalizedProps) {
+                props = Object.assign(props != null ? props : {}, normalizedProps);
+            }
+            calls = this._normalizeRuntimeCalls(runtimeCalls);
+        } catch (error) {
+            return Promise.reject(error);
         }
-        return entity;
+        return this.parseMutationBlock(target, {
+            props: props,
+            calls: calls
+        });
     };
-    ReflectionParser._isClass = function _isClass(value) {
-        return value["class"] !== undefined;
+    _proto._normalizeRuntimeProps = function _normalizeRuntimeProps(props) {
+        if (props === undefined) return undefined;
+        if (props == null || (typeof props === "undefined" ? "undefined" : _type_of(props)) !== "object" || Array.isArray(props)) {
+            throw new Error("$props must be an object");
+        }
+        return props;
     };
-    ReflectionParser._isClassType = function _isClassType(value) {
-        return value["classType"] !== undefined;
+    _proto._normalizeRuntimeCalls = function _normalizeRuntimeCalls(calls) {
+        if (calls === undefined) return undefined;
+        if (!Array.isArray(calls)) {
+            throw new Error("$calls must be an array");
+        }
+        return calls;
     };
-    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.
+ *
+ * Decodes .hdr files into pixel data. Supports parsing the header
+ * and decoding RLE-compressed RGBE scanlines into R16G16B16A16 half-float pixels.
+ */ var HDRDecoder = /*#__PURE__*/ function() {
+    function HDRDecoder() {}
+    /**
+   * Parse the header of an HDR file.
+   * @returns Header info including width, height, and data start position.
+   */ HDRDecoder.parseHeader = function parseHeader(uint8array) {
+        var line = this._readStringLine(uint8array, 0);
+        if (line[0] !== "#" || line[1] !== "?") {
+            throw "HDRDecoder: invalid file header";
+        }
+        var endOfHeader = false;
+        var findFormat = false;
+        var lineIndex = 0;
+        do {
+            lineIndex += line.length + 1;
+            line = this._readStringLine(uint8array, lineIndex);
+            if (line === "FORMAT=32-bit_rle_rgbe") findFormat = true;
+            else if (line.length === 0) endOfHeader = true;
+        }while (!endOfHeader);
+        if (!findFormat) {
+            throw "HDRDecoder: unsupported format, expected 32-bit_rle_rgbe";
+        }
+        lineIndex += line.length + 1;
+        line = this._readStringLine(uint8array, lineIndex);
+        var match = /^\-Y (.*) \+X (.*)$/g.exec(line);
+        if (!match || match.length < 3) {
+            throw "HDRDecoder: missing image size, only -Y +X layout is supported";
+        }
+        var width = parseInt(match[2]);
+        var height = parseInt(match[1]);
+        if (width < 8 || width > 0x7fff) {
+            throw "HDRDecoder: unsupported image width, must be between 8 and 32767";
+        }
+        return {
+            height: height,
+            width: width,
+            dataPosition: lineIndex + line.length + 1
+        };
+    };
+    /**
+   * Decode an HDR file buffer into R16G16B16A16 half-float pixel data.
+   * @param buffer - The full HDR file as Uint8Array.
+   * @returns Object with width, height, and half-float pixel data.
+   */ HDRDecoder.decode = function decode(buffer) {
+        var header = this.parseHeader(buffer);
+        var width = header.width, height = header.height, dataPosition = header.dataPosition;
+        var rgbe = this._readPixels(buffer.subarray(dataPosition), width, height);
+        var pixels = this._rgbeToHalfFloat(rgbe, width, height);
+        return {
+            width: width,
+            height: height,
+            pixels: pixels
+        };
+    };
+    /**
+   * Convert RGBE pixel data to R16G16B16A16 half-float.
+   */ HDRDecoder._rgbeToHalfFloat = function _rgbeToHalfFloat(rgbe, width, height) {
+        var floatView = this._floatView;
+        var uint32View = this._uint32View;
+        var _this__float2HalfTables = this._float2HalfTables, baseTable = _this__float2HalfTables.baseTable, shiftTable = _this__float2HalfTables.shiftTable;
+        var one = 0x3c00; // Half float 1.0
+        var pixelCount = width * height;
+        var result = new Uint16Array(pixelCount * 4);
+        for(var i = 0; i < pixelCount; i++){
+            var srcIdx = i * 4;
+            var dstIdx = i * 4;
+            var scaleFactor = Math.pow(2, rgbe[srcIdx + 3] - 128 - 8);
+            for(var c = 0; c < 3; c++){
+                floatView[0] = Math.min(rgbe[srcIdx + c] * scaleFactor, 65504);
+                var f = uint32View[0];
+                var e = f >> 23 & 0x1ff;
+                result[dstIdx + c] = baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);
+            }
+            result[dstIdx + 3] = one;
+        }
+        return result;
+    };
+    /**
+   * Decode RLE-compressed RGBE scanlines into raw RGBE pixel data.
+   */ HDRDecoder._readPixels = function _readPixels(buffer, width, height) {
+        var byteLength = buffer.byteLength;
+        var dataRGBA = new Uint8Array(4 * width * height);
+        var offset = 0;
+        var pos = 0;
+        var ptrEnd = 4 * width;
+        var scanLineBuffer = new Uint8Array(ptrEnd);
+        var numScanLines = height;
+        while(numScanLines > 0 && pos < byteLength){
+            var a = buffer[pos++];
+            var b = buffer[pos++];
+            var c = buffer[pos++];
+            var d = buffer[pos++];
+            if (a !== 2 || b !== 2 || c & 0x80 || width < 8 || width > 32767) return buffer;
+            if ((c << 8 | d) !== width) throw "HDRDecoder: wrong scanline width";
+            var ptr = 0;
+            while(ptr < ptrEnd && pos < byteLength){
+                var count = buffer[pos++];
+                var isEncodedRun = count > 128;
+                if (isEncodedRun) count -= 128;
+                if (count === 0 || ptr + count > ptrEnd) throw "HDRDecoder: bad scanline data";
+                if (isEncodedRun) {
+                    var byteValue = buffer[pos++];
+                    for(var i = 0; i < count; i++)scanLineBuffer[ptr++] = byteValue;
+                } else {
+                    scanLineBuffer.set(buffer.subarray(pos, pos + count), ptr);
+                    ptr += count;
+                    pos += count;
+                }
+            }
+            for(var i1 = 0; i1 < width; i1++, offset += 4){
+                dataRGBA[offset] = scanLineBuffer[i1];
+                dataRGBA[offset + 1] = scanLineBuffer[i1 + width];
+                dataRGBA[offset + 2] = scanLineBuffer[i1 + width * 2];
+                dataRGBA[offset + 3] = scanLineBuffer[i1 + width * 3];
+            }
+            numScanLines--;
+        }
+        return dataRGBA;
+    };
+    HDRDecoder._generateFloat2HalfTables = function _generateFloat2HalfTables() {
+        var baseTable = new Uint32Array(512);
+        var shiftTable = new Uint32Array(512);
+        for(var i = 0; i < 256; ++i){
+            var e = i - 127;
+            if (e < -27) {
+                baseTable[i] = 0x0000;
+                baseTable[i | 0x100] = 0x8000;
+                shiftTable[i] = 24;
+                shiftTable[i | 0x100] = 24;
+            } else if (e < -14) {
+                baseTable[i] = 0x0400 >> -e - 14;
+                baseTable[i | 0x100] = 0x0400 >> -e - 14 | 0x8000;
+                shiftTable[i] = -e - 1;
+                shiftTable[i | 0x100] = -e - 1;
+            } else if (e <= 15) {
+                baseTable[i] = e + 15 << 10;
+                baseTable[i | 0x100] = e + 15 << 10 | 0x8000;
+                shiftTable[i] = 13;
+                shiftTable[i | 0x100] = 13;
+            } else if (e < 128) {
+                baseTable[i] = 0x7c00;
+                baseTable[i | 0x100] = 0xfc00;
+                shiftTable[i] = 24;
+                shiftTable[i | 0x100] = 24;
+            } else {
+                baseTable[i] = 0x7c00;
+                baseTable[i | 0x100] = 0xfc00;
+                shiftTable[i] = 13;
+                shiftTable[i | 0x100] = 13;
+            }
+        }
+        return {
+            baseTable: baseTable,
+            shiftTable: shiftTable
+        };
+    };
+    HDRDecoder._readStringLine = function _readStringLine(uint8array, startIndex) {
+        var line = "";
+        for(var i = startIndex, n = uint8array.length; i < n; i++){
+            var character = String.fromCharCode(uint8array[i]);
+            if (character === "\n") break;
+            line += character;
+        }
+        return line;
+    };
+    return HDRDecoder;
+}();
+HDRDecoder._float2HalfTables = HDRDecoder._generateFloat2HalfTables();
+HDRDecoder._floatView = new Float32Array(1);
+HDRDecoder._uint32View = new Uint32Array(HDRDecoder._floatView.buffer);
 
-exports.Texture2DDecoder = /*#__PURE__*/ function() {
+/**
+ * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
+ * [format(1B)] [width(2B)] [height(2B)] [isSRGBColorSpace(1B)] [Uint32(imageSize) + imageBytes]
+ */ var Texture2DDecoder = /*#__PURE__*/ function() {
     function Texture2DDecoder() {}
     Texture2DDecoder.decode = function decode(engine, bufferReader, restoredTexture) {
         return new engineCore.AssetPromise(function(resolve, reject) {
-            var url = bufferReader.nextStr();
+            bufferReader.nextStr();
             var mipmap = !!bufferReader.nextUint8();
             var filterMode = bufferReader.nextUint8();
             var anisoLevel = bufferReader.nextUint8();
@@ -969,58 +1183,34 @@ exports.Texture2DDecoder = /*#__PURE__*/ function() {
             var format = bufferReader.nextUint8();
             var width = bufferReader.nextUint16();
             var height = bufferReader.nextUint16();
-            var isPixelBuffer = bufferReader.nextUint8();
             var isSRGBColorSpace = !!bufferReader.nextUint8();
-            var mipCount = bufferReader.nextUint8();
-            var imagesData = bufferReader.nextImagesData(mipCount);
-            var texture2D = restoredTexture || new engineCore.Texture2D(engine, width, height, format, mipmap, isSRGBColorSpace);
-            texture2D.filterMode = filterMode;
-            texture2D.anisoLevel = anisoLevel;
-            texture2D.wrapModeU = wrapModeU;
-            texture2D.wrapModeV = wrapModeV;
-            if (isPixelBuffer) {
-                var pixelBuffer = imagesData[0];
-                texture2D.setPixelBuffer(pixelBuffer);
-                if (mipmap) {
-                    texture2D.generateMipmaps();
-                    for(var i = 1; i < mipCount; i++){
-                        var pixelBuffer1 = imagesData[i];
-                        texture2D.setPixelBuffer(pixelBuffer1, i);
-                    }
-                }
-                // @ts-ignore
-                engine.resourceManager._objectPool[url] = texture2D;
-                resolve(texture2D);
+            var imageData = bufferReader.nextImagesData(1)[0];
+            var isHDR = imageData[0] === 0x23 && imageData[1] === 0x3f;
+            var textureFormat = isHDR ? engineCore.TextureFormat.R16G16B16A16 : format;
+            var texture = restoredTexture || new engineCore.Texture2D(engine, width, height, textureFormat, mipmap, isHDR ? false : isSRGBColorSpace);
+            texture.filterMode = filterMode;
+            texture.anisoLevel = anisoLevel;
+            texture.wrapModeU = wrapModeU;
+            texture.wrapModeV = wrapModeV;
+            if (isHDR) {
+                var pixels = HDRDecoder.decode(imageData).pixels;
+                texture.setPixelBuffer(pixels);
+                mipmap && texture.generateMipmaps();
+                resolve(texture);
             } else {
-                var blob = new window.Blob([
-                    imagesData[0]
+                var blob = new Blob([
+                    imageData
                 ]);
                 var img = new Image();
                 img.onload = function() {
-                    texture2D.setImageSource(img);
-                    var completedCount = 0;
-                    var onComplete = function() {
-                        completedCount++;
-                        if (completedCount >= mipCount) {
-                            resolve(texture2D);
-                        }
-                    };
-                    onComplete();
-                    if (mipmap) {
-                        var _loop = function(i) {
-                            var blob = new window.Blob([
-                                imagesData[i]
-                            ]);
-                            var img = new Image();
-                            img.onload = function() {
-                                texture2D.setImageSource(img, i);
-                                onComplete();
-                            };
-                            img.src = URL.createObjectURL(blob);
-                        };
-                        texture2D.generateMipmaps();
-                        for(var i = 1; i < mipCount; i++)_loop(i);
-                    }
+                    URL.revokeObjectURL(img.src);
+                    texture.setImageSource(img);
+                    mipmap && texture.generateMipmaps();
+                    resolve(texture);
+                };
+                img.onerror = function(e) {
+                    URL.revokeObjectURL(img.src);
+                    reject(e);
                 };
                 img.src = URL.createObjectURL(blob);
             }
@@ -1028,9 +1218,72 @@ exports.Texture2DDecoder = /*#__PURE__*/ function() {
     };
     return Texture2DDecoder;
 }();
-exports.Texture2DDecoder = __decorate([
+Texture2DDecoder = __decorate([
     decoder("Texture2D")
-], exports.Texture2DDecoder);
+], Texture2DDecoder);
+
+/**
+ * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
+ * [format(1B)] [faceSize(2B)] [isSRGBColorSpace(1B)] [Uint32(size) + faceBytes] × 6
+ */ var TextureCubeDecoder = /*#__PURE__*/ function() {
+    function TextureCubeDecoder() {}
+    TextureCubeDecoder.decode = function decode(engine, bufferReader, restoredTexture) {
+        return new engineCore.AssetPromise(function(resolve, reject) {
+            bufferReader.nextStr();
+            var mipmap = !!bufferReader.nextUint8();
+            var filterMode = bufferReader.nextUint8();
+            var anisoLevel = bufferReader.nextUint8();
+            var wrapModeU = bufferReader.nextUint8();
+            var wrapModeV = bufferReader.nextUint8();
+            var format = bufferReader.nextUint8();
+            var faceSize = bufferReader.nextUint16();
+            var isSRGBColorSpace = !!bufferReader.nextUint8();
+            var facesData = bufferReader.nextImagesData(6);
+            // Detect format by first face's magic bytes
+            var isHDR = facesData[0][0] === 0x23 && facesData[0][1] === 0x3f;
+            var textureFormat = isHDR ? engineCore.TextureFormat.R16G16B16A16 : format;
+            var texture = restoredTexture || new engineCore.TextureCube(engine, faceSize, textureFormat, mipmap, isSRGBColorSpace);
+            texture.filterMode = filterMode;
+            texture.anisoLevel = anisoLevel;
+            texture.wrapModeU = wrapModeU;
+            texture.wrapModeV = wrapModeV;
+            if (isHDR) {
+                for(var i = 0; i < 6; i++){
+                    var pixels = HDRDecoder.decode(facesData[i]).pixels;
+                    texture.setPixelBuffer(engineCore.TextureCubeFace.PositiveX + i, pixels, 0);
+                }
+                mipmap && texture.generateMipmaps();
+                resolve(texture);
+            } else {
+                var _loop = function(i1) {
+                    var blob = new Blob([
+                        facesData[i1]
+                    ]);
+                    var img = new Image();
+                    img.onload = function() {
+                        URL.revokeObjectURL(img.src);
+                        texture.setImageSource(engineCore.TextureCubeFace.PositiveX + i1, img);
+                        if (++loadedCount === 6) {
+                            mipmap && texture.generateMipmaps();
+                            resolve(texture);
+                        }
+                    };
+                    img.onerror = function(e) {
+                        URL.revokeObjectURL(img.src);
+                        reject(e);
+                    };
+                    img.src = URL.createObjectURL(blob);
+                };
+                var loadedCount = 0;
+                for(var i1 = 0; i1 < 6; i1++)_loop(i1);
+            }
+        });
+    };
+    return TextureCubeDecoder;
+}();
+TextureCubeDecoder = __decorate([
+    decoder("TextureCube")
+], TextureCubeDecoder);
 
 function _instanceof(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
@@ -1038,45 +1291,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) {
@@ -1108,8 +1322,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
@@ -1125,319 +1340,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) {
@@ -1451,91 +1607,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.rootEntities;
+    };
+    _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
@@ -3017,6 +3125,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
  */ /**
@@ -3638,11 +3785,13 @@ function registerGLTFParser(pipeline) {
             });
             var img = new Image();
             img.onerror = function() {
+                URL.revokeObjectURL(img.src);
                 reject(new Error("Failed to load image buffer"));
             };
             img.onload = function() {
                 // Call requestAnimationFrame to avoid iOS's bug.
                 requestAnimationFrame(function() {
+                    URL.revokeObjectURL(img.src);
                     resolve(img);
                     img.onload = null;
                     img.onerror = null;
@@ -4763,7 +4912,6 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
     }
     var _proto = GLTFSceneParser.prototype;
     _proto.parse = function parse(context, index) {
-        var _glTFResource;
         var _context_glTF = context.glTF, scenes = _context_glTF.scenes, _context_glTF_scene = _context_glTF.scene, scene = _context_glTF_scene === void 0 ? 0 : _context_glTF_scene, glTFResource = context.glTFResource;
         var sceneInfo = scenes[index];
         var sceneExtensions = sceneInfo.extensions;
@@ -4777,7 +4925,6 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
         for(var i = 0; i < sceneNodes.length; i++){
             sceneRoot.addChild(context.get(GLTFParserType.Entity, sceneNodes[i]));
         }
-        ((_glTFResource = glTFResource)._sceneRoots || (_glTFResource._sceneRoots = []))[index] = sceneRoot;
         if (isDefaultScene) {
             glTFResource._defaultSceneRoot = sceneRoot;
         }
@@ -4907,13 +5054,15 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
         if (rootBoneIndex !== -1) {
             engineMath.BoundingBox.transform(mesh.bounds, inverseBindMatrices[rootBoneIndex], skinnedMeshRenderer.localBounds);
         } else {
-            var inverseRootBoneWorld = new engineMath.Matrix();
+            // rootBone can be outside skin.joints, so it has no inverse bind matrix
+            var inverseRootBoneWorld = GLTFSceneParser._tempMatrix;
             engineMath.Matrix.invert(rootBone.transform.worldMatrix, inverseRootBoneWorld);
             engineMath.BoundingBox.transform(mesh.bounds, inverseRootBoneWorld, skinnedMeshRenderer.localBounds);
         }
     };
     return GLTFSceneParser;
 }(GLTFParser);
+exports.GLTFSceneParser._tempMatrix = new engineMath.Matrix();
 exports.GLTFSceneParser = __decorate([
     registerGLTFParser(GLTFParserType.Scene)
 ], exports.GLTFSceneParser);
@@ -4948,36 +5097,31 @@ exports.GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
                 skin.joints[i] = bone.name;
             }
             skin.bones = bones;
-            // Get skeleton
+            // Get skeleton — when `skin.skeleton` is absent, resolve via joints' LCA
+            // LCA falls back to the GLTF_ROOT wrapper only when joints span multiple top-level scene nodes
             if (skeleton !== undefined) {
                 var rootBone = entities[skeleton];
+                if (!rootBone) {
+                    throw "Skin skeleton index " + skeleton + " is out of range.";
+                }
                 skin.rootBone = rootBone;
             } else {
-                var rootBone1 = _this._findSkinRootBoneByLCA(index, joints, entities, glTF.nodes);
-                if (rootBone1) {
-                    skin.rootBone = rootBone1;
-                } else {
+                var rootBone1 = _this._findSkeletonRootBone(joints, entities);
+                if (!rootBone1) {
                     throw "Failed to find skeleton root bone.";
                 }
+                skin.rootBone = rootBone1;
             }
             return skin;
         });
         return engineCore.AssetPromise.resolve(skinPromise);
     };
-    _proto._findSkinRootBoneByLCA = function _findSkinRootBoneByLCA(skinIndex, joints, entities, nodes) {
-        if (nodes === void 0) nodes = [];
-        var nodeIndices = joints.slice();
-        for(var i = 0, n = nodes.length; i < n; i++){
-            var _nodes_i;
-            if (((_nodes_i = nodes[i]) == null ? void 0 : _nodes_i.skin) === skinIndex) {
-                nodeIndices.push(i);
-            }
-        }
-        return this._findRootBoneByLCA(nodeIndices, entities);
-    };
-    _proto._findRootBoneByLCA = function _findRootBoneByLCA(nodeIndices, entities) {
-        var paths = [];
-        for(var _iterator = _create_for_of_iterator_helper_loose(nodeIndices), _step; !(_step = _iterator()).done;){
+    /**
+   * Resolve the skeleton rootBone as the lowest common ancestor of the joints' parent chains.
+   * Returns null when joints share no common ancestor.
+   */ _proto._findSkeletonRootBone = function _findSkeletonRootBone(joints, entities) {
+        var paths = {};
+        for(var _iterator = _create_for_of_iterator_helper_loose(joints), _step; !(_step = _iterator()).done;){
             var index = _step.value;
             var path = new Array();
             var entity = entities[index];
@@ -4985,22 +5129,17 @@ exports.GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
                 path.unshift(entity);
                 entity = entity.parent;
             }
-            if (path.length) {
-                paths.push(path);
-            }
-        }
-        if (!paths.length) {
-            return null;
+            paths[index] = path;
         }
         var rootNode = null;
         for(var i = 0;; i++){
-            var path1 = paths[0];
+            var path1 = paths[joints[0]];
             if (i >= path1.length) {
                 return rootNode;
             }
             var entity1 = path1[i];
-            for(var j = 1, m = paths.length; j < m; j++){
-                path1 = paths[j];
+            for(var j = 1, m = joints.length; j < m; j++){
+                path1 = paths[joints[j]];
                 if (i >= path1.length || entity1 !== path1[i]) {
                     return rootNode;
                 }
@@ -5063,7 +5202,7 @@ exports.GLTFTextureParser = /*#__PURE__*/ function(GLTFParser1) {
         if (uri) {
             var extIndex = uri.lastIndexOf(".");
             var ext = uri.substring(extIndex + 1);
-            var type = ext.startsWith("ktx") ? engineCore.AssetType.KTX : engineCore.AssetType.Texture2D;
+            var type = ext.startsWith("ktx") ? engineCore.AssetType.KTX : engineCore.AssetType.Texture;
             texture = engine.resourceManager.load({
                 url: engineCore.Utils.resolveAbsoluteUrl(url, uri),
                 type: type,
@@ -5280,15 +5419,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();
@@ -5299,9 +5440,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);
@@ -5641,15 +5780,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() {
@@ -5710,7 +5840,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();
@@ -5724,7 +5854,6 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                 materialShaderData.enableMacro(name1, value);
             }
         }
-        parseProperty(material, "renderState", renderState);
         return Promise.all(texturePromises).then(function() {
             return material;
         });
@@ -5939,7 +6068,7 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader) {
                         var _atlasItem_type;
                         chainPromises.push(resourceManager.load({
                             url: engineCore.Utils.resolveAbsoluteUrl(item.url, atlasItem.img),
-                            type: (_atlasItem_type = atlasItem.type) != null ? _atlasItem_type : engineCore.AssetType.Texture2D,
+                            type: (_atlasItem_type = atlasItem.type) != null ? _atlasItem_type : engineCore.AssetType.Texture,
                             params: {
                                 format: format,
                                 mipmap: mipmap
@@ -5989,8 +6118,7 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader) {
                 var offsetLeft = atlasRegionOffset.x, offsetTop = atlasRegionOffset.y, offsetRight = atlasRegionOffset.z, offsetBottom = atlasRegionOffset.w;
                 sprite.atlasRegionOffset.set(offsetLeft * invW, offsetTop * invH, offsetRight * invW, offsetBottom * invH);
             }
-            var _config_atlasRotated;
-            sprite.atlasRotated = (_config_atlasRotated = config.atlasRotated) != null ? _config_atlasRotated : false;
+            config.atlasRotated && (sprite.atlasRotated = true);
         }
         width === undefined || (sprite.width = width);
         height === undefined || (sprite.height = height);
@@ -6019,517 +6147,210 @@ var SpriteLoader = /*#__PURE__*/ function(Loader) {
             return data.belongToAtlas ? _this._loadFromAtlas(resourceManager, data) : _this._loadFromTexture(resourceManager, data);
         });
     };
-    _proto._loadFromAtlas = function _loadFromAtlas(resourceManager, data) {
-        var _this = this;
-        return resourceManager// @ts-ignore
-        .getResourceByRef(data.belongToAtlas).then(function(atlas) {
-            return atlas.getSprite(data.fullPath) || _this._loadFromTexture(resourceManager, data);
-        });
-    };
-    _proto._loadFromTexture = function _loadFromTexture(resourceManager, data) {
-        if (data.texture) {
-            return resourceManager// @ts-ignore
-            .getResourceByRef(data.texture).then(function(texture) {
-                var sprite = new engineCore.Sprite(resourceManager.engine, texture, data.region, data.pivot, data.border);
-                var width = data.width, height = data.height;
-                width === undefined || (sprite.width = width);
-                height === undefined || (sprite.height = height);
-                return sprite;
-            });
-        } else {
-            return new engineCore.AssetPromise(function(resolve) {
-                var sprite = new engineCore.Sprite(resourceManager.engine, null, data.region, data.pivot, data.border);
-                var width = data.width, height = data.height;
-                width === undefined || (sprite.width = width);
-                height === undefined || (sprite.height = height);
-                resolve(sprite);
-            });
-        }
-    };
-    return SpriteLoader;
-}(engineCore.Loader);
-SpriteLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.Sprite, [
-        "sprite"
-    ])
-], SpriteLoader);
-
-var TextLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(TextLoader, Loader);
-    function TextLoader() {
-        return Loader.apply(this, arguments) || this;
-    }
-    var _proto = TextLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        // @ts-ignore
-        return resourceManager._request(item.url, _extends({}, item, {
-            type: "text"
-        })).then(function(text) {
-            var asset = new engineCore.TextAsset(resourceManager.engine);
-            asset.text = text;
-            return asset;
-        });
-    };
-    return TextLoader;
-}(engineCore.Loader);
-TextLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.Text, [
-        "txt"
-    ])
-], TextLoader);
-
-function loadImageFromBuffer(buffer) {
-    return new engineCore.AssetPromise(function(resolve, reject) {
-        var blob = new Blob([
-            buffer
-        ]);
-        var img = new Image();
-        img.onload = function() {
-            URL.revokeObjectURL(img.src);
-            resolve(img);
-        };
-        img.onerror = reject;
-        img.src = URL.createObjectURL(blob);
-    });
-}
-var Texture2DLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(Texture2DLoader, Loader);
-    function Texture2DLoader() {
-        return Loader.apply(this, arguments) || this;
-    }
-    var _proto = Texture2DLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        var _this = this;
-        var url = item.url;
-        var requestConfig = _extends({}, item, {
-            type: "arraybuffer"
-        });
-        return new engineCore.AssetPromise(function(resolve, reject, setTaskCompleteProgress, setTaskDetailProgress) {
-            resourceManager// @ts-ignore
-            ._request(url, requestConfig).onProgress(setTaskCompleteProgress, setTaskDetailProgress).then(function(buffer) {
-                if (FileHeader.checkMagic(buffer)) {
-                    decode(buffer, resourceManager.engine).then(function(texture) {
-                        resourceManager.addContentRestorer(new Texture2DContentRestorer(texture, url, requestConfig));
-                        resolve(texture);
-                    }, reject);
-                } else {
-                    loadImageFromBuffer(buffer).then(function(img) {
-                        var texture = _this._createTexture(img, item, resourceManager);
-                        resourceManager.addContentRestorer(new Texture2DContentRestorer(texture, url, requestConfig));
-                        resolve(texture);
-                    }, reject);
-                }
-            }).catch(reject);
-        });
-    };
-    _proto._createTexture = function _createTexture(img, item, resourceManager) {
-        var _item_params;
-        var _ref = (_item_params = item.params) != null ? _item_params : {}, _ref_format = _ref.format, format = _ref_format === void 0 ? engineCore.TextureFormat.R8G8B8A8 : _ref_format, anisoLevel = _ref.anisoLevel, wrapModeU = _ref.wrapModeU, wrapModeV = _ref.wrapModeV, filterMode = _ref.filterMode, _ref_isSRGBColorSpace = _ref.isSRGBColorSpace, isSRGBColorSpace = _ref_isSRGBColorSpace === void 0 ? true : _ref_isSRGBColorSpace, _ref_mipmap = _ref.mipmap, mipmap = _ref_mipmap === void 0 ? true : _ref_mipmap;
-        var width = img.width, height = img.height;
-        var engine = resourceManager.engine;
-        var generateMipmap = engineCore.TextureUtils.supportGenerateMipmapsWithCorrection(engine, width, height, format, mipmap, isSRGBColorSpace);
-        var texture = new engineCore.Texture2D(engine, width, height, format, generateMipmap, isSRGBColorSpace);
-        texture.anisoLevel = anisoLevel != null ? anisoLevel : texture.anisoLevel;
-        texture.filterMode = filterMode != null ? filterMode : texture.filterMode;
-        texture.wrapModeU = wrapModeU != null ? wrapModeU : texture.wrapModeU;
-        texture.wrapModeV = wrapModeV != null ? wrapModeV : texture.wrapModeV;
-        texture.setImageSource(img);
-        generateMipmap && texture.generateMipmaps();
-        var url = item.url;
-        if (url.indexOf("data:") !== 0) {
-            texture.name = url.substring(url.lastIndexOf("/") + 1);
-        }
-        return texture;
-    };
-    return Texture2DLoader;
-}(engineCore.Loader);
-Texture2DLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.Texture2D, [
-        "png",
-        "jpg",
-        "webp",
-        "jpeg",
-        "tex"
-    ])
-], Texture2DLoader);
-var Texture2DContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
-    _inherits(Texture2DContentRestorer, ContentRestorer);
-    function Texture2DContentRestorer(resource, url, requestConfig) {
-        var _this;
-        _this = ContentRestorer.call(this, resource) || this, _this.url = url, _this.requestConfig = requestConfig;
-        return _this;
-    }
-    var _proto = Texture2DContentRestorer.prototype;
-    _proto.restoreContent = function restoreContent() {
-        var texture = this.resource;
-        var engine = texture.engine;
-        return engine.resourceManager// @ts-ignore
-        ._request(this.url, this.requestConfig).then(function(buffer) {
-            if (FileHeader.checkMagic(buffer)) {
-                return decode(buffer, engine, texture);
-            } else {
-                return loadImageFromBuffer(buffer).then(function(img) {
-                    texture.setImageSource(img);
-                    texture.generateMipmaps();
-                    return texture;
-                });
-            }
-        });
-    };
-    return Texture2DContentRestorer;
-}(engineCore.ContentRestorer);
-
-/**
- * HDR panorama to cubemap decoder.
- */ var HDRDecoder = /*#__PURE__*/ function() {
-    function HDRDecoder() {}
-    HDRDecoder.parseHeader = function parseHeader(uint8array) {
-        var line = this._readStringLine(uint8array, 0);
-        if (line[0] !== "#" || line[1] !== "?") {
-            throw "HDRDecoder: invalid file header";
-        }
-        var endOfHeader = false;
-        var findFormat = false;
-        var lineIndex = 0;
-        do {
-            lineIndex += line.length + 1;
-            line = this._readStringLine(uint8array, lineIndex);
-            if (line === "FORMAT=32-bit_rle_rgbe") findFormat = true;
-            else if (line.length === 0) endOfHeader = true;
-        }while (!endOfHeader);
-        if (!findFormat) {
-            throw "HDRDecoder: unsupported format, expected 32-bit_rle_rgbe";
-        }
-        lineIndex += line.length + 1;
-        line = this._readStringLine(uint8array, lineIndex);
-        var match = /^\-Y (.*) \+X (.*)$/g.exec(line);
-        if (!match || match.length < 3) {
-            throw "HDRDecoder: missing image size, only -Y +X layout is supported";
-        }
-        var width = parseInt(match[2]);
-        var height = parseInt(match[1]);
-        if (width < 8 || width > 0x7fff) {
-            throw "HDRDecoder: unsupported image width, must be between 8 and 32767";
-        }
-        return {
-            height: height,
-            width: width,
-            dataPosition: lineIndex + line.length + 1
-        };
-    };
-    HDRDecoder.decodeFaces = function decodeFaces(bufferArray, header, onFace) {
-        var width = header.width, height = header.height, dataPosition = header.dataPosition;
-        var cubeSize = height >> 1;
-        var pixels = HDRDecoder._readPixels(bufferArray.subarray(dataPosition), width, height);
-        var faces = HDRDecoder._faces;
-        var faceBuffer = new Uint16Array(cubeSize * cubeSize * 4);
-        for(var faceIndex = 0; faceIndex < 6; faceIndex++){
-            HDRDecoder._createCubemapData(cubeSize, faces[faceIndex], pixels, width, height, faceBuffer);
-            onFace(faceIndex, faceBuffer);
-        }
-    };
-    HDRDecoder._generateFloat2HalfTables = function _generateFloat2HalfTables() {
-        var baseTable = new Uint32Array(512);
-        var shiftTable = new Uint32Array(512);
-        for(var i = 0; i < 256; ++i){
-            var e = i - 127;
-            if (e < -27) {
-                baseTable[i] = 0x0000;
-                baseTable[i | 0x100] = 0x8000;
-                shiftTable[i] = 24;
-                shiftTable[i | 0x100] = 24;
-            } else if (e < -14) {
-                baseTable[i] = 0x0400 >> -e - 14;
-                baseTable[i | 0x100] = 0x0400 >> -e - 14 | 0x8000;
-                shiftTable[i] = -e - 1;
-                shiftTable[i | 0x100] = -e - 1;
-            } else if (e <= 15) {
-                baseTable[i] = e + 15 << 10;
-                baseTable[i | 0x100] = e + 15 << 10 | 0x8000;
-                shiftTable[i] = 13;
-                shiftTable[i | 0x100] = 13;
-            } else if (e < 128) {
-                baseTable[i] = 0x7c00;
-                baseTable[i | 0x100] = 0xfc00;
-                shiftTable[i] = 24;
-                shiftTable[i | 0x100] = 24;
-            } else {
-                baseTable[i] = 0x7c00;
-                baseTable[i | 0x100] = 0xfc00;
-                shiftTable[i] = 13;
-                shiftTable[i | 0x100] = 13;
-            }
-        }
-        return {
-            baseTable: baseTable,
-            shiftTable: shiftTable
-        };
-    };
-    HDRDecoder._createCubemapData = function _createCubemapData(texSize, face, pixels, inputWidth, inputHeight, facePixels) {
-        var invSize = 1 / texSize;
-        var rotDX1X = (face[3] - face[0]) * invSize;
-        var rotDX1Y = (face[4] - face[1]) * invSize;
-        var rotDX1Z = (face[5] - face[2]) * invSize;
-        var rotDX2X = (face[9] - face[6]) * invSize;
-        var rotDX2Y = (face[10] - face[7]) * invSize;
-        var rotDX2Z = (face[11] - face[8]) * invSize;
-        var floatView = HDRDecoder._floatView;
-        var uint32View = HDRDecoder._uint32View;
-        var _HDRDecoder__float2HalfTables = HDRDecoder._float2HalfTables, baseTable = _HDRDecoder__float2HalfTables.baseTable, shiftTable = _HDRDecoder__float2HalfTables.shiftTable;
-        var one = HDRDecoder._one;
-        var fy = 0;
-        for(var y = 0; y < texSize; y++){
-            var xv1X = face[0], xv1Y = face[1], xv1Z = face[2];
-            var xv2X = face[6], xv2Y = face[7], xv2Z = face[8];
-            for(var x = 0; x < texSize; x++){
-                var dirX = xv1X + (xv2X - xv1X) * fy;
-                var dirY = xv1Y + (xv2Y - xv1Y) * fy;
-                var dirZ = xv1Z + (xv2Z - xv1Z) * fy;
-                var invLen = 1 / Math.sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ);
-                dirX *= invLen;
-                dirY *= invLen;
-                dirZ *= invLen;
-                var px = Math.round((Math.atan2(dirZ, dirX) / Math.PI * 0.5 + 0.5) * inputWidth);
-                if (px < 0) px = 0;
-                else if (px >= inputWidth) px = inputWidth - 1;
-                var py = Math.round(Math.acos(dirY) / Math.PI * inputHeight);
-                if (py < 0) py = 0;
-                else if (py >= inputHeight) py = inputHeight - 1;
-                var srcIndex = (inputHeight - py - 1) * inputWidth * 4 + px * 4;
-                var scaleFactor = Math.pow(2, pixels[srcIndex + 3] - 128) / 255;
-                var dstIndex = y * texSize * 4 + x * 4;
-                for(var c = 0; c < 3; c++){
-                    // Clamp to half-float max (65504) to prevent Infinity in R16G16B16A16
-                    floatView[0] = Math.min(pixels[srcIndex + c] * scaleFactor, 65504);
-                    var f = uint32View[0];
-                    var e = f >> 23 & 0x1ff;
-                    facePixels[dstIndex + c] = baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);
-                }
-                facePixels[dstIndex + 3] = one;
-                xv1X += rotDX1X;
-                xv1Y += rotDX1Y;
-                xv1Z += rotDX1Z;
-                xv2X += rotDX2X;
-                xv2Y += rotDX2Y;
-                xv2Z += rotDX2Z;
-            }
-            fy += invSize;
-        }
-    };
-    HDRDecoder._readStringLine = function _readStringLine(uint8array, startIndex) {
-        var line = "";
-        for(var i = startIndex, n = uint8array.length; i < n; i++){
-            var character = String.fromCharCode(uint8array[i]);
-            if (character === "\n") break;
-            line += character;
-        }
-        return line;
-    };
-    HDRDecoder._readPixels = function _readPixels(buffer, width, height) {
-        var byteLength = buffer.byteLength;
-        var dataRGBA = new Uint8Array(4 * width * height);
-        var offset = 0;
-        var pos = 0;
-        var ptrEnd = 4 * width;
-        var scanLineBuffer = new Uint8Array(ptrEnd);
-        var numScanLines = height;
-        while(numScanLines > 0 && pos < byteLength){
-            var a = buffer[pos++];
-            var b = buffer[pos++];
-            var c = buffer[pos++];
-            var d = buffer[pos++];
-            if (a !== 2 || b !== 2 || c & 0x80 || width < 8 || width > 32767) return buffer;
-            if ((c << 8 | d) !== width) throw "HDRDecoder: wrong scanline width";
-            var ptr = 0;
-            while(ptr < ptrEnd && pos < byteLength){
-                var count = buffer[pos++];
-                var isEncodedRun = count > 128;
-                if (isEncodedRun) count -= 128;
-                if (count === 0 || ptr + count > ptrEnd) throw "HDRDecoder: bad scanline data";
-                if (isEncodedRun) {
-                    var byteValue = buffer[pos++];
-                    for(var i = 0; i < count; i++)scanLineBuffer[ptr++] = byteValue;
-                } else {
-                    scanLineBuffer.set(buffer.subarray(pos, pos + count), ptr);
-                    ptr += count;
-                    pos += count;
-                }
-            }
-            for(var i1 = 0; i1 < width; i1++, offset += 4){
-                dataRGBA[offset] = scanLineBuffer[i1];
-                dataRGBA[offset + 1] = scanLineBuffer[i1 + width];
-                dataRGBA[offset + 2] = scanLineBuffer[i1 + width * 2];
-                dataRGBA[offset + 3] = scanLineBuffer[i1 + width * 3];
-            }
-            numScanLines--;
+    _proto._loadFromAtlas = function _loadFromAtlas(resourceManager, data) {
+        var _this = this;
+        return resourceManager// @ts-ignore
+        .getResourceByRef(data.belongToAtlas).then(function(atlas) {
+            return atlas.getSprite(data.fullPath) || _this._loadFromTexture(resourceManager, data);
+        });
+    };
+    _proto._loadFromTexture = function _loadFromTexture(resourceManager, data) {
+        if (data.texture) {
+            return resourceManager// @ts-ignore
+            .getResourceByRef(data.texture).then(function(texture) {
+                var sprite = new engineCore.Sprite(resourceManager.engine, texture, data.region, data.pivot, data.border);
+                var width = data.width, height = data.height;
+                width === undefined || (sprite.width = width);
+                height === undefined || (sprite.height = height);
+                return sprite;
+            });
+        } else {
+            return new engineCore.AssetPromise(function(resolve) {
+                var sprite = new engineCore.Sprite(resourceManager.engine, null, data.region, data.pivot, data.border);
+                var width = data.width, height = data.height;
+                width === undefined || (sprite.width = width);
+                height === undefined || (sprite.height = height);
+                resolve(sprite);
+            });
         }
-        return dataRGBA;
     };
-    return HDRDecoder;
-}();
-// Float32 to Float16 lookup tables (http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf)
-HDRDecoder._float2HalfTables = HDRDecoder._generateFloat2HalfTables();
-HDRDecoder._floatView = new Float32Array(1);
-HDRDecoder._uint32View = new Uint32Array(HDRDecoder._floatView.buffer);
-HDRDecoder._one = 0x3c00 // Half float for 1.0
-;
-// prettier-ignore
-HDRDecoder._faces = [
-    /* +X */ [
-        1,
-        -1,
-        -1,
-        1,
-        -1,
-        1,
-        1,
-        1,
-        -1,
-        1,
-        1,
-        1
-    ],
-    /* -X */ [
-        -1,
-        -1,
-        1,
-        -1,
-        -1,
-        -1,
-        -1,
-        1,
-        1,
-        -1,
-        1,
-        -1
-    ],
-    /* +Y */ [
-        -1,
-        -1,
-        1,
-        1,
-        -1,
-        1,
-        -1,
-        -1,
-        -1,
-        1,
-        -1,
-        -1
-    ],
-    /* -Y */ [
-        -1,
-        1,
-        -1,
-        1,
-        1,
-        -1,
-        -1,
-        1,
-        1,
-        1,
-        1,
-        1
-    ],
-    /* +Z */ [
-        -1,
-        -1,
-        -1,
-        1,
-        -1,
-        -1,
-        -1,
-        1,
-        -1,
-        1,
-        1,
-        -1
-    ],
-    /* -Z */ [
-        1,
-        -1,
-        1,
-        -1,
-        -1,
-        1,
-        1,
-        1,
-        1,
-        -1,
-        1,
-        1
-    ]
-];
+    return SpriteLoader;
+}(engineCore.Loader);
+SpriteLoader = __decorate([
+    engineCore.resourceLoader(engineCore.AssetType.Sprite, [
+        "sprite"
+    ])
+], SpriteLoader);
+
+var TextLoader = /*#__PURE__*/ function(Loader) {
+    _inherits(TextLoader, Loader);
+    function TextLoader() {
+        return Loader.apply(this, arguments) || this;
+    }
+    var _proto = TextLoader.prototype;
+    _proto.load = function load(item, resourceManager) {
+        // @ts-ignore
+        return resourceManager._request(item.url, _extends({}, item, {
+            type: "text"
+        })).then(function(text) {
+            var asset = new engineCore.TextAsset(resourceManager.engine);
+            asset.text = text;
+            return asset;
+        });
+    };
+    return TextLoader;
+}(engineCore.Loader);
+TextLoader = __decorate([
+    engineCore.resourceLoader(engineCore.AssetType.Text, [
+        "txt"
+    ])
+], TextLoader);
 
-var TextureCubeLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(TextureCubeLoader, Loader);
-    function TextureCubeLoader() {
+var TextureLoader = /*#__PURE__*/ function(Loader) {
+    _inherits(TextureLoader, Loader);
+    function TextureLoader() {
         return Loader.apply(this, arguments) || this;
     }
-    var _proto = TextureCubeLoader.prototype;
+    var _proto = TextureLoader.prototype;
     _proto.load = function load(item, resourceManager) {
+        var _this = this;
+        var url = item.url;
+        var requestConfig = _extends({}, item, {
+            type: "arraybuffer"
+        });
+        return new engineCore.AssetPromise(function(resolve, reject, setTaskCompleteProgress, setTaskDetailProgress) {
+            resourceManager// @ts-ignore
+            ._request(url, requestConfig).onProgress(setTaskCompleteProgress, setTaskDetailProgress).then(function(buffer) {
+                _this._decode(buffer, item, resourceManager).then(function(texture) {
+                    resourceManager.addContentRestorer(new TextureContentRestorer(texture, url, requestConfig));
+                    resolve(texture);
+                }, reject);
+            }).catch(reject);
+        });
+    };
+    _proto._decode = function _decode(buffer, item, resourceManager) {
+        if (FileHeader.checkMagic(buffer)) {
+            return decode(buffer, resourceManager.engine);
+        }
+        var bufferView = new Uint8Array(buffer);
+        var isHDR = bufferView[0] === 0x23 && bufferView[1] === 0x3f;
+        if (isHDR) {
+            return this._decodeHDR(bufferView, item, resourceManager);
+        }
+        return this._decodeImage(buffer, item, resourceManager);
+    };
+    _proto._decodeHDR = function _decodeHDR(buffer, item, resourceManager) {
+        var _this = this;
         return new engineCore.AssetPromise(function(resolve, reject) {
             var engine = resourceManager.engine;
-            var url = item.url;
-            var requestConfig = _extends({}, item, {
-                type: "arraybuffer"
-            });
-            resourceManager// @ts-ignore
-            ._request(url, requestConfig).then(function(buffer) {
-                if (!engineCore.SystemInfo.supportsTextureFormat(engine, engineCore.TextureFormat.R16G16B16A16)) {
-                    reject(new Error("TextureCubeLoader: HDR texture requires half float support."));
-                    return;
-                }
+            if (!engineCore.SystemInfo.supportsTextureFormat(engine, engineCore.TextureFormat.R16G16B16A16)) {
+                reject(new Error("TextureLoader: HDR texture requires half float support."));
+                return;
+            }
+            var _HDRDecoder_decode = HDRDecoder.decode(buffer), width = _HDRDecoder_decode.width, height = _HDRDecoder_decode.height, pixels = _HDRDecoder_decode.pixels;
+            var _item_params;
+            var _ref = (_item_params = item.params) != null ? _item_params : {}, _ref_mipmap = _ref.mipmap, mipmap = _ref_mipmap === void 0 ? true : _ref_mipmap;
+            var texture = new engineCore.Texture2D(engine, width, height, engineCore.TextureFormat.R16G16B16A16, mipmap, false);
+            texture.setPixelBuffer(pixels);
+            mipmap && texture.generateMipmaps();
+            _this._applyParams(texture, item);
+            resolve(texture);
+        });
+    };
+    _proto._decodeImage = function _decodeImage(buffer, item, resourceManager) {
+        var _this = this;
+        return new engineCore.AssetPromise(function(resolve, reject) {
+            var blob = new Blob([
+                buffer
+            ]);
+            var img = new Image();
+            img.onload = function() {
+                URL.revokeObjectURL(img.src);
                 var _item_params;
-                var _ref = (_item_params = item.params) != null ? _item_params : {}, _ref_mipmap = _ref.mipmap, mipmap = _ref_mipmap === void 0 ? true : _ref_mipmap, anisoLevel = _ref.anisoLevel, wrapModeU = _ref.wrapModeU, wrapModeV = _ref.wrapModeV, filterMode = _ref.filterMode;
-                var bufferArray = new Uint8Array(buffer);
-                var header = HDRDecoder.parseHeader(bufferArray);
-                var texture = new engineCore.TextureCube(engine, header.height >> 1, engineCore.TextureFormat.R16G16B16A16, mipmap, false);
-                HDRDecoder.decodeFaces(bufferArray, header, function(faceIndex, data) {
-                    texture.setPixelBuffer(engineCore.TextureCubeFace.PositiveX + faceIndex, data, 0);
-                });
-                texture.generateMipmaps();
-                texture.anisoLevel = anisoLevel != null ? anisoLevel : texture.anisoLevel;
-                texture.filterMode = filterMode != null ? filterMode : texture.filterMode;
-                texture.wrapModeU = wrapModeU != null ? wrapModeU : texture.wrapModeU;
-                texture.wrapModeV = wrapModeV != null ? wrapModeV : texture.wrapModeV;
-                resourceManager.addContentRestorer(new HDRContentRestorer(texture, url, requestConfig));
+                var _ref = (_item_params = item.params) != null ? _item_params : {}, _ref_format = _ref.format, format = _ref_format === void 0 ? engineCore.TextureFormat.R8G8B8A8 : _ref_format, _ref_isSRGBColorSpace = _ref.isSRGBColorSpace, isSRGBColorSpace = _ref_isSRGBColorSpace === void 0 ? true : _ref_isSRGBColorSpace, _ref_mipmap = _ref.mipmap, mipmap = _ref_mipmap === void 0 ? true : _ref_mipmap;
+                var engine = resourceManager.engine;
+                var width = img.width, height = img.height;
+                var generateMipmap = engineCore.TextureUtils.supportGenerateMipmapsWithCorrection(engine, width, height, format, mipmap, isSRGBColorSpace);
+                var texture = new engineCore.Texture2D(engine, width, height, format, generateMipmap, isSRGBColorSpace);
+                texture.setImageSource(img);
+                generateMipmap && texture.generateMipmaps();
+                _this._applyParams(texture, item);
                 resolve(texture);
-            }).catch(reject);
+            };
+            img.onerror = function(e) {
+                URL.revokeObjectURL(img.src);
+                reject(e);
+            };
+            img.src = URL.createObjectURL(blob);
         });
     };
-    return TextureCubeLoader;
+    _proto._applyParams = function _applyParams(texture, item) {
+        var _item_params;
+        var _ref = (_item_params = item.params) != null ? _item_params : {}, anisoLevel = _ref.anisoLevel, wrapModeU = _ref.wrapModeU, wrapModeV = _ref.wrapModeV, filterMode = _ref.filterMode;
+        texture.anisoLevel = anisoLevel != null ? anisoLevel : texture.anisoLevel;
+        texture.filterMode = filterMode != null ? filterMode : texture.filterMode;
+        texture.wrapModeU = wrapModeU != null ? wrapModeU : texture.wrapModeU;
+        texture.wrapModeV = wrapModeV != null ? wrapModeV : texture.wrapModeV;
+        var url = item.url;
+        if (url.indexOf("data:") !== 0) {
+            texture.name = url.substring(url.lastIndexOf("/") + 1);
+        }
+    };
+    return TextureLoader;
 }(engineCore.Loader);
-TextureCubeLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.TextureCube, [
-        "texCube",
+TextureLoader = __decorate([
+    engineCore.resourceLoader(engineCore.AssetType.Texture, [
+        "tex",
+        "png",
+        "jpg",
+        "webp",
+        "jpeg",
         "hdr"
     ])
-], TextureCubeLoader);
-var HDRContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
-    _inherits(HDRContentRestorer, ContentRestorer);
-    function HDRContentRestorer(resource, url, requestConfig) {
+], TextureLoader);
+var TextureContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
+    _inherits(TextureContentRestorer, ContentRestorer);
+    function TextureContentRestorer(resource, url, requestConfig) {
         var _this;
         _this = ContentRestorer.call(this, resource) || this, _this.url = url, _this.requestConfig = requestConfig;
         return _this;
     }
-    var _proto = HDRContentRestorer.prototype;
+    var _proto = TextureContentRestorer.prototype;
     _proto.restoreContent = function restoreContent() {
         var _this = this;
-        return new engineCore.AssetPromise(function(resolve, reject) {
-            var resource = _this.resource;
-            resource.engine.resourceManager// @ts-ignore
-            ._request(_this.url, _this.requestConfig).then(function(buffer) {
-                var bufferArray = new Uint8Array(buffer);
-                HDRDecoder.decodeFaces(bufferArray, HDRDecoder.parseHeader(bufferArray), function(faceIndex, data) {
-                    resource.setPixelBuffer(engineCore.TextureCubeFace.PositiveX + faceIndex, data, 0);
-                });
-                resource.generateMipmaps();
-                resolve(resource);
-            }).catch(reject);
+        return this.resource.engine.resourceManager// @ts-ignore
+        ._request(this.url, this.requestConfig).then(function(buffer) {
+            if (FileHeader.checkMagic(buffer)) {
+                return decode(buffer, _this.resource.engine, _this.resource);
+            }
+            var bufferView = new Uint8Array(buffer);
+            var texture = _this.resource;
+            if (bufferView[0] === 0x23 && bufferView[1] === 0x3f) {
+                var pixels = HDRDecoder.decode(bufferView).pixels;
+                texture.setPixelBuffer(pixels);
+                texture.mipmapCount > 1 && texture.generateMipmaps();
+                return texture;
+            }
+            return new engineCore.AssetPromise(function(resolve, reject) {
+                var blob = new Blob([
+                    buffer
+                ]);
+                var img = new Image();
+                img.onload = function() {
+                    URL.revokeObjectURL(img.src);
+                    texture.setImageSource(img);
+                    texture.mipmapCount > 1 && texture.generateMipmaps();
+                    resolve(texture);
+                };
+                img.onerror = function(e) {
+                    URL.revokeObjectURL(img.src);
+                    reject(e);
+                };
+                img.src = URL.createObjectURL(blob);
+            });
         });
     };
-    return HDRContentRestorer;
+    return TextureContentRestorer;
 }(engineCore.ContentRestorer);
 
 var AudioLoader = /*#__PURE__*/ function(Loader) {
@@ -6547,8 +6368,7 @@ var AudioLoader = /*#__PURE__*/ function(Loader) {
             resourceManager// @ts-ignore
             ._request(url, requestConfig).then(function(arrayBuffer) {
                 var audioClip = new engineCore.AudioClip(resourceManager.engine);
-                // @ts-ignore
-                engineCore.AudioManager.getContext().decodeAudioData(arrayBuffer).then(function(result) {
+                AudioLoader._getDecodeContext().decodeAudioData(arrayBuffer).then(function(result) {
                     // @ts-ignore
                     audioClip._setAudioSource(result);
                     if (url.indexOf("data:") !== 0) {
@@ -6564,6 +6384,12 @@ var AudioLoader = /*#__PURE__*/ function(Loader) {
             });
         });
     };
+    AudioLoader._getDecodeContext = function _getDecodeContext() {
+        var _AudioLoader;
+        // length/channels are decode-only placeholders; 44100 is the safest cross-browser rate.
+        // decodeAudioData resamples once to this rate then again to the playback rate, so pitch/duration are unaffected
+        return (_AudioLoader = AudioLoader)._decodeContext || (_AudioLoader._decodeContext = new OfflineAudioContext(1, 1, 44100));
+    };
     return AudioLoader;
 }(engineCore.Loader);
 AudioLoader = __decorate([
@@ -6571,58 +6397,12 @@ AudioLoader = __decorate([
         "mp3",
         "ogg",
         "wav",
-        "audio",
         "m4a",
         "aac",
         "flac"
     ])
 ], 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() {
@@ -6630,32 +6410,29 @@ var ShaderLoader = /*#__PURE__*/ function(Loader) {
     }
     var _proto = ShaderLoader.prototype;
     _proto.load = function load(item, resourceManager) {
-        var _this = this;
         var url = item.url;
+        if (url.endsWith(".shaderc")) {
+            // @ts-ignore
+            return resourceManager._request(url, _extends({}, item, {
+                type: "json"
+            })).then(function(data) {
+                // @ts-ignore - _createFromPrecompiled is @internal
+                return engineCore.Shader._createFromPrecompiled(data);
+            });
+        }
         // @ts-ignore
         return resourceManager._request(url, _extends({}, item, {
             type: "text"
         })).then(function(code) {
-            var builtinShader = _this._getBuiltinShader(code);
-            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) {
-        var match = code.match(ShaderLoader._builtinRegex);
-        if (match && match[1]) return match[1];
-    };
     return ShaderLoader;
 }(engineCore.Loader);
-ShaderLoader._builtinRegex = /^\s*\/\/\s*@builtin\s+(\w+)/;
 ShaderLoader = __decorate([
     engineCore.resourceLoader(engineCore.AssetType.Shader, [
-        "shader"
+        "shader",
+        "shaderc"
     ])
 ], ShaderLoader);
 
@@ -6735,6 +6512,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() {
@@ -6748,130 +6641,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);
-                    }
-                    // parse physics
-                    var physics = data.scene.physics;
-                    // PhysicsScene has a native backing only when the engine was created with a physics backend.
-                    // Keep scene files loadable for render-only engines by ignoring serialized physics settings there.
-                    if (physics && engine._physicsInitialized) {
-                        if (physics.gravity != undefined) scene.physics.gravity.copyFrom(physics.gravity);
-                        if (physics.fixedTimeStep != undefined) scene.physics.fixedTimeStep = physics.fixedTimeStep;
-                    }
-                    // 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);
                     });
                 });