@galacean/engine-loader 0.0.0-experimental-2.0-spine.0 → 0.0.0-experimental-2.0-game.19

package/dist/main.js

@@ -643,27 +643,37 @@ function float32ArrayToVector2(float32Array, vertexCount) {
     return array;
 }
 
-function _object_without_properties_loose(source, excluded) {
-    if (source == null) return {};
+function _is_native_reflect_construct() {
+    // Since Reflect.construct can't be properly polyfilled, some
+    // implementations (e.g. core-js@2) don't set the correct internal slots.
+    // Those polyfills don't allow us to subclass built-ins, so we need to
+    // use our fallback implementation.
+    try {
+        // If the internal slots aren't set, this throws an error similar to
+        //   TypeError: this is not a Boolean object.
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
 
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [null];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
 
-    for (i = 0; i < sourceKeys.length; i++) {
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        target[key] = source[key];
-    }
+            if (Class) _set_prototype_of(instance, Class.prototype);
 
-    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 instance;
+        };
     }
-    return refs[index];
+
+    return _construct.apply(null, arguments);
 }
 
 var ParserType = /*#__PURE__*/ function(ParserType) {
@@ -679,20 +689,32 @@ var ParserType = /*#__PURE__*/ function(ParserType) {
         this.engine = engine;
         this.type = type;
         this.resource = resource;
-        this./** Runtime Entity instances, indexed by the flat entities[] position. */ entityInstances = [];
-        this./** Components waiting for props/calls application (Stage 4). */ pendingComponents = [];
+        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._loaded = 0;
         this._total = 0;
         this.resourceManager = engine.resourceManager;
     }
     var _proto = ParserContext.prototype;
     _proto.clear = function clear() {
-        this.entityInstances.length = 0;
-        this.pendingComponents.length = 0;
-    };
-    /** @internal */ _proto._addDependentAsset = function _addDependentAsset(promise) {
+        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) {
         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);
@@ -702,399 +724,243 @@ var ParserType = /*#__PURE__*/ function(ParserType) {
 }();
 
 var ReflectionParser = /*#__PURE__*/ function() {
-    function ReflectionParser(_context, _refs) {
+    function ReflectionParser(_context) {
         this._context = _context;
-        this._refs = _refs;
     }
     var _proto = ReflectionParser.prototype;
-    /**
-   * 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) {
+    _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) {
         var promises = [];
-        if (props) {
+        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) {
             var _this, _loop = function(key) {
-                var promise = _this._resolveValue(props[key], instance[key]).then(function(v) {
-                    instance[key] = v;
+                var value = item.props[key];
+                var promise = _this.parseBasicType(value, instance[key]).then(function(v) {
+                    return instance[key] = v;
                 });
                 promises.push(promise);
             };
-            for(var key in props)_this = this, _loop(key);
+            for(var key in item.props)_this = this, _loop(key);
         }
         return Promise.all(promises).then(function() {
             return instance;
         });
     };
-    /**
-   * 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);
-                });
-            });
-        };
+    _proto.parseMethod = function parseMethod(instance, methodName, methodParams) {
         var _this = this;
-        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;
-        });
-    };
-    /**
-   * 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;
+        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;
+            }
         });
     };
-    /**
-   * Resolve a v2 value with $ prefix detection.
-   *
-   * Priority:
-   * 1. null/undefined/primitive → passthrough
-   * 2. Array → recurse each element
-   * 3. { $ref }       → asset reference
-   * 4. { $type }      → polymorphic type construct
-   * 5. { $class }     → registered class constructor
-   * 6. { $entity }    → entity reference by path (flat index + optional children descent)
-   * 7. { $component } → component reference
-   * 8. { $signal }    → signal binding
-   * 9. plain object   → recurse values (modify originValue in place if exists)
-   */ _proto._resolveValue = function _resolveValue(value, originValue) {
-        var _this, _loop = function(key) {
-            promises.push(_this._resolveValue(obj[key], target[key]).then(function(v) {
-                return target[key] = v;
-            }));
-        };
-        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);
-            }
-            // @ts-ignore
-            return context.resourceManager.getResourceByRef(refItem).then(function(resource) {
-                if (resource && context.type === ParserType.Prefab) {
-                    // @ts-ignore
-                    context.resource._addDependenceAsset(resource);
+    _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));
                 }
-                return resource;
-            });
-        }
-        // $type — polymorphic type: construct instance and apply remaining props
-        if ("$type" in obj) {
-            var $type = obj.$type, rest = _object_without_properties_loose(obj, [
-                "$type"
-            ]);
-            return this._resolveRegisteredClass($type, "$type").then(function(Class) {
-                var instance = new Class();
-                return Object.keys(rest).length > 0 ? _this1.parseProps(instance, rest) : instance;
             });
-        }
-        // $class — registered class constructor for factory-style methods.
-        if ("$class" in obj) {
-            return this._resolveRegisteredClass(obj.$class, "$class");
-        }
-        // $entity — entity reference by path (first element = flat index, subsequent = children indices)
-        if ("$entity" in obj) {
-            return Promise.resolve(this._resolveEntityRef(obj.$entity));
-        }
-        // $component — component reference: { entity, type, index }
-        if ("$component" in obj) {
-            return Promise.resolve(this._resolveComponent(obj.$component));
-        }
-        // $signal — signal binding: register listeners on the existing Signal instance
-        if ("$signal" in obj) {
-            return this._resolveSignal(originValue, obj.$signal);
-        }
-        // Plain object — recurse each value, modifying originValue in place or building a new object
-        var target = originValue && (typeof originValue === "undefined" ? "undefined" : _type_of(originValue)) === "object" && !Array.isArray(originValue) ? originValue : {};
-        var promises = [];
-        for(var key in obj)_this = this, _loop(key);
-        return Promise.all(promises).then(function() {
-            return target;
+        })).then(function() {
+            return signal;
         });
     };
