@galacean/engine-loader 0.0.0-experimental-2.0-game.2 → 0.0.0-experimental-2.0-game.3

package/dist/main.js

@@ -956,190 +956,11 @@ var ReflectionParser = /*#__PURE__*/ function() {
     return ReflectionParser;
 }();
 
-/**
- * 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() {
+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();
@@ -1148,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);
             }
@@ -1183,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]) {
@@ -3856,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;
@@ -5327,7 +5107,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,
@@ -6203,7 +5983,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
@@ -6341,12 +6121,26 @@ TextLoader = __decorate([
     ])
 ], TextLoader);
 
-var TextureLoader = /*#__PURE__*/ function(Loader) {
-    _inherits(TextureLoader, Loader);
-    function TextureLoader() {
+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 = TextureLoader.prototype;
+    var _proto = Texture2DLoader.prototype;
     _proto.load = function load(item, resourceManager) {
         var _this = this;
         var url = item.url;
@@ -6356,136 +6150,429 @@ var TextureLoader = /*#__PURE__*/ function(Loader) {
         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);
+                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._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) {
+    _proto._createTexture = function _createTexture(img, item, resourceManager) {
         var _item_params;
-        var _ref = (_item_params = item.params) != null ? _item_params : {}, anisoLevel = _ref.anisoLevel, wrapModeU = _ref.wrapModeU, wrapModeV = _ref.wrapModeV, filterMode = _ref.filterMode;
+        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 TextureLoader;
+    return Texture2DLoader;
 }(engineCore.Loader);
-TextureLoader = __decorate([
-    engineCore.resourceLoader(engineCore.AssetType.Texture, [
-        "tex",
+Texture2DLoader = __decorate([
+    engineCore.resourceLoader(engineCore.AssetType.Texture2D, [
         "png",
         "jpg",
         "webp",
         "jpeg",
-        "hdr"
+        "tex"
     ])
-], TextureLoader);
-var TextureContentRestorer = /*#__PURE__*/ function(ContentRestorer) {
-    _inherits(TextureContentRestorer, ContentRestorer);
-    function TextureContentRestorer(resource, url, requestConfig) {
+], 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 = TextureContentRestorer.prototype;
+    var _proto = Texture2DContentRestorer.prototype;
     _proto.restoreContent = function restoreContent() {
-        var _this = this;
-        return this.resource.engine.resourceManager// @ts-ignore
+        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, _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);
+                return decode(buffer, engine, texture);
+            } else {
+                return loadImageFromBuffer(buffer).then(function(img) {
                     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);
+                    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 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"
             });
+            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 TextureContentRestorer;
+    return HDRContentRestorer;
 }(engineCore.ContentRestorer);
 
 var AudioLoader = /*#__PURE__*/ function(Loader) {