"use strict"; var __defProp = Object.defineProperty; var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; var __publicField = (obj, key, value) => { __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); return value; }; Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); const THREE = require("three"); const _taskCache = /* @__PURE__ */ new WeakMap(); const BasisTextureLoader = /* @__PURE__ */ (() => { const _BasisTextureLoader = class extends THREE.Loader { constructor(manager) { super(manager); this.transcoderPath = ""; this.transcoderBinary = null; this.transcoderPending = null; this.workerLimit = 4; this.workerPool = []; this.workerNextTaskID = 1; this.workerSourceURL = ""; this.workerConfig = null; } setTranscoderPath(path) { this.transcoderPath = path; return this; } setWorkerLimit(workerLimit) { this.workerLimit = workerLimit; return this; } detectSupport(renderer) { this.workerConfig = { astcSupported: renderer.extensions.has("WEBGL_compressed_texture_astc"), etc1Supported: renderer.extensions.has("WEBGL_compressed_texture_etc1"), etc2Supported: renderer.extensions.has("WEBGL_compressed_texture_etc"), dxtSupported: renderer.extensions.has("WEBGL_compressed_texture_s3tc"), bptcSupported: renderer.extensions.has("EXT_texture_compression_bptc"), pvrtcSupported: renderer.extensions.has("WEBGL_compressed_texture_pvrtc") || renderer.extensions.has("WEBKIT_WEBGL_compressed_texture_pvrtc") }; return this; } load(url, onLoad, onProgress, onError) { const loader = new THREE.FileLoader(this.manager); loader.setResponseType("arraybuffer"); loader.setWithCredentials(this.withCredentials); const texture = new THREE.CompressedTexture(); loader.load( url, (buffer) => { if (_taskCache.has(buffer)) { const cachedTask = _taskCache.get(buffer); return cachedTask.promise.then(onLoad).catch(onError); } this._createTexture([buffer]).then(function(_texture) { texture.copy(_texture); texture.needsUpdate = true; if (onLoad) onLoad(texture); }).catch(onError); }, onProgress, onError ); return texture; } /** Low-level transcoding API, exposed for use by KTX2Loader. */ parseInternalAsync(options) { const { levels } = options; const buffers = /* @__PURE__ */ new Set(); for (let i = 0; i < levels.length; i++) { buffers.add(levels[i].data.buffer); } return this._createTexture(Array.from(buffers), { ...options, lowLevel: true }); } /** * @param {ArrayBuffer[]} buffers * @param {object?} config * @return {Promise} */ _createTexture(buffers, config = {}) { let worker; let taskID; const taskConfig = config; let taskCost = 0; for (let i = 0; i < buffers.length; i++) { taskCost += buffers[i].byteLength; } const texturePending = this._allocateWorker(taskCost).then((_worker) => { worker = _worker; taskID = this.workerNextTaskID++; return new Promise((resolve, reject) => { worker._callbacks[taskID] = { resolve, reject }; worker.postMessage({ type: "transcode", id: taskID, buffers, taskConfig }, buffers); }); }).then((message) => { const { mipmaps, width, height, format } = message; const texture = new THREE.CompressedTexture(mipmaps, width, height, format, THREE.UnsignedByteType); texture.minFilter = mipmaps.length === 1 ? THREE.LinearFilter : THREE.LinearMipmapLinearFilter; texture.magFilter = THREE.LinearFilter; texture.generateMipmaps = false; texture.needsUpdate = true; return texture; }); texturePending.catch(() => true).then(() => { if (worker && taskID) { worker._taskLoad -= taskCost; delete worker._callbacks[taskID]; } }); _taskCache.set(buffers[0], { promise: texturePending }); return texturePending; } _initTranscoder() { if (!this.transcoderPending) { const jsLoader = new THREE.FileLoader(this.manager); jsLoader.setPath(this.transcoderPath); jsLoader.setWithCredentials(this.withCredentials); const jsContent = new Promise((resolve, reject) => { jsLoader.load("basis_transcoder.js", resolve, void 0, reject); }); const binaryLoader = new THREE.FileLoader(this.manager); binaryLoader.setPath(this.transcoderPath); binaryLoader.setResponseType("arraybuffer"); binaryLoader.setWithCredentials(this.withCredentials); const binaryContent = new Promise((resolve, reject) => { binaryLoader.load("basis_transcoder.wasm", resolve, void 0, reject); }); this.transcoderPending = Promise.all([jsContent, binaryContent]).then(([jsContent2, binaryContent2]) => { const fn = _BasisTextureLoader.BasisWorker.toString(); const body = [ "/* constants */", "let _EngineFormat = " + JSON.stringify(_BasisTextureLoader.EngineFormat), "let _TranscoderFormat = " + JSON.stringify(_BasisTextureLoader.TranscoderFormat), "let _BasisFormat = " + JSON.stringify(_BasisTextureLoader.BasisFormat), "/* basis_transcoder.js */", jsContent2, "/* worker */", fn.substring(fn.indexOf("{") + 1, fn.lastIndexOf("}")) ].join("\n"); this.workerSourceURL = URL.createObjectURL(new Blob([body])); this.transcoderBinary = binaryContent2; }); } return this.transcoderPending; } _allocateWorker(taskCost) { return this._initTranscoder().then(() => { if (this.workerPool.length < this.workerLimit) { const worker2 = new Worker(this.workerSourceURL); worker2._callbacks = {}; worker2._taskLoad = 0; worker2.postMessage({ type: "init", config: this.workerConfig, transcoderBinary: this.transcoderBinary }); worker2.onmessage = function(e) { const message = e.data; switch (message.type) { case "transcode": worker2._callbacks[message.id].resolve(message); break; case "error": worker2._callbacks[message.id].reject(message); break; default: console.error('THREE.BasisTextureLoader: Unexpected message, "' + message.type + '"'); } }; this.workerPool.push(worker2); } else { this.workerPool.sort(function(a, b) { return a._taskLoad > b._taskLoad ? -1 : 1; }); } const worker = this.workerPool[this.workerPool.length - 1]; worker._taskLoad += taskCost; return worker; }); } dispose() { for (let i = 0; i < this.workerPool.length; i++) { this.workerPool[i].terminate(); } this.workerPool.length = 0; return this; } }; let BasisTextureLoader2 = _BasisTextureLoader; /* CONSTANTS */ __publicField(BasisTextureLoader2, "BasisFormat", { ETC1S: 0, UASTC_4x4: 1 }); __publicField(BasisTextureLoader2, "TranscoderFormat", { ETC1: 0, ETC2: 1, BC1: 2, BC3: 3, BC4: 4, BC5: 5, BC7_M6_OPAQUE_ONLY: 6, BC7_M5: 7, PVRTC1_4_RGB: 8, PVRTC1_4_RGBA: 9, ASTC_4x4: 10, ATC_RGB: 11, ATC_RGBA_INTERPOLATED_ALPHA: 12, RGBA32: 13, RGB565: 14, BGR565: 15, RGBA4444: 16 }); __publicField(BasisTextureLoader2, "EngineFormat", { RGBAFormat: THREE.RGBAFormat, RGBA_ASTC_4x4_Format: THREE.RGBA_ASTC_4x4_Format, RGBA_BPTC_Format: THREE.RGBA_BPTC_Format, RGBA_ETC2_EAC_Format: THREE.RGBA_ETC2_EAC_Format, RGBA_PVRTC_4BPPV1_Format: THREE.RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT5_Format: THREE.RGBA_S3TC_DXT5_Format, RGB_ETC1_Format: THREE.RGB_ETC1_Format, RGB_ETC2_Format: THREE.RGB_ETC2_Format, RGB_PVRTC_4BPPV1_Format: THREE.RGB_PVRTC_4BPPV1_Format, RGB_S3TC_DXT1_Format: THREE.RGB_S3TC_DXT1_Format }); /* WEB WORKER */ __publicField(BasisTextureLoader2, "BasisWorker", function() { let config; let transcoderPending; let BasisModule; const EngineFormat = _EngineFormat; const TranscoderFormat = _TranscoderFormat; const BasisFormat = _BasisFormat; onmessage = function(e) { const message = e.data; switch (message.type) { case "init": config = message.config; init(message.transcoderBinary); break; case "transcode": transcoderPending.then(() => { try { const { width, height, hasAlpha, mipmaps, format } = message.taskConfig.lowLevel ? transcodeLowLevel(message.taskConfig) : transcode(message.buffers[0]); const buffers = []; for (let i = 0; i < mipmaps.length; ++i) { buffers.push(mipmaps[i].data.buffer); } self.postMessage( { type: "transcode", id: message.id, width, height, hasAlpha, mipmaps, format }, buffers ); } catch (error) { console.error(error); self.postMessage({ type: "error", id: message.id, error: error.message }); } }); break; } }; function init(wasmBinary) { transcoderPending = new Promise((resolve) => { BasisModule = { wasmBinary, onRuntimeInitialized: resolve }; BASIS(BasisModule); }).then(() => { BasisModule.initializeBasis(); }); } function transcodeLowLevel(taskConfig) { const { basisFormat, width, height, hasAlpha } = taskConfig; const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha); const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat); assert(BasisModule.isFormatSupported(transcoderFormat), "THREE.BasisTextureLoader: Unsupported format."); const mipmaps = []; if (basisFormat === BasisFormat.ETC1S) { const transcoder = new BasisModule.LowLevelETC1SImageTranscoder(); const { endpointCount, endpointsData, selectorCount, selectorsData, tablesData } = taskConfig.globalData; try { let ok; ok = transcoder.decodePalettes(endpointCount, endpointsData, selectorCount, selectorsData); assert(ok, "THREE.BasisTextureLoader: decodePalettes() failed."); ok = transcoder.decodeTables(tablesData); assert(ok, "THREE.BasisTextureLoader: decodeTables() failed."); for (let i = 0; i < taskConfig.levels.length; i++) { const level = taskConfig.levels[i]; const imageDesc = taskConfig.globalData.imageDescs[i]; const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height); const dst = new Uint8Array(dstByteLength); ok = transcoder.transcodeImage( transcoderFormat, dst, dstByteLength / blockByteLength, level.data, getWidthInBlocks(transcoderFormat, level.width), getHeightInBlocks(transcoderFormat, level.height), level.width, level.height, level.index, imageDesc.rgbSliceByteOffset, imageDesc.rgbSliceByteLength, imageDesc.alphaSliceByteOffset, imageDesc.alphaSliceByteLength, imageDesc.imageFlags, hasAlpha, false, 0, 0 ); assert(ok, "THREE.BasisTextureLoader: transcodeImage() failed for level " + level.index + "."); mipmaps.push({ data: dst, width: level.width, height: level.height }); } } finally { transcoder.delete(); } } else { for (let i = 0; i < taskConfig.levels.length; i++) { const level = taskConfig.levels[i]; const dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height); const dst = new Uint8Array(dstByteLength); const ok = BasisModule.transcodeUASTCImage( transcoderFormat, dst, dstByteLength / blockByteLength, level.data, getWidthInBlocks(transcoderFormat, level.width), getHeightInBlocks(transcoderFormat, level.height), level.width, level.height, level.index, 0, level.data.byteLength, 0, hasAlpha, false, 0, 0, -1, -1 ); assert(ok, "THREE.BasisTextureLoader: transcodeUASTCImage() failed for level " + level.index + "."); mipmaps.push({ data: dst, width: level.width, height: level.height }); } } return { width, height, hasAlpha, mipmaps, format: engineFormat }; } function transcode(buffer) { const basisFile = new BasisModule.BasisFile(new Uint8Array(buffer)); const basisFormat = basisFile.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S; const width = basisFile.getImageWidth(0, 0); const height = basisFile.getImageHeight(0, 0); const levels = basisFile.getNumLevels(0); const hasAlpha = basisFile.getHasAlpha(); function cleanup() { basisFile.close(); basisFile.delete(); } const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha); if (!width || !height || !levels) { cleanup(); throw new Error("THREE.BasisTextureLoader: Invalid texture"); } if (!basisFile.startTranscoding()) { cleanup(); throw new Error("THREE.BasisTextureLoader: .startTranscoding failed"); } const mipmaps = []; for (let mip = 0; mip < levels; mip++) { const mipWidth = basisFile.getImageWidth(0, mip); const mipHeight = basisFile.getImageHeight(0, mip); const dst = new Uint8Array(basisFile.getImageTranscodedSizeInBytes(0, mip, transcoderFormat)); const status = basisFile.transcodeImage(dst, 0, mip, transcoderFormat, 0, hasAlpha); if (!status) { cleanup(); throw new Error("THREE.BasisTextureLoader: .transcodeImage failed."); } mipmaps.push({ data: dst, width: mipWidth, height: mipHeight }); } cleanup(); return { width, height, hasAlpha, mipmaps, format: engineFormat }; } const FORMAT_OPTIONS = [ { if: "astcSupported", basisFormat: [BasisFormat.UASTC_4x4], transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4], engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format], priorityETC1S: Infinity, priorityUASTC: 1, needsPowerOfTwo: false }, { if: "bptcSupported", basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4], transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5], engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format], priorityETC1S: 3, priorityUASTC: 2, needsPowerOfTwo: false }, { if: "dxtSupported", basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4], transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3], engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format], priorityETC1S: 4, priorityUASTC: 5, needsPowerOfTwo: false }, { if: "etc2Supported", basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4], transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2], engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format], priorityETC1S: 1, priorityUASTC: 3, needsPowerOfTwo: false }, { if: "etc1Supported", basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4], transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC1], engineFormat: [EngineFormat.RGB_ETC1_Format, EngineFormat.RGB_ETC1_Format], priorityETC1S: 2, priorityUASTC: 4, needsPowerOfTwo: false }, { if: "pvrtcSupported", basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4], transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA], engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format], priorityETC1S: 5, priorityUASTC: 6, needsPowerOfTwo: true } ]; const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function(a, b) { return a.priorityETC1S - b.priorityETC1S; }); const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function(a, b) { return a.priorityUASTC - b.priorityUASTC; }); function getTranscoderFormat(basisFormat, width, height, hasAlpha) { let transcoderFormat; let engineFormat; const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS; for (let i = 0; i < options.length; i++) { const opt = options[i]; if (!config[opt.if]) continue; if (!opt.basisFormat.includes(basisFormat)) continue; if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue; transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0]; engineFormat = opt.engineFormat[hasAlpha ? 1 : 0]; return { transcoderFormat, engineFormat }; } console.warn("THREE.BasisTextureLoader: No suitable compressed texture format found. Decoding to RGBA32."); transcoderFormat = TranscoderFormat.RGBA32; engineFormat = EngineFormat.RGBAFormat; return { transcoderFormat, engineFormat }; } function assert(ok, message) { if (!ok) throw new Error(message); } function getWidthInBlocks(transcoderFormat, width) { return Math.ceil(width / BasisModule.getFormatBlockWidth(transcoderFormat)); } function getHeightInBlocks(transcoderFormat, height) { return Math.ceil(height / BasisModule.getFormatBlockHeight(transcoderFormat)); } function getTranscodedImageByteLength(transcoderFormat, width, height) { const blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat); if (BasisModule.formatIsUncompressed(transcoderFormat)) { return width * height * blockByteLength; } if (transcoderFormat === TranscoderFormat.PVRTC1_4_RGB || transcoderFormat === TranscoderFormat.PVRTC1_4_RGBA) { const paddedWidth = width + 3 & ~3; const paddedHeight = height + 3 & ~3; return (Math.max(8, paddedWidth) * Math.max(8, paddedHeight) * 4 + 7) / 8; } return getWidthInBlocks(transcoderFormat, width) * getHeightInBlocks(transcoderFormat, height) * blockByteLength; } function isPowerOfTwo(value) { if (value <= 2) return true; return (value & value - 1) === 0 && value !== 0; } }); return BasisTextureLoader2; })(); exports.BasisTextureLoader = BasisTextureLoader; //# sourceMappingURL=BasisTextureLoader.cjs.map