@galacean/engine-loader 2.0.0-alpha.24 → 2.0.0-alpha.26

package/dist/main.js

@@ -949,11 +949,190 @@ var ReflectionParser = /*#__PURE__*/ function() {
     return ReflectionParser;
 }();
 
-exports.Texture2DDecoder = /*#__PURE__*/ function() {
+/**
+ * HDR (Radiance RGBE) image decoder.
+ *
+ * Decodes .hdr files into pixel data. Supports parsing the header
+ * and decoding RLE-compressed RGBE scanlines into R16G16B16A16 half-float pixels.
+ */ var HDRDecoder = /*#__PURE__*/ function() {
+    function HDRDecoder() {}
+    /**
+   * Parse the header of an HDR file.
+   * @returns Header info including width, height, and data start position.
+   */ HDRDecoder.parseHeader = function parseHeader(uint8array) {
+        var line = this._readStringLine(uint8array, 0);
+        if (line[0] !== "#" || line[1] !== "?") {
+            throw "HDRDecoder: invalid file header";
+        }
+        var endOfHeader = false;
+        var findFormat = false;
+        var lineIndex = 0;
+        do {
+            lineIndex += line.length + 1;
+            line = this._readStringLine(uint8array, lineIndex);
+            if (line === "FORMAT=32-bit_rle_rgbe") findFormat = true;
+            else if (line.length === 0) endOfHeader = true;
+        }while (!endOfHeader);
+        if (!findFormat) {
+            throw "HDRDecoder: unsupported format, expected 32-bit_rle_rgbe";
+        }
+        lineIndex += line.length + 1;
+        line = this._readStringLine(uint8array, lineIndex);
+        var match = /^\-Y (.*) \+X (.*)$/g.exec(line);
+        if (!match || match.length < 3) {
+            throw "HDRDecoder: missing image size, only -Y +X layout is supported";
+        }
+        var width = parseInt(match[2]);
+        var height = parseInt(match[1]);
+        if (width < 8 || width > 0x7fff) {
+            throw "HDRDecoder: unsupported image width, must be between 8 and 32767";
+        }
+        return {
+            height: height,
+            width: width,
+            dataPosition: lineIndex + line.length + 1
+        };
+    };
+    /**
+   * Decode an HDR file buffer into R16G16B16A16 half-float pixel data.
+   * @param buffer - The full HDR file as Uint8Array.
+   * @returns Object with width, height, and half-float pixel data.
+   */ HDRDecoder.decode = function decode(buffer) {
+        var header = this.parseHeader(buffer);
+        var width = header.width, height = header.height, dataPosition = header.dataPosition;
+        var rgbe = this._readPixels(buffer.subarray(dataPosition), width, height);
+        var pixels = this._rgbeToHalfFloat(rgbe, width, height);
+        return {
+            width: width,
+            height: height,
+            pixels: pixels
+        };
+    };
+    /**
+   * Convert RGBE pixel data to R16G16B16A16 half-float.
+   */ HDRDecoder._rgbeToHalfFloat = function _rgbeToHalfFloat(rgbe, width, height) {
+        var floatView = this._floatView;
+        var uint32View = this._uint32View;
+        var _this__float2HalfTables = this._float2HalfTables, baseTable = _this__float2HalfTables.baseTable, shiftTable = _this__float2HalfTables.shiftTable;
+        var one = 0x3c00; // Half float 1.0
+        var pixelCount = width * height;
+        var result = new Uint16Array(pixelCount * 4);
+        for(var i = 0; i < pixelCount; i++){
+            var srcIdx = i * 4;
+            var dstIdx = i * 4;
+            var scaleFactor = Math.pow(2, rgbe[srcIdx + 3] - 128 - 8);
+            for(var c = 0; c < 3; c++){
+                floatView[0] = Math.min(rgbe[srcIdx + c] * scaleFactor, 65504);
+                var f = uint32View[0];
+                var e = f >> 23 & 0x1ff;
+                result[dstIdx + c] = baseTable[e] + ((f & 0x007fffff) >> shiftTable[e]);
+            }
+            result[dstIdx + 3] = one;
+        }
+        return result;
+    };
+    /**
+   * Decode RLE-compressed RGBE scanlines into raw RGBE pixel data.
+   */ HDRDecoder._readPixels = function _readPixels(buffer, width, height) {
+        var byteLength = buffer.byteLength;
+        var dataRGBA = new Uint8Array(4 * width * height);
+        var offset = 0;
+        var pos = 0;
+        var ptrEnd = 4 * width;
+        var scanLineBuffer = new Uint8Array(ptrEnd);
+        var numScanLines = height;
+        while(numScanLines > 0 && pos < byteLength){
+            var a = buffer[pos++];
+            var b = buffer[pos++];
+            var c = buffer[pos++];
+            var d = buffer[pos++];
+            if (a !== 2 || b !== 2 || c & 0x80 || width < 8 || width > 32767) return buffer;
+            if ((c << 8 | d) !== width) throw "HDRDecoder: wrong scanline width";
+            var ptr = 0;
+            while(ptr < ptrEnd && pos < byteLength){
+                var count = buffer[pos++];
+                var isEncodedRun = count > 128;
+                if (isEncodedRun) count -= 128;
+                if (count === 0 || ptr + count > ptrEnd) throw "HDRDecoder: bad scanline data";
+                if (isEncodedRun) {
+                    var byteValue = buffer[pos++];
+                    for(var i = 0; i < count; i++)scanLineBuffer[ptr++] = byteValue;
+                } else {
+                    scanLineBuffer.set(buffer.subarray(pos, pos + count), ptr);
+                    ptr += count;
+                    pos += count;
+                }
+            }
+            for(var i1 = 0; i1 < width; i1++, offset += 4){
+                dataRGBA[offset] = scanLineBuffer[i1];
+                dataRGBA[offset + 1] = scanLineBuffer[i1 + width];
+                dataRGBA[offset + 2] = scanLineBuffer[i1 + width * 2];
+                dataRGBA[offset + 3] = scanLineBuffer[i1 + width * 3];
+            }
+            numScanLines--;
+        }
+        return dataRGBA;
+    };
+    HDRDecoder._generateFloat2HalfTables = function _generateFloat2HalfTables() {
+        var baseTable = new Uint32Array(512);
+        var shiftTable = new Uint32Array(512);
+        for(var i = 0; i < 256; ++i){
+            var e = i - 127;
+            if (e < -27) {
+                baseTable[i] = 0x0000;
+                baseTable[i | 0x100] = 0x8000;
+                shiftTable[i] = 24;
+                shiftTable[i | 0x100] = 24;
+            } else if (e < -14) {
+                baseTable[i] = 0x0400 >> -e - 14;
+                baseTable[i | 0x100] = 0x0400 >> -e - 14 | 0x8000;
+                shiftTable[i] = -e - 1;
+                shiftTable[i | 0x100] = -e - 1;
+            } else if (e <= 15) {
+                baseTable[i] = e + 15 << 10;
+                baseTable[i | 0x100] = e + 15 << 10 | 0x8000;
+                shiftTable[i] = 13;
+                shiftTable[i | 0x100] = 13;
+            } else if (e < 128) {
+                baseTable[i] = 0x7c00;
+                baseTable[i | 0x100] = 0xfc00;
+                shiftTable[i] = 24;
+                shiftTable[i | 0x100] = 24;
+            } else {
+                baseTable[i] = 0x7c00;
+                baseTable[i | 0x100] = 0xfc00;
+                shiftTable[i] = 13;
+                shiftTable[i | 0x100] = 13;
+            }
+        }
+        return {
+            baseTable: baseTable,
+            shiftTable: shiftTable
+        };
+    };
+    HDRDecoder._readStringLine = function _readStringLine(uint8array, startIndex) {
+        var line = "";
+        for(var i = startIndex, n = uint8array.length; i < n; i++){
+            var character = String.fromCharCode(uint8array[i]);
+            if (character === "\n") break;
+            line += character;
+        }
+        return line;
+    };
+    return HDRDecoder;
+}();
+HDRDecoder._float2HalfTables = HDRDecoder._generateFloat2HalfTables();
+HDRDecoder._floatView = new Float32Array(1);
+HDRDecoder._uint32View = new Uint32Array(HDRDecoder._floatView.buffer);
+
+/**
+ * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
+ * [format(1B)] [width(2B)] [height(2B)] [isSRGBColorSpace(1B)] [Uint32(imageSize) + imageBytes]
+ */ var Texture2DDecoder = /*#__PURE__*/ function() {
     function Texture2DDecoder() {}
     Texture2DDecoder.decode = function decode(engine, bufferReader, restoredTexture) {
         return new engineCore.AssetPromise(function(resolve, reject) {
-            var url = bufferReader.nextStr();
+            bufferReader.nextStr();
             var mipmap = !!bufferReader.nextUint8();
             var filterMode = bufferReader.nextUint8();
             var anisoLevel = bufferReader.nextUint8();
@@ -962,58 +1141,34 @@ exports.Texture2DDecoder = /*#__PURE__*/ function() {
             var format = bufferReader.nextUint8();
             var width = bufferReader.nextUint16();
             var height = bufferReader.nextUint16();
-            var isPixelBuffer = bufferReader.nextUint8();
             var isSRGBColorSpace = !!bufferReader.nextUint8();
-            var mipCount = bufferReader.nextUint8();
-            var imagesData = bufferReader.nextImagesData(mipCount);
-            var texture2D = restoredTexture || new engineCore.Texture2D(engine, width, height, format, mipmap, isSRGBColorSpace);
-            texture2D.filterMode = filterMode;
-            texture2D.anisoLevel = anisoLevel;
-            texture2D.wrapModeU = wrapModeU;
-            texture2D.wrapModeV = wrapModeV;
-            if (isPixelBuffer) {
-                var pixelBuffer = imagesData[0];
-                texture2D.setPixelBuffer(pixelBuffer);
-                if (mipmap) {
-                    texture2D.generateMipmaps();
-                    for(var i = 1; i < mipCount; i++){
-                        var pixelBuffer1 = imagesData[i];
-                        texture2D.setPixelBuffer(pixelBuffer1, i);
-                    }
-                }
-                // @ts-ignore
-                engine.resourceManager._objectPool[url] = texture2D;
-                resolve(texture2D);
+            var imageData = bufferReader.nextImagesData(1)[0];
+            var isHDR = imageData[0] === 0x23 && imageData[1] === 0x3f;
+            var textureFormat = isHDR ? engineCore.TextureFormat.R16G16B16A16 : format;
+            var texture = restoredTexture || new engineCore.Texture2D(engine, width, height, textureFormat, mipmap, isHDR ? false : isSRGBColorSpace);
+            texture.filterMode = filterMode;
+            texture.anisoLevel = anisoLevel;
+            texture.wrapModeU = wrapModeU;
+            texture.wrapModeV = wrapModeV;
+            if (isHDR) {
+                var pixels = HDRDecoder.decode(imageData).pixels;
+                texture.setPixelBuffer(pixels);
+                mipmap && texture.generateMipmaps();
+                resolve(texture);
             } else {
-                var blob = new window.Blob([
-                    imagesData[0]
+                var blob = new Blob([
+                    imageData
                 ]);
                 var img = new Image();
                 img.onload = function() {
-                    texture2D.setImageSource(img);
-                    var completedCount = 0;
-                    var onComplete = function() {
-                        completedCount++;
-                        if (completedCount >= mipCount) {
-                            resolve(texture2D);
-                        }
-                    };
-                    onComplete();
-                    if (mipmap) {
-                        var _loop = function(i) {
-                            var blob = new window.Blob([
-                                imagesData[i]
-                            ]);
-                            var img = new Image();
-                            img.onload = function() {
-                                texture2D.setImageSource(img, i);
-                                onComplete();
-                            };
-                            img.src = URL.createObjectURL(blob);
-                        };
-                        texture2D.generateMipmaps();
-                        for(var i = 1; i < mipCount; i++)_loop(i);
-                    }
+                    URL.revokeObjectURL(img.src);
+                    texture.setImageSource(img);
+                    mipmap && texture.generateMipmaps();
+                    resolve(texture);
+                };
+                img.onerror = function(e) {
+                    URL.revokeObjectURL(img.src);
+                    reject(e);
                 };
                 img.src = URL.createObjectURL(blob);
             }
@@ -1021,9 +1176,72 @@ exports.Texture2DDecoder = /*#__PURE__*/ function() {
     };
     return Texture2DDecoder;
 }();
-exports.Texture2DDecoder = __decorate([
+Texture2DDecoder = __decorate([
     decoder("Texture2D")
-], exports.Texture2DDecoder);
+], Texture2DDecoder);
+
+/**
+ * Data format: [url] [mipmap(1B)] [filterMode(1B)] [anisoLevel(1B)] [wrapModeU(1B)] [wrapModeV(1B)]
+ * [format(1B)] [faceSize(2B)] [isSRGBColorSpace(1B)] [Uint32(size) + faceBytes] × 6
+ */ var TextureCubeDecoder = /*#__PURE__*/ function() {
+    function TextureCubeDecoder() {}
+    TextureCubeDecoder.decode = function decode(engine, bufferReader, restoredTexture) {
+        return new engineCore.AssetPromise(function(resolve, reject) {
+            bufferReader.nextStr();
+            var mipmap = !!bufferReader.nextUint8();
+            var filterMode = bufferReader.nextUint8();
+            var anisoLevel = bufferReader.nextUint8();
+            var wrapModeU = bufferReader.nextUint8();
+            var wrapModeV = bufferReader.nextUint8();
+            var format = bufferReader.nextUint8();
+            var faceSize = bufferReader.nextUint16();
+            var isSRGBColorSpace = !!bufferReader.nextUint8();
+            var facesData = bufferReader.nextImagesData(6);
+            // Detect format by first face's magic bytes
+            var isHDR = facesData[0][0] === 0x23 && facesData[0][1] === 0x3f;
+            var textureFormat = isHDR ? engineCore.TextureFormat.R16G16B16A16 : format;
+            var texture = restoredTexture || new engineCore.TextureCube(engine, faceSize, textureFormat, mipmap, isSRGBColorSpace);
+            texture.filterMode = filterMode;
+            texture.anisoLevel = anisoLevel;
+            texture.wrapModeU = wrapModeU;
+            texture.wrapModeV = wrapModeV;
+            if (isHDR) {
+                for(var i = 0; i < 6; i++){
+                    var pixels = HDRDecoder.decode(facesData[i]).pixels;
+                    texture.setPixelBuffer(engineCore.TextureCubeFace.PositiveX + i, pixels, 0);
+                }
+                mipmap && texture.generateMipmaps();
+                resolve(texture);
+            } else {
+                var _loop = function(i1) {
+                    var blob = new Blob([
+                        facesData[i1]
+                    ]);
+                    var img = new Image();
+                    img.onload = function() {
+                        URL.revokeObjectURL(img.src);
+                        texture.setImageSource(engineCore.TextureCubeFace.PositiveX + i1, img);
+                        if (++loadedCount === 6) {
+                            mipmap && texture.generateMipmaps();
+                            resolve(texture);
+                        }
+                    };
+                    img.onerror = function(e) {
+                        URL.revokeObjectURL(img.src);
+                        reject(e);
+                    };
+                    img.src = URL.createObjectURL(blob);
+                };
+                var loadedCount = 0;
+                for(var i1 = 0; i1 < 6; i1++)_loop(i1);
+            }
+        });
+    };
+    return TextureCubeDecoder;
+}();
+TextureCubeDecoder = __decorate([
+    decoder("TextureCube")
+], TextureCubeDecoder);
 
 function _instanceof(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
@@ -3631,11 +3849,13 @@ function registerGLTFParser(pipeline) {
             });
             var img = new Image();
             img.onerror = function() {
+                URL.revokeObjectURL(img.src);
                 reject(new Error("Failed to load image buffer"));
             };
             img.onload = function() {
                 // Call requestAnimationFrame to avoid iOS's bug.
                 requestAnimationFrame(function() {
+                    URL.revokeObjectURL(img.src);
                     resolve(img);
                     img.onload = null;
                     img.onerror = null;
@@ -4763,16 +4983,11 @@ exports.GLTFSceneParser = /*#__PURE__*/ function(GLTFParser1) {
         var isDefaultScene = scene === index;
         var sceneNodes = sceneInfo.nodes || [];
         var sceneRoot;
-        if (sceneNodes.length === 1) {
-            sceneRoot = context.get(GLTFParserType.Entity, sceneNodes[0]);
-        } else {
-            sceneRoot = new engineCore.Entity(engine, "GLTF_ROOT");
-            // @ts-ignore
-            sceneRoot._markAsTemplate(glTFResource);
-            for(var i = 0; i < sceneNodes.length; i++){
-                var childEntity = context.get(GLTFParserType.Entity, sceneNodes[i]);
-                sceneRoot.addChild(childEntity);
-            }
+        sceneRoot = new engineCore.Entity(engine, "GLTF_ROOT");
+        // @ts-ignore
+        sceneRoot._markAsTemplate(glTFResource);
+        for(var i = 0; i < sceneNodes.length; i++){
+            sceneRoot.addChild(context.get(GLTFParserType.Entity, sceneNodes[i]));
         }
         if (isDefaultScene) {
             glTFResource._defaultSceneRoot = sceneRoot;
@@ -5065,7 +5280,7 @@ exports.GLTFTextureParser = /*#__PURE__*/ function(GLTFParser1) {
         if (uri) {
             var extIndex = uri.lastIndexOf(".");
             var ext = uri.substring(extIndex + 1);
-            var type = ext.startsWith("ktx") ? engineCore.AssetType.KTX : engineCore.AssetType.Texture2D;
+            var type = ext.startsWith("ktx") ? engineCore.AssetType.KTX : engineCore.AssetType.Texture;
             texture = engine.resourceManager.load({
                 url: engineCore.Utils.resolveAbsoluteUrl(url, uri),
                 type: type,
@@ -5941,7 +6156,7 @@ var SpriteAtlasLoader = /*#__PURE__*/ function(Loader) {
                         var _atlasItem_type;
                         chainPromises.push(resourceManager.load({
                             url: engineCore.Utils.resolveAbsoluteUrl(item.url, atlasItem.img),
-                            type: (_atlasItem_type = atlasItem.type) != null ? _atlasItem_type : engineCore.AssetType.Texture2D,
+                            type: (_atlasItem_type = atlasItem.type) != null ? _atlasItem_type : engineCore.AssetType.Texture,
                             params: {
                                 format: format,
                                 mipmap: mipmap
@@ -6079,26 +6294,12 @@ TextLoader = __decorate([
     ])
 ], 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() {
+var TextureLoader = /*#__PURE__*/ function(Loader) {
+    _inherits(TextureLoader, Loader);
+    function TextureLoader() {
         return Loader.apply(this, arguments) || this;
     }
-    var _proto = Texture2DLoader.prototype;
+    var _proto = TextureLoader.prototype;
     _proto.load = function load(item, resourceManager) {
         var _this = this;
         var url = item.url;
@@ -6108,429 +6309,136 @@ var Texture2DLoader = /*#__PURE__*/ function(Loader) {
         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);
-                }
+                _this._decode(buffer, item, resourceManager).then(function(texture) {
+                    resourceManager.addContentRestorer(new TextureContentRestorer(texture, url, requestConfig));
+                    resolve(texture);
+                }, reject);
             }).catch(reject);
         });
     };
-    _proto._createTexture = function _createTexture(img, item, resourceManager) {
+    _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 _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);
+                resolve(texture);
+            };
+            img.onerror = function(e) {
+                URL.revokeObjectURL(img.src);
+                reject(e);
+            };
+            img.src = URL.createObjectURL(blob);
+        });
+    };
+    _proto._applyParams = function _applyParams(texture, item) {
         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);
+        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;
-        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;
+    return TextureLoader;
 }(engineCore.Loader);
-Texture2DLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.Texture2D, [
+TextureLoader = __decorate([
+    engineCore.resourceLoader(engineCore.AssetType.Texture, [
+        "tex",
         "png",
         "jpg",
         "webp",
         "jpeg",
-        "tex"
+        "hdr"
     ])
-], Texture2DLoader);
-var Texture2DContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
-    _inherits(Texture2DContentRestorer, ContentRestorer);
-    function Texture2DContentRestorer(resource, url, requestConfig) {
+], TextureLoader);
+var TextureContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
+    _inherits(TextureContentRestorer, ContentRestorer);
+    function TextureContentRestorer(resource, url, requestConfig) {
         var _this;
         _this = ContentRestorer.call(this, resource) || this, _this.url = url, _this.requestConfig = requestConfig;
         return _this;
     }
-    var _proto = Texture2DContentRestorer.prototype;
+    var _proto = TextureContentRestorer.prototype;
     _proto.restoreContent = function restoreContent() {
-        var texture = this.resource;
-        var engine = texture.engine;
-        return engine.resourceManager// @ts-ignore
+        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, engine, texture);
-            } else {
-                return loadImageFromBuffer(buffer).then(function(img) {
-                    texture.setImageSource(img);
-                    texture.generateMipmaps();
-                    return texture;
-                });
+                return decode(buffer, _this.resource.engine, _this.resource);
             }
-        });
-    };
-    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];
+            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;
             }
-            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 TextureCubeLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(TextureCubeLoader, Loader);
-    function TextureCubeLoader() {
-        return Loader.apply(this, arguments) || this;
-    }
-    var _proto = TextureCubeLoader.prototype;
-    _proto.load = function load(item, resourceManager) {
-        return new engineCore.AssetPromise(function(resolve, reject) {
-            var engine = resourceManager.engine;
-            var url = item.url;
-            var requestConfig = _extends({}, item, {
-                type: "arraybuffer"
+            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);
             });
-            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_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);
-            }).catch(reject);
         });
     };
-    return TextureCubeLoader;
-}(engineCore.Loader);
-TextureCubeLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.TextureCube, [
-        "texCube",
-        "hdr"
-    ])
-], 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 = HDRContentRestorer.prototype;
-    _proto.restoreContent = function restoreContent() {
-        var _this = this;
-        return new engineCore.AssetPromise(function(resolve, reject) {
-            var resource = _this.resource;
-            resource.engine.resourceManager// @ts-ignore
-            ._request(_this.url, _this.requestConfig).then(function(buffer) {
-                var bufferArray = new Uint8Array(buffer);
-                HDRDecoder.decodeFaces(bufferArray, HDRDecoder.parseHeader(bufferArray), function(faceIndex, data) {
-                    resource.setPixelBuffer(engineCore.TextureCubeFace.PositiveX + faceIndex, data, 0);
-                });
-                resource.generateMipmaps();
-                resolve(resource);
-            }).catch(reject);
-        });
-    };
-    return HDRContentRestorer;
+    return TextureContentRestorer;
 }(engineCore.ContentRestorer);
 
 var AudioLoader = /*#__PURE__*/ function(Loader) {
@@ -6629,6 +6537,15 @@ var ShaderLoader = /*#__PURE__*/ function(Loader) {
     _proto.load = function load(item, resourceManager) {
         var _this = this;
         var url = item.url;
+        if (url.endsWith(".gsp")) {
+            // @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"
@@ -6652,8 +6569,7 @@ var ShaderLoader = /*#__PURE__*/ function(Loader) {
 ShaderLoader._builtinRegex = /^\s*\/\/\s*@builtin\s+(\w+)/;
 ShaderLoader = __decorate([
     engineCore.resourceLoader(engineCore.AssetType.Shader, [
-        "gs",
-        "gsl"
+        "shader"
     ])
 ], ShaderLoader);