-    _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;
-    };
-    /** 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);
+    _proto.parseBasicType = function parseBasicType(value, originValue) {
+        var _this = this;
+        if (Array.isArray(value)) {
+            return Promise.all(value.map(function(item) {
+                return _this.parseBasicType(item);
+            }));
+        } else if ((typeof value === "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;
+                });
+            }
         }
+        // primitive type
+        return Promise.resolve(value);
     };
-    _proto._resolveSignal = function _resolveSignal(signal, listeners) {
+    _proto._getEntityByConfig = function _getEntityByConfig(entityConfig) {
         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));
+        // @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
+                    _this._context.resource._addDependenceAsset(resource);
+                }
+                entity.name = entityConfig.name;
+                return entity;
             });
-        });
-        return Promise.all(promises).then(function() {
-            return signal;
-        });
-    };
-    _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;
+        } else {
+            var transform = entityConfig.transform;
+            var entity = new engineCore.Entity(engine, entityConfig.name, transform ? engineCore.Loader.getClass(transform.class) : engineCore.Transform);
+            return Promise.resolve(entity);
+        }
     };
-    _proto._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;
+    _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]];
         }
         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
-        };
+    ReflectionParser._isClass = function _isClass(value) {
+        return value["class"] !== undefined;
     };
-    /**
-   * 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
-        };
+    ReflectionParser._isClassType = function _isClassType(value) {
+        return value["classType"] !== undefined;
     };
-    /**
-   * 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;
+    ReflectionParser._isAssetRef = function _isAssetRef(value) {
+        return value["url"] !== undefined;
     };
-    /**
-   * 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;
+    ReflectionParser._isEntityRef = function _isEntityRef(value) {
+        return Array.isArray(value["entityPath"]) && value["componentType"] === undefined;
     };
-    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
-        };
+    ReflectionParser._isComponentRef = function _isComponentRef(value) {
+        return Array.isArray(value["entityPath"]) && value["componentType"] !== undefined;
     };
-    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;
+    ReflectionParser._isSignalRef = function _isSignalRef(value) {
+        return value["listeners"] !== undefined;
     };
-    return HDRDecoder;
+    ReflectionParser._isMethodObject = function _isMethodObject(value) {
+        return Array.isArray(value == null ? void 0 : value.params);
+    };
+    return ReflectionParser;
 }();
-HDRDecoder._float2HalfTables = HDRDecoder._generateFloat2HalfTables();
-HDRDecoder._floatView = new Float32Array(1);
-HDRDecoder._uint32View = new Uint32Array(HDRDecoder._floatView.buffer);
 
-/**
- * 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() {
+exports.Texture2DDecoder = /*#__PURE__*/ function() {
     function Texture2DDecoder() {}
     Texture2DDecoder.decode = function decode(engine, bufferReader, restoredTexture) {
         return new engineCore.AssetPromise(function(resolve, reject) {
-            bufferReader.nextStr();
+            var url = bufferReader.nextStr();
             var mipmap = !!bufferReader.nextUint8();
             var filterMode = bufferReader.nextUint8();
             var anisoLevel = bufferReader.nextUint8();
@@ -1103,34 +969,58 @@ HDRDecoder._uint32View = new Uint32Array(HDRDecoder._floatView.buffer);
             var format = bufferReader.nextUint8();
             var width = bufferReader.nextUint16();
             var height = bufferReader.nextUint16();
+            var isPixelBuffer = bufferReader.nextUint8();
             var isSRGBColorSpace = !!bufferReader.nextUint8();
-            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);
+            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);
             } else {
-                var blob = new Blob([
-                    imageData
+                var blob = new window.Blob([
+                    imagesData[0]
                 ]);
                 var img = new Image();
                 img.onload = function() {
-                    URL.revokeObjectURL(img.src);
-                    texture.setImageSource(img);
-                    mipmap && texture.generateMipmaps();
-                    resolve(texture);
-                };
-                img.onerror = function(e) {
-                    URL.revokeObjectURL(img.src);
-                    reject(e);
+                    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);
+                    }
                 };
                 img.src = URL.createObjectURL(blob);
             }
@@ -1138,72 +1028,9 @@ HDRDecoder._uint32View = new Uint32Array(HDRDecoder._floatView.buffer);
     };
     return Texture2DDecoder;
 }();
