@galacean/effects-plugin-ktx2 2.8.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,1458 @@
+/*!
+ * Name: @galacean/effects-plugin-ktx2
+ * Description: Galacean Effects player Khronos Texture 2.0 plugin
+ * Author: Ant Group CO., Ltd.
+ * Contributors: 澄弈
+ * Version: v2.8.0-alpha.0
+ */
+
+import * as EFFECTS from '@galacean/effects';
+import { glContext, TextureSourceType, textureLoaderRegistry, loadBinary } from '@galacean/effects';
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+
+function __generator(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function sent() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+typeof SuppressedError === "function" ? SuppressedError : function _SuppressedError(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * KTX2 transcode target format.
+ * if you modify this file, please also modify KTX2TargetFormat in binomial-workercode.ts
+ */ var KTX2TargetFormat;
+(function(KTX2TargetFormat) {
+    /** RGB(A) compressed format, 128 bits per 4x4 pixel block. */ KTX2TargetFormat[KTX2TargetFormat["ASTC"] = 0] = "ASTC";
+})(KTX2TargetFormat || (KTX2TargetFormat = {}));
+var TextureFormat;
+(function(TextureFormat) {
+    /** RGB format, 8 bits per channel. */ TextureFormat[TextureFormat["R8G8B8"] = 0] = "R8G8B8";
+    /** RGBA format, 8 bits per channel. */ TextureFormat[TextureFormat["R8G8B8A8"] = 1] = "R8G8B8A8";
+    /** RGB(A) compressed format, 128 bits per 4x4 pixel block. */ TextureFormat[TextureFormat["ASTC_4x4"] = 2] = "ASTC_4x4";
+})(TextureFormat || (TextureFormat = {}));
+
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+
+/**
+ * @internal
+ * WorkerPool, T 为发送消息的类型，U 为返回值的类型。
+ */ var WorkerPool = /*#__PURE__*/ function() {
+    function WorkerPool(limitedCount, workerCreator) {
+        if (limitedCount === void 0) limitedCount = 2;
+        this.limitedCount = limitedCount;
+        this.workerCreator = workerCreator;
+        this.taskQueue = [];
+        this.workerStatus = 0;
+        this.initPromises = new Map();
+        this.destroyed = false;
+        if (limitedCount > 8 || limitedCount < 1) {
+            throw new Error("limitedCount must be between 1 and 8");
+        }
+        this.workerItems = new Array(limitedCount);
+    }
+    var _proto = WorkerPool.prototype;
+    _proto.prepareWorker = function prepareWorker() {
+        var count = this.limitedCount;
+        var promises = new Array(count);
+        for(var i = 0; i < count; i++){
+            promises.push(this.ensureWorker(i));
+        }
+        return Promise.all(promises);
+    };
+    _proto.ensureWorker = function ensureWorker(workerId) {
+        if (!this.initPromises.has(workerId)) {
+            this.initPromises.set(workerId, this.initWorker(workerId));
+        }
+        return this.initPromises.get(workerId);
+    };
+    /**
+   * 向 worker 发送消息。
+   * @param message - 要发送给 worker 的消息
+   * @returns 返回一个消息处理结果的 Promise
+   */ _proto.postMessage = function postMessage(message) {
+        var _this = this;
+        if (this.destroyed) {
+            return Promise.reject(new Error("Worker Pool destroyed"));
+        }
+        return new Promise(function(resolve, reject) {
+            var workerId = _this.getIdleWorkerId();
+            if (workerId !== -1) {
+                _this.ensureWorker(workerId).then(function() {
+                    if (_this.destroyed) {
+                        throw new Error("Worker Pool destroyed");
+                    }
+                    var workerItem = _this.workerItems[workerId];
+                    workerItem.resolve = resolve;
+                    workerItem.reject = reject;
+                    workerItem.worker.postMessage(message);
+                }).catch(function(error) {
+                    _this.workerStatus &= ~(1 << workerId);
+                    _this.initPromises.delete(workerId);
+                    reject(error);
+                });
+            } else {
+                _this.taskQueue.push({
+                    resolve: resolve,
+                    reject: reject,
+                    message: message
+                });
+            }
+        });
+    };
+    _proto.initWorker = function initWorker(workerId) {
+        var _this = this;
+        return Promise.resolve(this.workerCreator()).then(function(worker) {
+            if (_this.destroyed) {
+                worker.terminate();
+                throw new Error("Worker Pool destroyed");
+            }
+            var onMessage = _this.onMessage.bind(_this, workerId);
+            var onError = function(event) {
+                var workerItem = _this.workerItems[workerId];
+                if (workerItem) {
+                    workerItem.reject(event.error || new Error(event.message || "Worker error"));
+                    _this.nextTask(workerId);
+                }
+            };
+            worker.addEventListener("message", onMessage);
+            worker.addEventListener("error", onError);
+            _this.workerItems[workerId] = {
+                worker: worker,
+                resolve: function() {},
+                reject: function() {},
+                onMessage: onMessage,
+                onError: onError
+            };
+            return worker;
+        });
+    };
+    /**
+   * 获取空闲的 worker ID，并原子性地标记为忙碌
+   * @returns worker ID，如果没有空闲 worker 返回 -1
+   */ _proto.getIdleWorkerId = function getIdleWorkerId() {
+        for(var i = 0, count = this.limitedCount; i < count; i++){
+            if (!(this.workerStatus & 1 << i)) {
+                this.workerStatus |= 1 << i; // ✅ 原子性标记
+                return i;
+            }
+        }
+        return -1;
+    };
+    _proto.onMessage = function onMessage(workerId, msg) {
+        var workerItem = this.workerItems[workerId];
+        if (!workerItem) {
+            return;
+        }
+        var error = msg.data.error;
+        if (error) {
+            workerItem.reject(error);
+        } else {
+            workerItem.resolve(msg.data);
+        }
+        this.nextTask(workerId);
+    };
+    _proto.nextTask = function nextTask(workerId) {
+        if (this.taskQueue.length) {
+            var taskItem = this.taskQueue.shift();
+            var workerItem = this.workerItems[workerId];
+            if (!workerItem) {
+                taskItem.reject(new Error("Worker not initialized"));
+                this.workerStatus &= ~(1 << workerId);
+                return;
+            }
+            workerItem.resolve = taskItem.resolve;
+            workerItem.reject = taskItem.reject;
+            workerItem.worker.postMessage(taskItem.message);
+        } else {
+            this.workerStatus &= ~(1 << workerId);
+        }
+    };
+    _proto.destroy = function destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        var workerItems = this.workerItems;
+        var error = new Error("Worker Pool destroyed");
+        for(var i = 0, n = workerItems.length; i < n; i++){
+            var workerItem = workerItems[i];
+            if (!workerItem) {
+                continue;
+            }
+            if (workerItem.onMessage) {
+                workerItem.worker.removeEventListener("message", workerItem.onMessage);
+            }
+            if (workerItem.onError) {
+                workerItem.worker.removeEventListener("error", workerItem.onError);
+            }
+            workerItem.worker.terminate();
+            workerItem.reject == null ? void 0 : workerItem.reject.call(workerItem, error);
+        }
+        while(this.taskQueue.length){
+            var _this_taskQueue_shift;
+            (_this_taskQueue_shift = this.taskQueue.shift()) == null ? void 0 : _this_taskQueue_shift.reject(error);
+        }
+        workerItems.length = 0;
+        this.taskQueue.length = 0;
+        this.workerStatus = 0;
+        this.initPromises.clear();
+    };
+    return WorkerPool;
+}();
+
+var TextureTranscoder = /*#__PURE__*/ function() {
+    function TextureTranscoder(workerLimitCount) {
+        this.workerLimitCount = workerLimitCount;
+    }
+    var _proto = TextureTranscoder.prototype;
+    _proto.init = function init() {
+        if (!this.initPromise) {
+            this.initPromise = this.initTranscodeWorkerPool();
+        }
+        return this.initPromise;
+    };
+    _proto.destroy = function destroy() {
+        var _this_transcodeWorkerPool;
+        (_this_transcodeWorkerPool = this.transcodeWorkerPool) == null ? void 0 : _this_transcodeWorkerPool.destroy();
+    };
+    _proto.createTranscodePool = function createTranscodePool(workerURL, transcoderWasm) {
+        this.transcodeWorkerPool = new WorkerPool(this.workerLimitCount, function() {
+            return new Promise(function(resolve, reject) {
+                var onError = function onError(e) {
+                    cleanup();
+                    worker.terminate();
+                    var _e_error;
+                    reject((_e_error = e.error) != null ? _e_error : new Error(e.message || "Worker init error"));
+                };
+                var worker = new Worker(workerURL);
+                var msg = {
+                    type: "init",
+                    transcoderWasm: transcoderWasm
+                };
+                var cleanup = function() {
+                    worker.removeEventListener("message", onMessage);
+                    worker.removeEventListener("error", onError);
+                };
+                function onMessage(e) {
+                    if (e.data.error) {
+                        reject(e.data.error);
+                    } else {
+                        worker.removeEventListener("message", onMessage);
+                        resolve(worker);
+                    }
+                }
+                worker.addEventListener("message", onMessage);
+                worker.addEventListener("error", onError);
+                worker.postMessage(msg);
+            });
+        });
+        return this.transcodeWorkerPool.prepareWorker();
+    };
+    return TextureTranscoder;
+}();
+function decodeText(array) {
+    if (typeof TextDecoder !== "undefined") {
+        return new TextDecoder("utf-8").decode(array);
+    }
+    // TextDecoder polyfill
+    var s = "";
+    for(var i = 0, il = array.length; i < il; i++){
+        s += String.fromCharCode(array[i]);
+    }
+    return decodeURIComponent(encodeURIComponent(s));
+}
+
+var BufferReader = /*#__PURE__*/ function() {
+    function BufferReader(data, byteOffset, byteLength, littleEndian) {
+        if (byteOffset === void 0) byteOffset = 0;
+        if (littleEndian === void 0) littleEndian = true;
+        this.data = data;
+        this.dataView = new DataView(data.buffer, data.byteOffset + byteOffset, byteLength != null ? byteLength : data.byteLength - byteOffset);
+        this.littleEndian = littleEndian;
+        this.pos = 0;
+        this.baseOffset = byteOffset;
+    }
+    var _proto = BufferReader.prototype;
+    _proto.nextUint8 = function nextUint8() {
+        var value = this.dataView.getUint8(this.pos);
+        this.pos += 1;
+        return value;
+    };
+    _proto.nextUint16 = function nextUint16() {
+        var value = this.dataView.getUint16(this.pos, this.littleEndian);
+        this.pos += 2;
+        return value;
+    };
+    _proto.nextUint32 = function nextUint32() {
+        var value = this.dataView.getUint32(this.pos, this.littleEndian);
+        this.pos += 4;
+        return value;
+    };
+    _proto.nextInt32 = function nextInt32() {
+        var value = this.dataView.getInt32(this.pos, this.littleEndian);
+        this.pos += 4;
+        return value;
+    };
+    _proto.nextInt32Array = function nextInt32Array(len) {
+        var value = new Int32Array(this.data.buffer, this.pos + this.dataView.byteOffset, len);
+        this.pos += 4 * len;
+        return value;
+    };
+    _proto.nextFloat32 = function nextFloat32() {
+        var value = this.dataView.getFloat32(this.pos, this.littleEndian);
+        this.pos += 4;
+        return value;
+    };
+    _proto.nextFloat32Array = function nextFloat32Array(len) {
+        var value = new Float32Array(this.data.buffer, this.pos + this.dataView.byteOffset, len);
+        this.pos += 4 * len;
+        return value;
+    };
+    _proto.nextUint32Array = function nextUint32Array(len) {
+        var value = new Uint32Array(this.data.buffer, this.pos + this.dataView.byteOffset, len);
+        this.pos += 4 * len;
+        return value;
+    };
+    _proto.nextUint8Array = function nextUint8Array(len) {
+        var value = new Uint8Array(this.data.buffer, this.pos + this.dataView.byteOffset, len);
+        this.pos += len;
+        return value;
+    };
+    _proto.nextUint64 = function nextUint64() {
+        if (!this.littleEndian) {
+            throw new Error("nextUint64 only supports little-endian");
+        }
+        var left = this.dataView.getUint32(this.pos, this.littleEndian);
+        var right = this.dataView.getUint32(this.pos + 4, this.littleEndian);
+        var value = left + Math.pow(2, 32) * right;
+        this.pos += 8;
+        return value;
+    };
+    _proto.nextStr = function nextStr() {
+        var strByteLength = this.nextUint16();
+        var uint8Array = new Uint8Array(this.data.buffer, this.pos + this.dataView.byteOffset, strByteLength);
+        this.pos += strByteLength;
+        return decodeText(uint8Array);
+    };
+    _proto.skip = function skip(bytes) {
+        this.pos += bytes;
+        return this;
+    };
+    _proto.scan = function scan(maxByteLength, term) {
+        if (term === void 0) term = 0x00;
+        var byteOffset = this.pos;
+        var byteLength = 0;
+        while(this.dataView.getUint8(this.pos) !== term && byteLength < maxByteLength){
+            byteLength++;
+            this.pos++;
+        }
+        if (byteLength < maxByteLength) {
+            this.pos++;
+        }
+        return new Uint8Array(this.dataView.buffer, this.dataView.byteOffset + byteOffset, byteLength);
+    };
+    _create_class(BufferReader, [
+        {
+            key: "position",
+            get: function get() {
+                return this.pos;
+            }
+        },
+        {
+            key: "offset",
+            get: function get() {
+                return this.pos + this.baseOffset;
+            }
+        }
+    ]);
+    return BufferReader;
+}();
+
+var DFDTransferFunction;
+(function(DFDTransferFunction) {
+    DFDTransferFunction[DFDTransferFunction["linear"] = 1] = "linear";
+    DFDTransferFunction[DFDTransferFunction["sRGB"] = 2] = "sRGB";
+})(DFDTransferFunction || (DFDTransferFunction = {}));
+var ColorModel;
+(function(ColorModel) {
+    ColorModel[ColorModel["ETC1S"] = 163] = "ETC1S";
+    ColorModel[ColorModel["UASTC"] = 166] = "UASTC";
+})(ColorModel || (ColorModel = {}));
+var SupercompressionScheme;
+(function(SupercompressionScheme) {
+    SupercompressionScheme[SupercompressionScheme["None"] = 0] = "None";
+    SupercompressionScheme[SupercompressionScheme["BasisLZ"] = 1] = "BasisLZ";
+    SupercompressionScheme[SupercompressionScheme["Zstd"] = 2] = "Zstd";
+    SupercompressionScheme[SupercompressionScheme["ZLib"] = 3] = "ZLib";
+})(SupercompressionScheme || (SupercompressionScheme = {}));
+var KTX2Container = /*#__PURE__*/ function() {
+    function KTX2Container(buffer) {
+        this.vkFormat = 0;
+        this.typeSize = 1;
+        this.pixelWidth = 0;
+        this.pixelHeight = 0;
+        this.pixelDepth = 0;
+        this.layerCount = 0;
+        this.faceCount = 1;
+        this.supercompressionScheme = 0;
+        this.levels = [];
+        this.keyValue = {};
+        this.globalData = null;
+        this.parse(buffer);
+    }
+    var _proto = KTX2Container.prototype;
+    _proto.parse = function parse(data) {
+        var KTX2_IDENTIFIER = new Uint8Array([
+            0xAB,
+            0x4B,
+            0x54,
+            0x58,
+            0x20,
+            0x32,
+            0x30,
+            0xBB,
+            0x0D,
+            0x0A,
+            0x1A,
+            0x0A
+        ]);
+        if (data.length < KTX2_IDENTIFIER.length || !KTX2_IDENTIFIER.every(function(v, i) {
+            return data[i] === v;
+        })) {
+            throw new Error("Texture missing KTX2 identifier.");
+        }
+        var buffer = data.buffer;
+        var byteOffset = data.byteOffset;
+        var headerBufferReader = new BufferReader(data, 12);
+        this.vkFormat = headerBufferReader.nextUint32();
+        this.typeSize = headerBufferReader.nextUint32();
+        this.pixelWidth = headerBufferReader.nextUint32();
+        this.pixelHeight = headerBufferReader.nextUint32();
+        this.pixelDepth = headerBufferReader.nextUint32();
+        this.layerCount = headerBufferReader.nextUint32();
+        this.faceCount = headerBufferReader.nextUint32();
+        var levelCount = Math.max(1, headerBufferReader.nextUint32());
+        this.supercompressionScheme = headerBufferReader.nextUint32();
+        var dfdByteOffset = headerBufferReader.nextUint32();
+        var dfdByteLength = headerBufferReader.nextUint32();
+        var kvdByteOffset = headerBufferReader.nextUint32();
+        var kvdByteLength = headerBufferReader.nextUint32();
+        var sgdByteOffset = headerBufferReader.nextUint64();
+        var sgdByteLength = headerBufferReader.nextUint64();
+        // level index
+        var ktxLevels = new Array(levelCount);
+        var levelByteLength = levelCount * 3 * 8;
+        var levelReader = new BufferReader(data, headerBufferReader.offset, levelByteLength);
+        this.levels = ktxLevels;
+        for(var i = 0; i < levelCount; i++){
+            ktxLevels[i] = {
+                levelData: new Uint8Array(buffer, byteOffset + levelReader.nextUint64(), levelReader.nextUint64()),
+                uncompressedByteLength: levelReader.nextUint64()
+            };
+        }
+        // Data Format Descriptor (DFD).
+        var dfdReader = new BufferReader(data, dfdByteOffset, dfdByteLength);
+        var dfd = {
+            vendorId: dfdReader.skip(4 /* totalSize */ ).nextUint16(),
+            descriptorType: dfdReader.nextUint16(),
+            versionNumber: dfdReader.nextUint16(),
+            descriptorBlockSize: dfdReader.nextUint16(),
+            colorModel: dfdReader.nextUint8(),
+            colorPrimaries: dfdReader.nextUint8(),
+            transferFunction: dfdReader.nextUint8(),
+            flags: dfdReader.nextUint8(),
+            texelBlockDimension: [
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8()
+            ],
+            bytesPlane: [
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8(),
+                dfdReader.nextUint8()
+            ],
+            samples: []
+        };
+        this.dataFormatDescriptor = dfd;
+        var sampleStart = 6;
+        var sampleWords = 4;
+        var numSamples = (dfd.descriptorBlockSize / 4 - sampleStart) / sampleWords;
+        for(var i1 = 0; i1 < numSamples; i1++){
+            var sample = {
+                bitOffset: dfdReader.nextUint16(),
+                bitLength: dfdReader.nextUint8(),
+                channelType: dfdReader.nextUint8(),
+                samplePosition: [
+                    dfdReader.nextUint8(),
+                    dfdReader.nextUint8(),
+                    dfdReader.nextUint8(),
+                    dfdReader.nextUint8()
+                ],
+                sampleLower: -Infinity,
+                sampleUpper: Infinity
+            };
+            if (sample.channelType & 0x40) {
+                sample.sampleLower = dfdReader.nextInt32();
+                sample.sampleUpper = dfdReader.nextInt32();
+            } else {
+                sample.sampleLower = dfdReader.nextUint32();
+                sample.sampleUpper = dfdReader.nextUint32();
+            }
+            dfd.samples[i1] = sample;
+        }
+        var kvdReader = new BufferReader(data, kvdByteOffset, kvdByteLength, true);
+        while(kvdReader.position < kvdByteLength){
+            var keyValueByteLength = kvdReader.nextUint32();
+            var keyData = kvdReader.scan(keyValueByteLength);
+            var key = decodeText(keyData);
+            // 4-byte alignment.
+            var valueData = kvdReader.nextUint8Array(keyValueByteLength - keyData.byteLength - 1);
+            if (/^ktx/i.test(key)) {
+                var decodedValue = decodeText(valueData);
+                var trimmedValue = decodedValue;
+                while(trimmedValue.length > 0 && trimmedValue.charCodeAt(trimmedValue.length - 1) === 0){
+                    trimmedValue = trimmedValue.slice(0, -1);
+                }
+                this.keyValue[key] = trimmedValue;
+            } else {
+                this.keyValue[key] = valueData;
+            }
+            var kvPadding = keyValueByteLength % 4 ? 4 - keyValueByteLength % 4 : 0; // align(4)
+            // 4-byte alignment.
+            kvdReader.skip(kvPadding);
+        }
+        if (sgdByteLength <= 0) {
+            return this;
+        }
+        var sgdReader = new BufferReader(data, sgdByteOffset, sgdByteLength, true);
+        var endpointCount = sgdReader.nextUint16();
+        var selectorCount = sgdReader.nextUint16();
+        var endpointsByteLength = sgdReader.nextUint32();
+        var selectorsByteLength = sgdReader.nextUint32();
+        var tablesByteLength = sgdReader.nextUint32();
+        var extendedByteLength = sgdReader.nextUint32();
+        var imageDescs = new Array(levelCount);
+        for(var i2 = 0; i2 < levelCount; i2++){
+            imageDescs[i2] = {
+                imageFlags: sgdReader.nextUint32(),
+                rgbSliceByteOffset: sgdReader.nextUint32(),
+                rgbSliceByteLength: sgdReader.nextUint32(),
+                alphaSliceByteOffset: sgdReader.nextUint32(),
+                alphaSliceByteLength: sgdReader.nextUint32()
+            };
+        }
+        var endpointsByteOffset = sgdByteOffset + sgdReader.position;
+        var selectorsByteOffset = endpointsByteOffset + endpointsByteLength;
+        var tablesByteOffset = selectorsByteOffset + selectorsByteLength;
+        var extendedByteOffset = tablesByteOffset + tablesByteLength;
+        var endpointsData = new Uint8Array(buffer, byteOffset + endpointsByteOffset, endpointsByteLength);
+        var selectorsData = new Uint8Array(buffer, byteOffset + selectorsByteOffset, selectorsByteLength);
+        var tablesData = new Uint8Array(buffer, byteOffset + tablesByteOffset, tablesByteLength);
+        var extendedData = new Uint8Array(buffer, byteOffset + extendedByteOffset, extendedByteLength);
+        this.globalData = {
+            endpointCount: endpointCount,
+            selectorCount: selectorCount,
+            imageDescs: imageDescs,
+            endpointsData: endpointsData,
+            selectorsData: selectorsData,
+            tablesData: tablesData,
+            extendedData: extendedData
+        };
+    };
+    _create_class(KTX2Container, [
+        {
+            key: "isSRGB",
+            get: function get() {
+                return this.dataFormatDescriptor.transferFunction === 2;
+            }
+        },
+        {
+            key: "isUASTC",
+            get: function get() {
+                return this.dataFormatDescriptor.colorModel === 166;
+            }
+        },
+        {
+            key: "isNotBasis",
+            get: function get() {
+                return this.vkFormat != 0;
+            }
+        }
+    ]);
+    return KTX2Container;
+}();
+
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+
+/* eslint-disable compat/compat */ /* eslint-disable promise/no-nesting */ /**
+ * 转码核心代码
+ * 主线程调用时会返回 API 对象
+ * Worker 中使用时需要拼接消息处理代码
+ */ function TranscodeWorkerCode() {
+    var wasmPromise;
+    /**
+   * ZSTD (Zstandard) decoder.
+   */ var ZSTDDecoder = /*#__PURE__*/ function() {
+        function ZSTDDecoder() {}
+        var _proto = ZSTDDecoder.prototype;
+        _proto.init = function init(zstddecWasmModule) {
+            if (!this.initPromise) {
+                this.initPromise = WebAssembly.instantiate(zstddecWasmModule, ZSTDDecoder.IMPORT_OBJECT).then(this.initInstance);
+            }
+            return this.initPromise;
+        };
+        _proto.initInstance = function initInstance(result) {
+            ZSTDDecoder.instance = result;
+            ZSTDDecoder.IMPORT_OBJECT.env.emscripten_notify_memory_growth();
+        };
+        _proto.decode = function decode(array, uncompressedSize) {
+            if (uncompressedSize === void 0) uncompressedSize = 0;
+            if (!ZSTDDecoder.instance) {
+                throw new Error("ZSTDDecoder: Await .init() before decoding.");
+            }
+            var exports = ZSTDDecoder.instance.exports;
+            var compressedSize = array.byteLength;
+            var compressedPtr = exports.malloc(compressedSize);
+            ZSTDDecoder.heap.set(array, compressedPtr);
+            uncompressedSize = uncompressedSize || Number(exports.ZSTD_findDecompressedSize(compressedPtr, compressedSize));
+            var uncompressedPtr = exports.malloc(uncompressedSize);
+            var actualSize = exports.ZSTD_decompress(uncompressedPtr, uncompressedSize, compressedPtr, compressedSize);
+            if (actualSize < 0) {
+                exports.free(compressedPtr);
+                exports.free(uncompressedPtr);
+                throw new Error("ZSTDDecoder: decompression failed.");
+            }
+            // Read decompressed data and free WASM memory
+            var dec = ZSTDDecoder.heap.slice(uncompressedPtr, uncompressedPtr + actualSize);
+            exports.free(compressedPtr);
+            exports.free(uncompressedPtr);
+            return dec;
+        };
+        return ZSTDDecoder;
+    }();
+    ZSTDDecoder.IMPORT_OBJECT = {
+        env: {
+            emscripten_notify_memory_growth: function emscripten_notify_memory_growth() {
+                ZSTDDecoder.heap = new Uint8Array(ZSTDDecoder.instance.exports.memory.buffer);
+            }
+        }
+    };
+    function transcodeASTC(wasmTranscoder, compressedData, width, height) {
+        var nBlocks = (width + 3 >> 2) * (height + 3 >> 2);
+        var texMemoryPages = nBlocks * 16 + 65535 >> 16;
+        var memory = wasmTranscoder.memory;
+        var delta = texMemoryPages + 1 - (memory.buffer.byteLength >> 16);
+        if (delta > 0) {
+            memory.grow(delta);
+        }
+        var textureView = new Uint8Array(memory.buffer, 65536, nBlocks * 16);
+        textureView.set(compressedData);
+        return wasmTranscoder.transcode(nBlocks) === 0 ? textureView : null;
+    }
+    function initTranscoder(transcoderWasmModule) {
+        wasmPromise = WebAssembly.instantiate(transcoderWasmModule, {
+            env: {
+                memory: new WebAssembly.Memory({
+                    initial: 16
+                })
+            }
+        }).then(function(moduleWrapper) {
+            return moduleWrapper.exports;
+        });
+        return wasmPromise;
+    }
+    var zstdDecoder = new ZSTDDecoder();
+    function transcode(data, needZstd, transcoderWasmModule, zstddecWasmModule) {
+        var faceCount = data.length;
+        var result = new Array(faceCount);
+        var decodedLevelCache = needZstd ? new Map() : undefined;
+        var promise = Promise.resolve();
+        if (needZstd && zstddecWasmModule) {
+            void zstdDecoder.init(zstddecWasmModule);
+            promise = zstdDecoder.initPromise;
+        }
+        return promise.then(function() {
+            for(var faceIndex = 0; faceIndex < faceCount; faceIndex++){
+                var mipmapCount = data[faceIndex].length;
+                var decodedData = new Array(mipmapCount);
+                for(var i = 0; i < mipmapCount; i++){
+                    var _data_faceIndex_i = data[faceIndex][i], buffer = _data_faceIndex_i.buffer, levelHeight = _data_faceIndex_i.levelHeight, levelWidth = _data_faceIndex_i.levelWidth, uncompressedByteLength = _data_faceIndex_i.uncompressedByteLength;
+                    var levelBuffer = buffer;
+                    if (needZstd) {
+                        var decoded = decodedLevelCache == null ? void 0 : decodedLevelCache.get(i);
+                        if (!decoded) {
+                            decoded = zstdDecoder.decode(buffer.slice(), uncompressedByteLength);
+                            decodedLevelCache == null ? void 0 : decodedLevelCache.set(i, decoded);
+                        }
+                        levelBuffer = decoded;
+                    }
+                    var faceByteLength = levelBuffer.byteLength / faceCount;
+                    var originByteOffset = levelBuffer.byteOffset;
+                    var decodedBuffer = transcodeASTC(transcoderWasmModule, new Uint8Array(levelBuffer.buffer, originByteOffset + faceIndex * faceByteLength, faceByteLength), levelWidth, levelHeight);
+                    if (decodedBuffer) {
+                        decodedData[i] = {
+                            // use wasm memory as buffer, should slice to avoid duplicate
+                            data: decodedBuffer.slice(),
+                            width: levelWidth,
+                            height: levelHeight
+                        };
+                    } else {
+                        throw new Error("buffer decoded error");
+                    }
+                }
+                result[faceIndex] = decodedData;
+            }
+            return result;
+        });
+    }
+    self.onmessage = function onmessage(event) {
+        var message = event.data;
+        switch(message.type){
+            case "init":
+                initTranscoder(message.transcoderWasm).then(function() {
+                    self.postMessage("init-completed");
+                }).catch(function(error) {
+                    self.postMessage({
+                        error: error
+                    });
+                });
+                break;
+            case "transcode":
+                wasmPromise.then(function(transcoderWasmModule) {
+                    transcode(message.data, message.needZstd, transcoderWasmModule, message.zstddecWasmModule).then(function(decodedData) {
+                        self.postMessage(decodedData);
+                    }).catch(function(error) {
+                        return self.postMessage({
+                            error: error
+                        });
+                    });
+                }).catch(function(error) {
+                    self.postMessage({
+                        error: error
+                    });
+                });
+                break;
+        }
+    };
+    // 主线程使用
+    return {
+        ZSTDDecoder: ZSTDDecoder,
+        transcodeASTC: transcodeASTC,
+        initTranscoder: initTranscoder,
+        zstdDecoder: zstdDecoder,
+        transcode: transcode,
+        getWasmPromise: function() {
+            return wasmPromise;
+        }
+    };
+}
+
+function _loadWasmModule (sync, filepath, src, imports) {
+  function _instantiateOrCompile(source, imports, stream) {
+    var instantiateFunc = stream ? WebAssembly.instantiateStreaming : WebAssembly.instantiate;
+    var compileFunc = stream ? WebAssembly.compileStreaming : WebAssembly.compile;
+
+    if (imports) {
+      return instantiateFunc(source, imports)
+    } else {
+      return compileFunc(source)
+    }
+  }
+
+  
+var buf = null;
+var isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+if (isNode) {
+  
+buf = Buffer.from(src, 'base64');
+
+} else {
+  
+var raw = globalThis.atob(src);
+var rawLength = raw.length;
+buf = new Uint8Array(new ArrayBuffer(rawLength));
+for(var i = 0; i < rawLength; i++) {
+   buf[i] = raw.charCodeAt(i);
+}
+
+}
+
+
+  if(sync) {
+    var mod = new WebAssembly.Module(buf);
+    return imports ? new WebAssembly.Instance(mod, imports) : mod
+  } else {
+    return _instantiateOrCompile(buf, imports, false)
+  }
+}
+
+function uastcAstcWasm(imports){return _loadWasmModule(0, null, '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', imports)}
+
+function zstddecWasm(imports){return _loadWasmModule(0, null, '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', imports)}
+
+/**
+ * 主线程 ASTC/UASTC 转码器
+ */ var KhronosMainThreadTranscoder = /*#__PURE__*/ function() {
+    function KhronosMainThreadTranscoder() {
+        this.context = null;
+    }
+    var _proto = KhronosMainThreadTranscoder.prototype;
+    _proto.init = function init() {
+        var _this = this;
+        return _async_to_generator(function() {
+            var transcoderWasmModule;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!!_this.context) return [
+                            3,
+                            3
+                        ];
+                        _this.context = TranscodeWorkerCode();
+                        return [
+                            4,
+                            uastcAstcWasm()
+                        ];
+                    case 1:
+                        transcoderWasmModule = _state.sent();
+                        return [
+                            4,
+                            _this.context.initTranscoder(transcoderWasmModule)
+                        ];
+                    case 2:
+                        _state.sent();
+                        _state.label = 3;
+                    case 3:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    };
+    _proto.transcode = function transcode(data, needZstd, zstddecWasmModule) {
+        var _this = this;
+        return _async_to_generator(function() {
+            var _this_context, wasmModule;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            _this.init()
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            (_this_context = _this.context) == null ? void 0 : _this_context.getWasmPromise()
+                        ];
+                    case 2:
+                        wasmModule = _state.sent();
+                        return [
+                            2,
+                            _this.context.transcode(data, needZstd, wasmModule, zstddecWasmModule)
+                        ];
+                }
+            });
+        })();
+    };
+    _proto.destroy = function destroy() {
+        this.context = null;
+    };
+    return KhronosMainThreadTranscoder;
+}();
+/**
+ * KTX2 Khronos ASTC/UASTC 转码器
+ * 支持主线程和 Worker 两种执行模式
+ */ var KhronosTranscoder = /*#__PURE__*/ function(TextureTranscoder) {
+    _inherits(KhronosTranscoder, TextureTranscoder);
+    function KhronosTranscoder(workerLimitCount, type) {
+        var _this;
+        _this = TextureTranscoder.call(this, workerLimitCount) || this;
+        _this.type = type;
+        _this.mainThreadTranscoder = null;
+        return _this;
+    }
+    var _proto = KhronosTranscoder.prototype;
+    _proto.initTranscodeWorkerPool = function initTranscodeWorkerPool() {
+        var _this = this;
+        return _async_to_generator(function() {
+            var transcoderWasm, funcCode, funcBody, returnIndex, workerCode, workerURL;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!(_this.workerLimitCount <= 0)) return [
+                            3,
+                            2
+                        ];
+                        _this.mainThreadTranscoder = new KhronosMainThreadTranscoder();
+                        return [
+                            4,
+                            _this.mainThreadTranscoder.init()
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2,
+                            []
+                        ];
+                    case 2:
+                        return [
+                            4,
+                            uastcAstcWasm()
+                        ];
+                    case 3:
+                        transcoderWasm = _state.sent();
+                        funcCode = TranscodeWorkerCode.toString();
+                        funcBody = funcCode.substring(funcCode.indexOf("{") + 1, funcCode.lastIndexOf("}"));
+                        // 移除主线程的 return 语句，添加 Worker 消息处理
+                        returnIndex = funcBody.lastIndexOf("return {");
+                        workerCode = funcBody.substring(0, returnIndex);
+                        workerURL = URL.createObjectURL(new Blob([
+                            workerCode
+                        ], {
+                            type: "application/javascript"
+                        }));
+                        _this.workerURL = workerURL;
+                        return [
+                            2,
+                            _this.createTranscodePool(workerURL, transcoderWasm)
+                        ];
+                }
+            });
+        })();
+    };
+    _proto.transcode = function transcode(ktx2Container) {
+        var _this = this;
+        return _async_to_generator(function() {
+            var needZstd, levelCount, faceCount, encodedData, faceIndex, mipmapData, mipmapIndex, level, levelWidth, levelHeight, originBuffer, originOffset, originByteLength, zstddecWasmModule, _tmp, faces, postMessageData;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        needZstd = ktx2Container.supercompressionScheme === SupercompressionScheme.Zstd;
+                        levelCount = ktx2Container.levels.length;
+                        faceCount = ktx2Container.faceCount;
+                        // 准备编码数据
+                        encodedData = new Array(faceCount);
+                        for(faceIndex = 0; faceIndex < faceCount; faceIndex++){
+                            mipmapData = new Array(levelCount);
+                            for(mipmapIndex = 0; mipmapIndex < levelCount; mipmapIndex++){
+                                level = ktx2Container.levels[mipmapIndex];
+                                levelWidth = Math.floor(ktx2Container.pixelWidth / (1 << mipmapIndex)) || 1;
+                                levelHeight = Math.floor(ktx2Container.pixelHeight / (1 << mipmapIndex)) || 1;
+                                originBuffer = level.levelData.buffer;
+                                originOffset = level.levelData.byteOffset;
+                                originByteLength = level.levelData.byteLength;
+                                mipmapData[mipmapIndex] = {
+                                    buffer: new Uint8Array(originBuffer, originOffset, originByteLength),
+                                    levelWidth: levelWidth,
+                                    levelHeight: levelHeight,
+                                    uncompressedByteLength: level.uncompressedByteLength
+                                };
+                            }
+                            encodedData[faceIndex] = mipmapData;
+                        }
+                        if (!needZstd) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            zstddecWasm()
+                        ];
+                    case 1:
+                        _tmp = _state.sent();
+                        return [
+                            3,
+                            3
+                        ];
+                    case 2:
+                        _tmp = undefined;
+                        _state.label = 3;
+                    case 3:
+                        zstddecWasmModule = _tmp;
+                        if (!(_this.workerLimitCount <= 0 && _this.mainThreadTranscoder)) return [
+                            3,
+                            5
+                        ];
+                        return [
+                            4,
+                            _this.mainThreadTranscoder.transcode(encodedData, needZstd, zstddecWasmModule)
+                        ];
+                    case 4:
+                        faces = _state.sent();
+                        return [
+                            3,
+                            7
+                        ];
+                    case 5:
+                        // WebWorker 模式
+                        postMessageData = {
+                            type: "transcode",
+                            format: 0,
+                            needZstd: needZstd,
+                            data: encodedData,
+                            zstddecWasmModule: zstddecWasmModule
+                        };
+                        return [
+                            4,
+                            _this.transcodeWorkerPool.postMessage(postMessageData)
+                        ];
+                    case 6:
+                        faces = _state.sent();
+                        _state.label = 7;
+                    case 7:
+                        return [
+                            2,
+                            {
+                                width: ktx2Container.pixelWidth,
+                                height: ktx2Container.pixelHeight,
+                                hasAlpha: true,
+                                format: 0,
+                                faces: faces,
+                                faceCount: faceCount
+                            }
+                        ];
+                }
+            });
+        })();
+    };
+    _proto.destroy = function destroy() {
+        TextureTranscoder.prototype.destroy.call(this);
+        if (this.mainThreadTranscoder) {
+            this.mainThreadTranscoder.destroy();
+            this.mainThreadTranscoder = null;
+        }
+        if (this.workerURL) {
+            URL.revokeObjectURL(this.workerURL);
+            this.workerURL = undefined;
+        }
+    };
+    return KhronosTranscoder;
+}(TextureTranscoder);
+
+/**
+ * KTX2 加载器 - 专用于 UASTC 转 ASTC
+ */ var KTX2Loader = /*#__PURE__*/ function() {
+    function KTX2Loader(workerCount) {
+        if (workerCount === void 0) workerCount = 0;
+        this.workerCount = workerCount;
+        this.khronosTranscoder = null;
+    }
+    var _proto = KTX2Loader.prototype;
+    /**
+   * 初始化 Khronos Transcoder
+   */ _proto.initKhronosTranscoder = function initKhronosTranscoder() {
+        var _this = this;
+        return _async_to_generator(function() {
+            var transcoder, error;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (_this.khronosTranscoder) {
+                            return [
+                                2
+                            ];
+                        }
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        transcoder = new KhronosTranscoder(_this.workerCount, KTX2TargetFormat.ASTC);
+                        return [
+                            4,
+                            transcoder.init()
+                        ];
+                    case 2:
+                        _state.sent();
+                        _this.khronosTranscoder = transcoder;
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        error = _state.sent();
+                        console.error("Failed to initialize KhronosTranscoder:", error);
+                        _this.khronosTranscoder = null;
+                        _this.khronosInitPromise = undefined;
+                        throw error;
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    };
+    /**
+   * 确保 Khronos Transcoder 已初始化
+   */ _proto.ensureKhronosTranscoder = function ensureKhronosTranscoder() {
+        var _this = this;
+        return _async_to_generator(function() {
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (_this.khronosTranscoder) {
+                            return [
+                                2,
+                                _this.khronosTranscoder
+                            ];
+                        }
+                        if (!_this.khronosInitPromise) {
+                            _this.khronosInitPromise = _this.initKhronosTranscoder();
+                        }
+                        return [
+                            4,
+                            _this.khronosInitPromise
+                        ];
+                    case 1:
+                        _state.sent();
+                        if (!_this.khronosTranscoder) {
+                            throw new Error("KhronosTranscoder initialization failed");
+                        }
+                        return [
+                            2,
+                            _this.khronosTranscoder
+                        ];
+                }
+            });
+        })();
+    };
+    /**
+   * 从 ArrayBuffer 加载 KTX2 纹理并返回压缩纹理源选项
+   */ _proto.loadFromBuffer = function loadFromBuffer(arrBuffer) {
+        var _this = this;
+        return _async_to_generator(function() {
+            var buffer, _ref, ktx2Container, result;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        buffer = new Uint8Array(arrBuffer);
+                        return [
+                            4,
+                            _this.parseBuffer(buffer)
+                        ];
+                    case 1:
+                        _ref = _state.sent(), ktx2Container = _ref.ktx2Container, result = _ref.result;
+                        return [
+                            2,
+                            _this.createTextureByBuffer(ktx2Container, result)
+                        ];
+                }
+            });
+        })();
+    };
+    /**
+   * 从 URL 加载 KTX2 纹理并返回压缩纹理源选项
+   */ _proto.loadFromURL = function loadFromURL(url) {
+        var _this = this;
+        return _async_to_generator(function() {
+            var buffer, _, _ref, ktx2Container, result;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _ = Uint8Array.bind;
+                        return [
+                            4,
+                            loadBinary(url)
+                        ];
+                    case 1:
+                        buffer = new (_.apply(Uint8Array, [
+                            void 0,
+                            _state.sent()
+                        ]));
+                        return [
+                            4,
+                            _this.parseBuffer(buffer)
+                        ];
+                    case 2:
+                        _ref = _state.sent(), ktx2Container = _ref.ktx2Container, result = _ref.result;
+                        return [
+                            2,
+                            _this.createTextureByBuffer(ktx2Container, result)
+                        ];
+                }
+            });
+        })();
+    };
+    /**
+   * @internal
+   * 解析并转码 KTX2 文件
+   */ _proto.parseBuffer = function parseBuffer(buffer) {
+        var _this = this;
+        return _async_to_generator(function() {
+            var ktx2Container, transcoder, result;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        ktx2Container = new KTX2Container(buffer);
+                        // 验证格式支持
+                        if (!ktx2Container.isUASTC) {
+                            throw new Error("Unsupported KTX2: only UASTC format is supported");
+                        }
+                        return [
+                            4,
+                            _this.ensureKhronosTranscoder()
+                        ];
+                    case 1:
+                        transcoder = _state.sent();
+                        return [
+                            4,
+                            transcoder.transcode(ktx2Container)
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        return [
+                            2,
+                            {
+                                ktx2Container: ktx2Container,
+                                result: result
+                            }
+                        ];
+                }
+            });
+        })();
+    };
+    /**
+   * @internal
+   * 根据转码结果创建引擎所需的压缩纹理源选项
+   */ _proto.createTextureByBuffer = function createTextureByBuffer(ktx2Container, transcodeResult) {
+        var _faces_;
+        var pixelWidth = ktx2Container.pixelWidth, pixelHeight = ktx2Container.pixelHeight, faceCount = ktx2Container.faceCount;
+        var _this_getASTC4x4TextureDetail = this.getASTC4x4TextureDetail(), internalFormat = _this_getASTC4x4TextureDetail.internalFormat, format = _this_getASTC4x4TextureDetail.format, type = _this_getASTC4x4TextureDetail.type;
+        var target = faceCount === 6 ? glContext.TEXTURE_CUBE_MAP : glContext.TEXTURE_2D;
+        var faces = transcodeResult.faces;
+        var _faces__length;
+        var transLevels = (_faces__length = (_faces_ = faces[0]) == null ? void 0 : _faces_.length) != null ? _faces__length : 0;
+        var maxDimension = Math.max(pixelWidth, pixelHeight);
+        if (maxDimension === 0) {
+            throw new Error("Invalid KTX2 texture: both width and height are zero");
+        }
+        var fullChainCount = Math.floor(Math.log2(maxDimension)) + 1;
+        var useMipmaps = transLevels > 1 && transLevels >= fullChainCount;
+        var levelCount = useMipmaps ? transLevels : 1;
+        var mipmaps = [];
+        for(var level = 0; level < levelCount; level++){
+            for(var face = 0; face < faceCount; face++){
+                var src = faces[face][level];
+                mipmaps.push({
+                    data: src.data,
+                    width: src.width,
+                    height: src.height
+                });
+            }
+        }
+        return {
+            sourceType: TextureSourceType.compressed,
+            target: target,
+            internalFormat: internalFormat,
+            format: format,
+            type: type,
+            mipmaps: mipmaps
+        };
+    };
+    /**
+   * @internal
+   * 获取 ASTC 4x4 的 WebGL 格式信息
+   */ _proto.getASTC4x4TextureDetail = function getASTC4x4TextureDetail() {
+        var COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93b0;
+        return {
+            internalFormat: COMPRESSED_RGBA_ASTC_4x4_KHR,
+            format: 0,
+            type: 0
+        };
+    };
+    /**
+   * 销毁加载器，释放资源
+   */ _proto.dispose = function dispose() {
+        var _this_khronosTranscoder;
+        (_this_khronosTranscoder = this.khronosTranscoder) == null ? void 0 : _this_khronosTranscoder.destroy();
+        this.khronosTranscoder = null;
+        this.khronosInitPromise = undefined;
+    };
+    return KTX2Loader;
+}();
+/**
+ * 注册 KTX2 加载器到全局注册表
+ * @param workerCount - 大于 0 时使用 WebWorker，默认使用主线程
+ */ function registerKTX2Loader(workerCount) {
+    if (workerCount === void 0) workerCount = 0;
+    textureLoaderRegistry.register("ktx2", function() {
+        return new KTX2Loader(workerCount);
+    });
+}
+/**
+ * 注销 KTX2 加载器
+ */ function unregisterKTX2Loader() {
+    textureLoaderRegistry.unregister("ktx2");
+}
+
+/**
+ * 插件版本号
+ */ var version = "2.8.0-alpha.0";
+registerKTX2Loader();
+if (version !== EFFECTS.version) {
+    console.error("注意：请统一 KTX2 插件与 Player 版本，不统一的版本混用会有不可预知的后果！", "\nAttention: Please ensure the KTX2 plugin is synchronized with the Player version. Mixing and matching incompatible versions may result in unpredictable consequences!");
+}
+
+export { KTX2Loader, registerKTX2Loader, unregisterKTX2Loader, version };
+//# sourceMappingURL=index.mjs.map