-Texture2DDecoder = __decorate([
+exports.Texture2DDecoder = __decorate([
     decoder("Texture2D")
-], 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);
+], exports.Texture2DDecoder);
 
 function _instanceof(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
@@ -1211,6 +1038,45 @@ 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) {
@@ -1242,9 +1108,8 @@ function _instanceof(left, right) {
     };
     _proto._onDestroy = function _onDestroy() {
         var _this = this;
-        var _this__root;
         ReferResource1.prototype._onDestroy.call(this);
-        (_this__root = this._root) == null ? void 0 : _this__root.destroy();
+        this._root.destroy();
         this._dependenceAssets.forEach(function(asset) {
             if (_instanceof(asset, engineCore.ReferResource)) {
                 // @ts-ignore
@@ -1260,260 +1125,319 @@ function _instanceof(left, right) {
         var _this = this;
         this.data = data;
         this.context = context;
-        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._prefabContextMap = new WeakMap();
+        this._prefabPromiseMap = new Map();
         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, data.refs);
+        this._reflectionParser = new ReflectionParser(context);
     }
     var _proto = HierarchyParser.prototype;
-    _proto.start = function start() {
-        var _this = this;
-        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
-    // ---------------------------------------------------------------------------
+    /** 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() {
-        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 entities = this.data.entities;
-        var entityInstances = this.context.entityInstances;
+        var _this = this;
+        var entitiesConfig = this.data.entities;
+        var entityConfigMap = this.context.entityConfigMap;
+        var entityMap = this.context.entityMap;
         var engine = this._engine;
-        var promises = [];
-        for(var i = 0, n = entities.length; i < n; i++)_this = this, _loop(i);
-        return Promise.all(promises);
-    };
-    // ---------------------------------------------------------------------------
-    // 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 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]);
             }
-        }
-        var rootIndices = this._getRootIndices();
-        for(var i1 = 0, n1 = rootIndices.length; i1 < n1; i1++){
-            this._handleRootEntity(rootIndices[i1]);
-        }
+            // 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;
+        });
     };
-    // ---------------------------------------------------------------------------
-    // 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
-                });
+        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;
             }
-        }
-    };
-    // ---------------------------------------------------------------------------
-    // 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);
-    };
-    // ---------------------------------------------------------------------------
-    // Stage 5: Apply prefab instance overrides
-    // ---------------------------------------------------------------------------
-    _proto._parsePrefabOverrides = function _parsePrefabOverrides() {
-        var entities = this.data.entities;
-        var entityInstances = this.context.entityInstances;
+            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));
+                    }
+                })));
+            }
+        };
+        var _this = this;
+        var entitiesConfig = this.data.entities;
+        var entityMap = this.context.entityMap;
         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);
-        }
+        for(var i = 0, l = entitiesConfig.length; i < l; i++)_loop(i);
         return Promise.all(promises);
     };
-    _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));
+    _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();
+                    }
+                }
             }
         }
-        // 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]);
+    };
+    _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();
+                    }
+                }
             }
         }
-        // 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();
-            }
+    };
+    _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]);
         }
-        // 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();
-            }
+        for(var i1 = 0; i1 < rootIds.length; i1++){
+            this._handleRootEntity(rootIds[i1]);
         }
     };
-    // ---------------------------------------------------------------------------
-    // Prefab instance loading
-    // ---------------------------------------------------------------------------
-    _proto._loadPrefabInstance = function _loadPrefabInstance(entityConfig, engine) {
+    _proto._getEntityByConfig = function _getEntityByConfig(entityConfig, engine) {
         var _this = this;
-        var instance = entityConfig.instance;
-        var refItem;
-        try {
-            refItem = resolveRefItem(this.data.refs, instance.asset, "HierarchyParser", "instance.asset");
-        } catch (error) {
-            return Promise.reject(error);
+        var entityPromise;
+        if (entityConfig.assetUrl) {
+            entityPromise = this._parsePrefab(entityConfig, engine);
+        } else if (entityConfig.strippedId) {
+            entityPromise = this._parseStrippedEntity(entityConfig);
+        } else {
+            entityPromise = this._parseEntity(entityConfig, engine);
         }
+        return entityPromise.then(function(entity) {
+            return _this._applyEntityData(entity, entityConfig);
+        });
+    };
+    _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._parsePrefab = function _parsePrefab(entityConfig, engine) {
+        var _this = this;
+        var assetUrl = entityConfig.assetUrl;
         return engine.resourceManager// @ts-ignore
-        .getResourceByRef(refItem).then(function(prefabResource) {
+        .getResourceByRef({
+            url: assetUrl
+        }).then(function(prefabResource) {
             var entity = _instanceof(prefabResource, PrefabResource) ? prefabResource.instantiate() : prefabResource.instantiateSceneRoot();
-            _this._onEntityCreated(entity);
+            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);
+                }
+            }
             return entity;
         });
     };
-    // ---------------------------------------------------------------------------
-    // 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;
-    };
-    /** 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._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);
+        });
     };
-    /** 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);
+    _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);
+            }
+        }
     };
-    HierarchyParser._isPrefabInstanceEntity = function _isPrefabInstanceEntity(entityConfig) {
-        return "instance" in entityConfig;
+    _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);
+        }
     };
-    /** 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._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);
     };
+    _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) {
@@ -1527,42 +1451,90 @@ function _instanceof(left, right) {
    */ _proto._collectDependentAssets = function _collectDependentAssets(data) {
         var context = this.context;
         var resourceManager = context.resourceManager;
-        var refs = data.refs;
-        for(var i = 0, n = refs.length; i < n; i++){
+        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;
             // @ts-ignore
-            context._addDependentAsset(resourceManager.getResourceByRef(refs[i]));
+            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));
+            }
         }
     };
-    _proto._getRootIndices = function _getRootIndices() {
-        return this.data.scene.rootEntities;
-    };
-    _proto._handleRootEntity = function _handleRootEntity(index) {
-        this.scene.addRootEntity(this.context.entityInstances[index]);
+    _proto._handleRootEntity = function _handleRootEntity(id) {
+        var entityMap = this.context.entityMap;
+        this.scene.addRootEntity(entityMap.get(id));
     };
     _proto._clearAndResolve = function _clearAndResolve() {
         this.context.clear();
         return this.scene;
     };
-    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;
-}({});
+    _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);
 
 /**
  * Decode engine binary resource.
@@ -3045,45 +3017,6 @@ 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
  */ /**
@@ -3705,13 +3638,11 @@ 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;
@@ -4832,6 +4763,7 @@ 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;
@@ -4845,6 +4777,7 @@ 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;
         }
@@ -4974,15 +4907,13 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
         if (rootBoneIndex !== -1) {
             engineMath.BoundingBox.transform(mesh.bounds, inverseBindMatrices[rootBoneIndex], skinnedMeshRenderer.localBounds);
         } else {
-            // rootBone can be outside skin.joints, so it has no inverse bind matrix
-            var inverseRootBoneWorld = GLTFSceneParser._tempMatrix;
+            var inverseRootBoneWorld = new engineMath.Matrix();
             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);
@@ -5017,31 +4948,36 @@ exports.GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
                 skin.joints[i] = bone.name;
             }
             skin.bones = bones;
-            // 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
+            // Get skeleton
             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._findSkeletonRootBone(joints, entities);
-                if (!rootBone1) {
+                var rootBone1 = _this._findSkinRootBoneByLCA(index, joints, entities, glTF.nodes);
+                if (rootBone1) {
+                    skin.rootBone = rootBone1;
+                } else {
                     throw "Failed to find skeleton root bone.";
                 }
-                skin.rootBone = rootBone1;
             }
             return skin;
         });
         return engineCore.AssetPromise.resolve(skinPromise);
     };
-    /**
-   * 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;){
+    _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;){
             var index = _step.value;
             var path = new Array();
             var entity = entities[index];
@@ -5049,17 +4985,22 @@ exports.GLTFSkinParser = /*#__PURE__*/ function(GLTFParser) {
                 path.unshift(entity);
                 entity = entity.parent;
             }
-            paths[index] = path;
+            if (path.length) {
+                paths.push(path);
+            }
+        }
+        if (!paths.length) {
+            return null;
         }
         var rootNode = null;
         for(var i = 0;; i++){
-            var path1 = paths[joints[0]];
+            var path1 = paths[0];
             if (i >= path1.length) {
                 return rootNode;
             }
             var entity1 = path1[i];
-            for(var j = 1, m = joints.length; j < m; j++){
-                path1 = paths[joints[j]];
+            for(var j = 1, m = paths.length; j < m; j++){
+                path1 = paths[j];
                 if (i >= path1.length || entity1 !== path1[i]) {
                     return rootNode;
                 }
@@ -5122,7 +5063,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.Texture;
+            var type = ext.startsWith("ktx") ? engineCore.AssetType.KTX : engineCore.AssetType.Texture2D;
             texture = engine.resourceManager.load({
                 url: engineCore.Utils.resolveAbsoluteUrl(url, uri),
                 type: type,
@@ -5339,17 +5280,15 @@ var PrefabParser = /*#__PURE__*/ function(HierarchyParser) {
         return _this;
     }
     var _proto = PrefabParser.prototype;
-    _proto._onEntityCreated = function _onEntityCreated(entity) {
+    _proto._applyEntityData = function _applyEntityData(entity, entityConfig) {
+        if (entityConfig === void 0) entityConfig = {};
+        HierarchyParser.prototype._applyEntityData.call(this, entity, entityConfig);
         // @ts-ignore
         entity._markAsTemplate(this.context.resource);
+        return entity;
     };
-    _proto._getRootIndices = function _getRootIndices() {
-        return [
-            this.data.root
-        ];
-    };
-    _proto._handleRootEntity = function _handleRootEntity(index) {
-        this.prefabResource._root = this.context.entityInstances[index];
+    _proto._handleRootEntity = function _handleRootEntity(id) {
+        this.prefabResource._root = this.context.entityMap.get(id);
     };
     _proto._clearAndResolve = function _clearAndResolve() {
         this.context.clear();
@@ -5360,7 +5299,9 @@ 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;
+        return parser.promise.then(function() {
+            return prefabResource;
+        });
     };
     return PrefabParser;
 }(HierarchyParser);
@@ -5700,6 +5641,15 @@ 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() {
@@ -5760,7 +5710,7 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                     break;
             }
         };
-        var name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros;
+        var name = materialSchema.name, shaderData = materialSchema.shaderData, macros = materialSchema.macros, renderState = materialSchema.renderState;
         var material = new engineCore.Material(engine, shader);
         material.name = name;
         var texturePromises = new Array();
@@ -5774,6 +5724,7 @@ var MaterialLoader = /*#__PURE__*/ function(Loader) {
                 materialShaderData.enableMacro(name1, value);
             }
         }
+        parseProperty(material, "renderState", renderState);
         return Promise.all(texturePromises).then(function() {
             return material;
         });
@@ -5988,7 +5939,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.Texture,
+                            type: (_atlasItem_type = atlasItem.type) != null ? _atlasItem_type : engineCore.AssetType.Texture2D,
                             params: {
                                 format: format,
                                 mipmap: mipmap
@@ -6038,7 +5989,8 @@ 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);
             }
-            config.atlasRotated && (sprite.atlasRotated = true);
+            var _config_atlasRotated;
+            sprite.atlasRotated = (_config_atlasRotated = config.atlasRotated) != null ? _config_atlasRotated : false;
         }
         width === undefined || (sprite.width = width);
         height === undefined || (sprite.height = height);
@@ -6094,183 +6046,490 @@ var SpriteLoader = /*#__PURE__*/ function(Loader) {
             });
         }
     };
-    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);
+    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--;
+        }
+        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
+    ]
+];
 
-var TextureLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(TextureLoader, Loader);
-    function TextureLoader() {
+var TextureCubeLoader = /*#__PURE__*/ function(Loader) {
+    _inherits(TextureCubeLoader, Loader);
+    function TextureCubeLoader() {
         return Loader.apply(this, arguments) || this;
     }
-    var _proto = TextureLoader.prototype;
+    var _proto = TextureCubeLoader.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;
-            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 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;
+                }
                 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, _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);
+                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));
                 resolve(texture);
-            };
-            img.onerror = function(e) {
-                URL.revokeObjectURL(img.src);
-                reject(e);
-            };
-            img.src = URL.createObjectURL(blob);
+            }).catch(reject);
         });
     };
-    _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;
+    return TextureCubeLoader;
 }(engineCore.Loader);
-TextureLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.Texture, [
-        "tex",
-        "png",
-        "jpg",
-        "webp",
-        "jpeg",
+TextureCubeLoader = __decorate([
+    engineCore.resourceLoader(engineCore.AssetType.TextureCube, [
+        "texCube",
         "hdr"
     ])
-], TextureLoader);
-var TextureContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
-    _inherits(TextureContentRestorer, ContentRestorer);
-    function TextureContentRestorer(resource, url, requestConfig) {
+], TextureCubeLoader);
+var HDRContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
+    _inherits(HDRContentRestorer, ContentRestorer);
+    function HDRContentRestorer(resource, url, requestConfig) {
         var _this;
         _this = ContentRestorer.call(this, resource) || this, _this.url = url, _this.requestConfig = requestConfig;
         return _this;
     }
-    var _proto = TextureContentRestorer.prototype;
+    var _proto = HDRContentRestorer.prototype;
     _proto.restoreContent = function restoreContent() {
         var _this = this;
-        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 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 TextureContentRestorer;
+    return HDRContentRestorer;
 }(engineCore.ContentRestorer);
 
 var AudioLoader = /*#__PURE__*/ function(Loader) {
@@ -6288,7 +6547,8 @@ var AudioLoader = /*#__PURE__*/ function(Loader) {
             resourceManager// @ts-ignore
             ._request(url, requestConfig).then(function(arrayBuffer) {
                 var audioClip = new engineCore.AudioClip(resourceManager.engine);
-                AudioLoader._getDecodeContext().decodeAudioData(arrayBuffer).then(function(result) {
+                // @ts-ignore
+                engineCore.AudioManager.getContext().decodeAudioData(arrayBuffer).then(function(result) {
                     // @ts-ignore
                     audioClip._setAudioSource(result);
                     if (url.indexOf("data:") !== 0) {
@@ -6304,12 +6564,6 @@ 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([
@@ -6317,12 +6571,58 @@ 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() {
@@ -6330,29 +6630,32 @@ 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) {
-            return engineCore.Shader.create(code, undefined, url);
+            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;
+            });
         });
     };
+    _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",
-        "shaderc"
+        "shader"
     ])
 ], ShaderLoader);
 
@@ -6432,122 +6735,6 @@ 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() {
@@ -6561,15 +6748,130 @@ var SceneLoader = /*#__PURE__*/ function(Loader) {
             ._request(item.url, _extends({}, item, {
                 type: "json"
             })).then(function(data) {
-                var _data_scene_name;
-                var scene = new engineCore.Scene(engine, (_data_scene_name = data.scene.name) != null ? _data_scene_name : "");
+                var _data_name;
+                var scene = new engineCore.Scene(engine, (_data_name = data.name) != null ? _data_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() {
-                    return applySceneData(scene, data.scene, resourceManager, data.refs).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() {
                         resolve(scene);
                     });
                 });