@xeokit/xeokit-sdk 2.3.0-beta-11 → 2.3.0-beta-16

package/dist/xeokit-sdk.cjs.js

@@ -15299,7 +15299,7 @@ class RenderBufferManager {
 /**
  * @private
  */
-function getExtension$1 (gl, name) {
+function getExtension (gl, name) {
     if (gl._cachedExtensions === undefined) {
         gl._cachedExtensions = {};
     }
@@ -15365,12 +15365,12 @@ const Renderer = function (scene, options) {
     this._occlusionTester = null; // Lazy-created in #addMarker()
 
     this.capabilities = {
-        astcSupported: !!getExtension$1(gl, 'WEBGL_compressed_texture_astc'),
+        astcSupported: !!getExtension(gl, 'WEBGL_compressed_texture_astc'),
         etc1Supported: true, // WebGL2
-        etc2Supported: !!getExtension$1(gl, 'WEBGL_compressed_texture_etc'),
-        dxtSupported: !!getExtension$1(gl, 'WEBGL_compressed_texture_s3tc'),
-        bptcSupported: !!getExtension$1(gl, 'EXT_texture_compression_bptc'),
-        pvrtcSupported: !!(getExtension$1(gl, 'WEBGL_compressed_texture_pvrtc') || getExtension$1(gl, 'WEBKIT_WEBGL_compressed_texture_pvrtc'))
+        etc2Supported: !!getExtension(gl, 'WEBGL_compressed_texture_etc'),
+        dxtSupported: !!getExtension(gl, 'WEBGL_compressed_texture_s3tc'),
+        bptcSupported: !!getExtension(gl, 'EXT_texture_compression_bptc'),
+        pvrtcSupported: !!(getExtension(gl, 'WEBGL_compressed_texture_pvrtc') || getExtension(gl, 'WEBKIT_WEBGL_compressed_texture_pvrtc'))
     };
 
     this.setTransparentEnabled = function (enabled) {
@@ -15999,22 +15999,6 @@ const Renderer = function (scene, options) {
                     gl.depthMask(false);
                 }
 
-                // Transparent X-ray edges
-
-                if (xrayEdgesTransparentBinLen > 0) {
-                    for (i = 0; i < xrayEdgesTransparentBinLen; i++) {
-                        xrayEdgesTransparentBin[i].drawEdgesXRayed(frameCtx);
-                    }
-                }
-
-                // Transparent X-ray fill
-
-                if (xrayedFillTransparentBinLen > 0) {
-                    for (i = 0; i < xrayedFillTransparentBinLen; i++) {
-                        xrayedFillTransparentBin[i].drawSilhouetteXRayed(frameCtx);
-                    }
-                }
-
                 // Transparent color edges
 
                 if (normalFillTransparentBinLen > 0 || normalEdgesTransparentBinLen > 0) {
@@ -16035,6 +16019,23 @@ const Renderer = function (scene, options) {
                         drawable.drawColorTransparent(frameCtx);
                     }
                 }
+
+                // Transparent X-ray edges
+
+                if (xrayEdgesTransparentBinLen > 0) {
+                    for (i = 0; i < xrayEdgesTransparentBinLen; i++) {
+                        xrayEdgesTransparentBin[i].drawEdgesXRayed(frameCtx);
+                    }
+                }
+
+                // Transparent X-ray fill
+
+                if (xrayedFillTransparentBinLen > 0) {
+                    for (i = 0; i < xrayedFillTransparentBinLen; i++) {
+                        xrayedFillTransparentBin[i].drawSilhouetteXRayed(frameCtx);
+                    }
+                }
+
                 gl.disable(gl.BLEND);
                 if (!alphaDepthMask) {
                     gl.depthMask(true);
@@ -27801,6 +27802,7 @@ const ClampToEdgeWrapping = 1001;
 const MirroredRepeatWrapping = 1002;
 const NearestFilter = 1003;
 const NearestMipMapNearestFilter = 1004;
+const NearestMipmapNearestFilter = 1004;
 const NearestMipmapLinearFilter = 1005;
 const NearestMipMapLinearFilter = 1005;
 const LinearFilter = 1006;
@@ -46505,29 +46507,29 @@ function transformAndOctEncodeNormals(worldNormalMatrix, normals, lenNormals, co
 function octEncodeNormals(normals) { // http://jcgt.org/published/0003/02/01/
     const lenNormals = normals.length;
     const compressedNormals = new Int8Array(lenNormals);
-    let oct, best, currentCos, bestCos;
+    let oct, dec, best, currentCos, bestCos;
     for (let i = 0; i < lenNormals; i += 3) {
         // Test various combinations of ceil and floor to minimize rounding errors
         best = oct = octEncodeNormal(normals, i, "floor", "floor");
-        octDecodeVec2(oct);
-        currentCos = bestCos = dot(normals, i);
+        dec = octDecodeVec2(oct);
+        currentCos = bestCos = dot(normals, i, dec);
         oct = octEncodeNormal(normals, i, "ceil", "floor");
-        octDecodeVec2(oct);
-        currentCos = dot(normals, i);
+        dec = octDecodeVec2(oct);
+        currentCos = dot(normals, i, dec);
         if (currentCos > bestCos) {
             best = oct;
             bestCos = currentCos;
         }
         oct = octEncodeNormal(normals, i, "floor", "ceil");
-        octDecodeVec2(oct);
-        currentCos = dot(normals, i);
+        dec = octDecodeVec2(oct);
+        currentCos = dot(normals, i, dec);
         if (currentCos > bestCos) {
             best = oct;
             bestCos = currentCos;
         }
         oct = octEncodeNormal(normals, i, "ceil", "ceil");
-        octDecodeVec2(oct);
-        currentCos = dot(normals, i);
+        dec = octDecodeVec2(oct);
+        currentCos = dot(normals, i, dec);
         if (currentCos > bestCos) {
             best = oct;
             bestCos = currentCos;
@@ -46601,8 +46603,8 @@ function octDecodeVec2(oct) { // Decode an oct-encoded normal
 /**
  * @private
  */
-function dot(p, vec3) { // Dot product of a normal in an array against a candidate decoding
-    return p[0] * vec3[0] + p[1] * vec3[1] + p[2] * vec3[2];
+function dot(array, i, vec3) {
+    return array[i] * vec3[0] + array[i + 1] * vec3[1] + array[i + 2] * vec3[2];
 }
 
 const tempMat4$2 = math.mat4();
@@ -64417,7 +64419,7 @@ function convertConstant(gl, constantVal, encoding = null) {
 
     if (p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format || p === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format) {
         if (encoding === sRGBEncoding) {
-            const extension = getExtension$1(gl, 'WEBGL_compressed_texture_s3tc_srgb');
+            const extension = getExtension(gl, 'WEBGL_compressed_texture_s3tc_srgb');
             if (extension !== null) {
                 if (p === RGB_S3TC_DXT1_Format) return extension.COMPRESSED_SRGB_S3TC_DXT1_EXT;
                 if (p === RGBA_S3TC_DXT1_Format) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
@@ -64427,7 +64429,7 @@ function convertConstant(gl, constantVal, encoding = null) {
                 return null;
             }
         } else {
-            extension = getExtension$1(gl, 'WEBGL_compressed_texture_s3tc');
+            extension = getExtension(gl, 'WEBGL_compressed_texture_s3tc');
             if (extension !== null) {
                 if (p === RGB_S3TC_DXT1_Format) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;
                 if (p === RGBA_S3TC_DXT1_Format) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;
@@ -64442,7 +64444,7 @@ function convertConstant(gl, constantVal, encoding = null) {
     // PVRTC
 
     if (p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format || p === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format) {
-        const extension = getExtension$1(gl, 'WEBGL_compressed_texture_pvrtc');
+        const extension = getExtension(gl, 'WEBGL_compressed_texture_pvrtc');
         if (extension !== null) {
             if (p === RGB_PVRTC_4BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
             if (p === RGB_PVRTC_2BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
@@ -64456,7 +64458,7 @@ function convertConstant(gl, constantVal, encoding = null) {
     // ETC1
 
     if (p === RGB_ETC1_Format) {
-        const extension = getExtension$1(gl, 'WEBGL_compressed_texture_etc1');
+        const extension = getExtension(gl, 'WEBGL_compressed_texture_etc1');
         if (extension !== null) {
             return extension.COMPRESSED_RGB_ETC1_WEBGL;
         } else {
@@ -64467,7 +64469,7 @@ function convertConstant(gl, constantVal, encoding = null) {
     // ETC2
 
     if (p === RGB_ETC2_Format || p === RGBA_ETC2_EAC_Format) {
-        const extension = getExtension$1(gl, 'WEBGL_compressed_texture_etc');
+        const extension = getExtension(gl, 'WEBGL_compressed_texture_etc');
         if (extension !== null) {
             if (p === RGB_ETC2_Format) return (encoding === sRGBEncoding) ? extension.COMPRESSED_SRGB8_ETC2 : extension.COMPRESSED_RGB8_ETC2;
             if (p === RGBA_ETC2_EAC_Format) return (encoding === sRGBEncoding) ? extension.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : extension.COMPRESSED_RGBA8_ETC2_EAC;
@@ -64483,7 +64485,7 @@ function convertConstant(gl, constantVal, encoding = null) {
         p === RGBA_ASTC_8x6_Format || p === RGBA_ASTC_8x8_Format || p === RGBA_ASTC_10x5_Format ||
         p === RGBA_ASTC_10x6_Format || p === RGBA_ASTC_10x8_Format || p === RGBA_ASTC_10x10_Format ||
         p === RGBA_ASTC_12x10_Format || p === RGBA_ASTC_12x12_Format) {
-        const extension = getExtension$1(gl, 'WEBGL_compressed_texture_astc');
+        const extension = getExtension(gl, 'WEBGL_compressed_texture_astc');
         if (extension !== null) {
             if (p === RGBA_ASTC_4x4_Format) return (encoding === sRGBEncoding) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR : extension.COMPRESSED_RGBA_ASTC_4x4_KHR;
             if (p === RGBA_ASTC_5x4_Format) return (encoding === sRGBEncoding) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR : extension.COMPRESSED_RGBA_ASTC_5x4_KHR;
@@ -64507,7 +64509,7 @@ function convertConstant(gl, constantVal, encoding = null) {
     // BPTC
 
     if (p === RGBA_BPTC_Format) {
-        const extension = getExtension$1(gl, 'EXT_texture_compression_bptc');
+        const extension = getExtension(gl, 'EXT_texture_compression_bptc');
         if (extension !== null) {
             if (p === RGBA_BPTC_Format) {
                 return (encoding === sRGBEncoding) ? extension.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT : extension.COMPRESSED_RGBA_BPTC_UNORM_EXT;
@@ -64540,9 +64542,6 @@ function convertConstant(gl, constantVal, encoding = null) {
     if (p === LinearMipMapLinearFilter) {
         return gl.LINEAR_MIPMAP_LINEAR;
     }
-    if (p === NearestMipMapLinearFilter) {
-        return gl.NEAREST_MIPMAP_LINEAR;
-    }
     if (p === NearestFilter) {
         return gl.NEAREST;
     }
@@ -64580,7 +64579,7 @@ class Texture2D {
         this.texture = gl.createTexture();
 
         if (preloadColor) {
-            this.setPreloadColor(preloadColor || [0, 0, 0, 1]); // Prevents "there is no texture bound to the unit 0" error
+            this.setPreloadColor(preloadColor); // Prevents "there is no texture bound to the unit 0" error
         }
 
         this.allocated = true;
@@ -64599,9 +64598,6 @@ class Texture2D {
             color$2[3] = Math.floor((value[3] !== undefined ? value[3] : 1) * 255);
         }
         const gl = this.gl;
-        const glFormat = convertConstant(gl, this.format, this.encoding);
-        const glType = convertConstant(gl, this.type);
-        const glInternalFormat = getInternalFormat(gl, this.internalFormat, glFormat, glType, this.encoding, false);
         gl.bindTexture(this.target, this.texture);
         if (this.target === gl.TEXTURE_CUBE_MAP) {
             const faces = [
@@ -64613,10 +64609,10 @@ class Texture2D {
                 gl.TEXTURE_CUBE_MAP_NEGATIVE_Z
             ];
             for (let i = 0, len = faces.length; i < len; i++) {
-                gl.texImage2D(faces[i], 0, glInternalFormat, 1, 1, 0, glFormat, glType, color$2);
+                gl.texImage2D(faces[i], 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color$2);
             }
         } else {
-            gl.texImage2D(this.target, 0, glInternalFormat, 1, 1, 0, glFormat, glType, color$2);
+            gl.texImage2D(this.target, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color$2);
         }
         gl.bindTexture(this.target, null);
     }
@@ -64776,44 +64772,38 @@ class Texture2D {
         gl.activeTexture(gl.TEXTURE0 + 0);
         gl.bindTexture(this.target, this.texture);
 
-        let generateMipMap = false;
+        let supportsMips = mipmaps.length > 1;
 
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this.flipY);
         gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, this.premultiplyAlpha);
         gl.pixelStorei(gl.UNPACK_ALIGNMENT, this.unpackAlignment);
         gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
 
-        {
-
-            const minFilter = convertConstant(gl, this.minFilter);
-            gl.texParameteri(this.target, gl.TEXTURE_MIN_FILTER, minFilter);
-            if (minFilter === gl.NEAREST_MIPMAP_NEAREST || minFilter === gl.LINEAR_MIPMAP_NEAREST || minFilter === gl.NEAREST_MIPMAP_LINEAR || minFilter === gl.LINEAR_MIPMAP_LINEAR) {
-                generateMipMap = true;
-            }
-
-            const magFilter = convertConstant(gl, this.magFilter);
-            if (magFilter) {
-                gl.texParameteri(this.target, gl.TEXTURE_MAG_FILTER, magFilter);
-            }
+        const wrapS = convertConstant(gl, this.wrapS);
+        if (wrapS) {
+            gl.texParameteri(this.target, gl.TEXTURE_WRAP_S, wrapS);
+        }
 
-            const wrapS = convertConstant(gl, this.wrapS);
-            if (wrapS) {
-                gl.texParameteri(this.target, gl.TEXTURE_WRAP_S, wrapS);
-            }
+        const wrapT = convertConstant(gl, this.wrapT);
+        if (wrapT) {
+            gl.texParameteri(this.target, gl.TEXTURE_WRAP_T, wrapT);
+        }
 
-            const wrapT = convertConstant(gl, this.wrapT);
-            if (wrapT) {
-                gl.texParameteri(this.target, gl.TEXTURE_WRAP_T, wrapT);
+        if (this.type === gl.TEXTURE_3D || this.type === gl.TEXTURE_2D_ARRAY) {
+            const wrapR = convertConstant(gl, this.wrapR);
+            if (wrapR) {
+                gl.texParameteri(this.target, gl.TEXTURE_WRAP_R, wrapR);
             }
+            gl.texParameteri(this.type, gl.TEXTURE_WRAP_R, wrapR);
+        }
 
-            if (this.type === gl.TEXTURE_3D || this.type === gl.TEXTURE_2D_ARRAY) {
-                const wrapR = convertConstant(gl, this.wrapR);
-                if (wrapR) {
-                    gl.texParameteri(this.target, gl.TEXTURE_WRAP_R, wrapR);
-                }
-                gl.texParameteri(this.type, gl.TEXTURE_WRAP_R, wrapR);
-            }
+        if (supportsMips) {
+            gl.texParameteri(this.target, gl.TEXTURE_MIN_FILTER, filterFallback(gl, this.minFilter));
+            gl.texParameteri(this.target, gl.TEXTURE_MAG_FILTER, filterFallback(gl, this.magFilter));
 
+        } else {
+            gl.texParameteri(this.target, gl.TEXTURE_MIN_FILTER, convertConstant(gl, this.minFilter));
+            gl.texParameteri(this.target, gl.TEXTURE_MAG_FILTER, convertConstant(gl, this.magFilter));
         }
 
         const glFormat = convertConstant(gl, this.format, this.encoding);
@@ -64833,13 +64823,13 @@ class Texture2D {
                     console.warn('Attempt to load unsupported compressed texture format in .setCompressedData()');
                 }
             } else {
-                    gl.texSubImage2D(gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data);
+                gl.texSubImage2D(gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data);
             }
         }
 
-        if (generateMipMap) {
-            gl.generateMipmap(this.target);
-        }
+        //    if (generateMipMap) {
+        // //       gl.generateMipmap(this.target); // Only for roughness textures?
+        //    }
 
         gl.bindTexture(this.target, null);
     }
@@ -64966,6 +64956,14 @@ function getInternalFormat(gl, internalFormatName, glFormat, glType, encoding, i
     return internalFormat;
 }
 
+function filterFallback(gl, f) {
+    if (f === NearestFilter || f === NearestMipmapNearestFilter || f === NearestMipmapLinearFilter) {
+        return gl.NEAREST;
+    }
+    return gl.LINEAR;
+
+}
+
 /**
  * Instantiated by VBOSceneModel#createTexture
  *
@@ -65886,6 +65884,1059 @@ class SceneModel  {
     }
 }
 
+class LoadingManager {
+
+    constructor(onLoad, onProgress, onError) {
+
+        this.isLoading = false;
+        this.itemsLoaded = 0;
+        this.itemsTotal = 0;
+        this.urlModifier = undefined;
+        this.handlers = [];
+
+        this.onStart = undefined;
+        this.onLoad = onLoad;
+        this.onProgress = onProgress;
+        this.onError = onError;
+    }
+
+    itemStart(url) {
+        this.itemsTotal++;
+        if (this.isLoading === false) {
+            if (this.onStart !== undefined) {
+                this.onStart(url, this.itemsLoaded, this.itemsTotal);
+            }
+        }
+        this.isLoading = true;
+    }
+
+    itemEnd(url) {
+        this.itemsLoaded++;
+        if (this.onProgress !== undefined) {
+            this.onProgress(url, this.itemsLoaded, this.itemsTotal);
+        }
+        if (this.itemsLoaded === this.itemsTotal) {
+            this.isLoading = false;
+            if (this.onLoad !== undefined) {
+                this.onLoad();
+            }
+        }
+    }
+
+    itemError(url) {
+        if (this.onError !== undefined) {
+            this.onError(url);
+        }
+    }
+
+    resolveURL(url) {
+        if (this.urlModifier) {
+            return this.urlModifier(url);
+        }
+        return url;
+    }
+
+    setURLModifier(transform) {
+        this.urlModifier = transform;
+        return this;
+    }
+
+    addHandler(regex, loader) {
+        this.handlers.push(regex, loader);
+        return this;
+    }
+
+    removeHandler(regex) {
+        const index = this.handlers.indexOf(regex);
+        if (index !== -1) {
+            this.handlers.splice(index, 2);
+        }
+        return this;
+    }
+
+    getHandler(file) {
+        for (let i = 0, l = this.handlers.length; i < l; i += 2) {
+            const regex = this.handlers[i];
+            const loader = this.handlers[i + 1];
+            if (regex.global) regex.lastIndex = 0; // see #17920
+            if (regex.test(file)) {
+                return loader;
+            }
+        }
+        return null;
+    }
+}
+
+const DefaultLoadingManager = new LoadingManager();
+
+class Loader {
+
+    constructor(manager) {
+
+        this.manager = (manager !== undefined) ? manager : DefaultLoadingManager;
+
+        this.crossOrigin = 'anonymous';
+        this.withCredentials = false;
+        this.path = '';
+        this.resourcePath = '';
+        this.requestHeader = {};
+    }
+
+    load( /* url, onLoad, onProgress, onError */) {
+    }
+
+    loadAsync(url, onProgress) {
+        const scope = this;
+        return new Promise(function (resolve, reject) {
+            scope.load(url, resolve, onProgress, reject);
+        });
+    }
+
+    parse( /* data */) {
+    }
+
+    setCrossOrigin(crossOrigin) {
+        this.crossOrigin = crossOrigin;
+        return this;
+    }
+
+    setWithCredentials(value) {
+        this.withCredentials = value;
+        return this;
+    }
+
+    setPath(path) {
+        this.path = path;
+        return this;
+    }
+
+    setResourcePath(resourcePath) {
+        this.resourcePath = resourcePath;
+        return this;
+    }
+
+    setRequestHeader(requestHeader) {
+        this.requestHeader = requestHeader;
+        return this;
+    }
+}
+
+/**
+ * @author Deepkolos / https://github.com/deepkolos
+ */
+
+class WorkerPool$1 {
+
+    constructor(pool = 4) {
+        this.pool = pool;
+        this.queue = [];
+        this.workers = [];
+        this.workersResolve = [];
+        this.workerStatus = 0;
+    }
+
+    _initWorker(workerId) {
+        if (!this.workers[workerId]) {
+            const worker = this.workerCreator();
+            worker.addEventListener('message', this._onMessage.bind(this, workerId));
+            this.workers[workerId] = worker;
+        }
+    }
+
+    _getIdleWorker() {
+        for (let i = 0; i < this.pool; i++)
+            if (!(this.workerStatus & (1 << i))) return i;
+        return -1;
+    }
+
+    _onMessage(workerId, msg) {
+        const resolve = this.workersResolve[workerId];
+        resolve && resolve(msg);
+        if (this.queue.length) {
+            const {resolve, msg, transfer} = this.queue.shift();
+            this.workersResolve[workerId] = resolve;
+            this.workers[workerId].postMessage(msg, transfer);
+        } else {
+            this.workerStatus ^= 1 << workerId;
+        }
+    }
+
+    setWorkerCreator(workerCreator) {
+        this.workerCreator = workerCreator;
+    }
+
+    setWorkerLimit(pool) {
+        this.pool = pool;
+    }
+
+    postMessage(msg, transfer) {
+        return new Promise((resolve) => {
+            const workerId = this._getIdleWorker();
+            if (workerId !== -1) {
+                this._initWorker(workerId);
+                this.workerStatus |= 1 << workerId;
+                this.workersResolve[workerId] = resolve;
+                this.workers[workerId].postMessage(msg, transfer);
+            } else {
+                this.queue.push({resolve, msg, transfer});
+            }
+        });
+    }
+
+    destroy() {
+
+        this.workers.forEach((worker) => worker.terminate());
+        this.workersResolve.length = 0;
+        this.workers.length = 0;
+        this.queue.length = 0;
+        this.workerStatus = 0;
+
+    }
+
+}
+
+/**
+ * Transcodes texture data.
+ *
+ * A {@link SceneModel} configured with an appropriate TextureTranscoder will allow us to add textures from
+ * transcoded buffers or files. For a concrete example, see {@link VBOSceneModel}, which can be configured with
+ * a {@link KTX2TextureTranscoder}, which allows us to add textures from KTX2 buffers and files.
+ *
+ * @interface
+ */
+class TextureTranscoder {
+
+    /**
+     * Transcodes texture data from transcoded buffers into a {@link Texture2D}.
+     *
+     * @param {ArrayBuffer[]} buffers Transcoded texture data. Given as an array of buffers so that we can support
+     * multi-image textures, such as cube maps.
+     * @param {*} config Transcoding options.
+     * @param {Texture2D} texture The texture to load.
+     * @returns {Promise} Resolves when the texture has loaded.
+     */
+    transcode(buffers, texture, config = {}) {
+    }
+
+    /**
+     * Destroys this transcoder.
+     */
+    destroy() {
+    }
+}
+
+const Cache = {
+
+    enabled: false,
+    files: {},
+
+    add: function (key, file) {
+        if (this.enabled === false) {
+            return;
+        }
+        this.files[key] = file;
+    },
+
+    get: function (key) {
+        if (this.enabled === false) {
+            return;
+        }
+        return this.files[key];
+    },
+
+    remove: function (key) {
+        delete this.files[key];
+    },
+
+    clear: function () {
+        this.files = {};
+    }
+};
+
+const loading = {};
+
+class FileLoader extends Loader {
+
+    constructor(manager) {
+        super(manager);
+    }
+
+    load(url, onLoad, onProgress, onError) {
+        if (url === undefined) {
+            url = '';
+        }
+        if (this.path !== undefined) {
+            url = this.path + url;
+        }
+        url = this.manager.resolveURL(url);
+        const cached = Cache.get(url);
+        if (cached !== undefined) {
+            this.manager.itemStart(url);
+            setTimeout(() => {
+                if (onLoad) {
+                    onLoad(cached);
+                }
+                this.manager.itemEnd(url);
+            }, 0);
+            return cached;
+        }
+        if (loading[url] !== undefined) {
+            loading[url].push({onLoad, onProgress, onError});
+            return;
+        }
+        loading[url] = [];
+        loading[url].push({onLoad, onProgress, onError});
+        const req = new Request(url, {
+            headers: new Headers(this.requestHeader),
+            credentials: this.withCredentials ? 'include' : 'same-origin'
+        });
+        const mimeType = this.mimeType;
+        const responseType = this.responseType;
+        fetch(req).then(response => {
+            if (response.status === 200 || response.status === 0) {
+                // Some browsers return HTTP Status 0 when using non-http protocol
+                // e.g. 'file://' or 'data://'. Handle as success.
+                if (response.status === 0) {
+                    console.warn('FileLoader: HTTP Status 0 received.');
+                }
+                if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
+                    return response;
+                }
+                const callbacks = loading[url];
+                const reader = response.body.getReader();
+                const contentLength = response.headers.get('Content-Length');
+                const total = contentLength ? parseInt(contentLength) : 0;
+                const lengthComputable = total !== 0;
+                let loaded = 0;
+                const stream = new ReadableStream({
+                    start(controller) {
+                        readData();
+
+                        function readData() {
+                            reader.read().then(({done, value}) => {
+                                if (done) {
+                                    controller.close();
+                                } else {
+                                    loaded += value.byteLength;
+                                    const event = new ProgressEvent('progress', {lengthComputable, loaded, total});
+                                    for (let i = 0, il = callbacks.length; i < il; i++) {
+                                        const callback = callbacks[i];
+                                        if (callback.onProgress) {
+                                            callback.onProgress(event);
+                                        }
+                                    }
+                                    controller.enqueue(value);
+                                    readData();
+                                }
+                            });
+                        }
+                    }
+                });
+                return new Response(stream);
+            } else {
+                throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
+            }
+        }).then(response => {
+            switch (responseType) {
+                case 'arraybuffer':
+                    return response.arrayBuffer();
+                case 'blob':
+                    return response.blob();
+                case 'document':
+                    return response.text()
+                        .then(text => {
+                            const parser = new DOMParser();
+                            return parser.parseFromString(text, mimeType);
+                        });
+                case 'json':
+                    return response.json();
+                default:
+                    if (mimeType === undefined) {
+                        return response.text();
+                    } else {
+                        // sniff encoding
+                        const re = /charset="?([^;"\s]*)"?/i;
+                        const exec = re.exec(mimeType);
+                        const label = exec && exec[1] ? exec[1].toLowerCase() : undefined;
+                        const decoder = new TextDecoder(label);
+                        return response.arrayBuffer().then(ab => decoder.decode(ab));
+                    }
+            }
+        }).then(data => {
+            // Add to cache only on HTTP success, so that we do not cache
+            // error response bodies as proper responses to requests.
+            Cache.add(url, data);
+            const callbacks = loading[url];
+            delete loading[url];
+            for (let i = 0, il = callbacks.length; i < il; i++) {
+                const callback = callbacks[i];
+                if (callback.onLoad) {
+                    callback.onLoad(data);
+                }
+            }
+        }).catch(err => {
+            // Abort errors and other errors are handled the same
+            const callbacks = loading[url];
+            if (callbacks === undefined) {
+                // When onLoad was called and url was deleted in `loading`
+                this.manager.itemError(url);
+                throw err;
+
+            }
+            delete loading[url];
+            for (let i = 0, il = callbacks.length; i < il; i++) {
+                const callback = callbacks[i];
+                if (callback.onError) {
+                    callback.onError(err);
+                }
+            }
+            this.manager.itemError(url);
+        }).finally(() => {
+            this.manager.itemEnd(url);
+        });
+        this.manager.itemStart(url);
+    }
+
+    setResponseType(value) {
+        this.responseType = value;
+        return this;
+    }
+
+    setMimeType(value) {
+        this.mimeType = value;
+        return this;
+    }
+}
+
+const KTX2TransferSRGB = 2;
+const KTX2_ALPHA_PREMULTIPLIED = 1;
+
+let activeTranscoders = 0;
+
+/**
+ * Transcodes texture data from KTX2.
+ *
+ * ## Overview
+ *
+ * * Uses the [Basis Universal GPU Texture Codec](https://github.com/BinomialLLC/basis_universal) to
+ * transcode [KTX2](https://github.khronos.org/KTX-Specification/) textures.
+ * * {@link XKTLoaderPlugin} uses a KTX2TextureTranscoder to load textures in XKT files.
+ * * {@link VBOSceneModel} uses a KTX2TextureTranscoder to enable us to add KTX2-encoded textures.
+ * * Loads the Basis Codec from [CDN](https://cdn.jsdelivr.net/npm/@xeokit/xeokit-sdk/dist/basis/) by default, but can
+ * also be configured to load the Codec from local files.
+ * * We also bundle the Basis Codec with the xeokit-sdk npm package, and in the [repository](https://github.com/xeokit/xeokit-sdk/tree/master/dist/basis).
+ *
+ * ## What is KTX2?
+ *
+ * A [KTX2](https://github.khronos.org/KTX-Specification/) file stores GPU texture data in the Khronos Texture 2.0 (KTX2) container format. It contains image data for
+ * a texture asset compressed with Basis Universal (BasisU) supercompression that can be transcoded to different formats
+ * depending on the support provided by the target devices. KTX2 provides a lightweight format for distributing texture
+ * assets to GPUs. Due to BasisU compression, KTX2 files can store any image format supported by GPUs.
+ *
+ * ## Loading XKT files containing KTX2 textures
+ *
+ * {@link XKTLoaderPlugin} uses a KTX2TextureTranscoder to load textures in XKT files. An XKTLoaderPlugin has its own
+ * default KTX2TextureTranscoder, configured to load the Basis Codec from the [CDN](https://cdn.jsdelivr.net/npm/@xeokit/xeokit-sdk/dist/basis/). If we wish, we can override that with our own
+ * KTX2TextureTranscoder, configured to load the Codec locally.
+ *
+ * In the example below, we'll create a {@link Viewer} and add an {@link XKTLoaderPlugin}
+ * configured with a KTX2TextureTranscoder. Then we'll use the XKTLoaderPlugin to load an
+ * XKT file that contains KTX2 textures, which the plugin will transcode using
+ * its KTX2TextureTranscoder.
+ *
+ * We'll configure our KTX2TextureTranscoder to load the Basis Codec from a local directory. If we were happy with loading the
+ * Codec from our [CDN](https://cdn.jsdelivr.net/npm/@xeokit/xeokit-sdk/dist/basis/) (ie. our app will always have an Internet connection) then we could just leave out the
+ * KTX2TextureTranscoder altogether, and let the XKTLoaderPlugin use its internal default KTX2TextureTranscoder, which is configured to
+ * load the Codec from the CDN. We'll stick with loading our own Codec, in case we want to run our app without an Internet connection.
+ *
+ * <a href="https://xeokit.github.io/xeokit-sdk/examples/#loading_XKT_Textures_HousePlan"><img src="https://xeokit.github.io/xeokit-sdk/assets/images/xktWithTextures.png"></a>
+ *
+ * * [[Run this example](https://xeokit.github.io/xeokit-sdk/examples/#loading_XKT_Textures_HousePlan)]
+ *
+ * ````javascript
+ * const viewer = new Viewer({
+ *     canvasId: "myCanvas",
+ *     transparent: true
+ * });
+ *
+ * viewer.camera.eye = [-2.56, 8.38, 8.27];
+ * viewer.camera.look = [13.44, 3.31, -14.83];
+ * viewer.camera.up = [0.10, 0.98, -0.14];
+ *
+ * const textureTranscoder = new KTX2TextureTranscoder({
+ *     viewer,
+ *     transcoderPath: "./../dist/basis/" // <------ Path to Basis Universal transcoder
+ * });
+ *
+ * const xktLoader = new XKTLoaderPlugin(viewer, {
+ *     textureTranscoder // <<------------- Transcodes KTX2 textures in XKT files
+ * });
+ *
+ * const sceneModel = xktLoader.load({
+ *     id: "myModel",
+ *     src: "./HousePlan.xkt" // <<------ XKT file with KTX2 textures
+ * });
+ * ````
+ *
+ * ## Loading KTX2 files into a VBOSceneModel
+ *
+ * A {@link SceneModel} that is configured with a KTX2TextureTranscoder will
+ * allow us to load textures into it from KTX2-transcoded buffers or files.
+ *
+ * In the example below, we'll create a {@link Viewer}, containing a {@link VBOSceneModel} configured with a
+ * KTX2TextureTranscoder.
+ *
+ * We'll then programmatically create a simple object within the VBOSceneModel, consisting of
+ * a single box mesh with a texture loaded from a KTX2 file, which our VBOSceneModel internally transcodes, using
+ * its KTX2TextureTranscoder.
+ *
+ * As in the previous example, we'll configure our KTX2TextureTranscoder to load the Basis Codec from a local directory.
+ *
+ * * [Run a similar example](http://localhost:8080/examples/sceneRepresentation_VBOSceneModel_batching_textures_ktx2.html)
+ *
+ * ````javascript
+ * const viewer = new Viewer({
+ *     canvasId: "myCanvas",
+ *     transparent: true
+ * });
+ *
+ * viewer.scene.camera.eye = [-21.80, 4.01, 6.56];
+ * viewer.scene.camera.look = [0, -5.75, 0];
+ * viewer.scene.camera.up = [0.37, 0.91, -0.11];
+ *
+ * const textureTranscoder = new KTX2TextureTranscoder({
+ *     viewer,
+ *     transcoderPath: "./../dist/basis/" // <------ Path to BasisU transcoder module
+ * });
+ *
+ * const vboSceneModel = new VBOSceneModel(viewer.scene, {
+ *      id: "myModel",
+ *      textureTranscoder // <<-------------------- Configure model with our transcoder
+ *  });
+ *
+ * vboSceneModel.createTexture({
+ *      id: "myColorTexture",
+ *      src: "../assets/textures/compressed/sample_uastc_zstd.ktx2" // <<----- KTX2 texture asset
+ * });
+ *
+ * vboSceneModel.createTexture({
+ *      id: "myMetallicRoughnessTexture",
+ *      src: "../assets/textures/alpha/crosshatchAlphaMap.jpg" // <<----- JPEG texture asset
+ * });
+ *
+ * vboSceneModel.createTextureSet({
+ *      id: "myTextureSet",
+ *      colorTextureId: "myColorTexture",
+ *      metallicRoughnessTextureId: "myMetallicRoughnessTexture"
+ *  });
+ *
+ * vboSceneModel.createMesh({
+ *      id: "myMesh",
+ *      textureSetId: "myTextureSet",
+ *      primitive: "triangles",
+ *      positions: [1, 1, 1, ...],
+ *      normals: [0, 0, 1, 0, ...],
+ *      uv: [1, 0, 0, ...],
+ *      indices: [0, 1, 2, ...],
+ *  });
+ *
+ * vboSceneModel.createEntity({
+ *      id: "myEntity",
+ *      meshIds: ["myMesh"]
+ *  });
+ *
+ * vboSceneModel.finalize();
+ * ````
+ *
+ * ## Loading KTX2 ArrayBuffers into a VBOSceneModel
+ *
+ * A {@link SceneModel} that is configured with a KTX2TextureTranscoder will also allow us to load textures into
+ * it from KTX2 ArrayBuffers.
+ *
+ * In the example below, we'll create a {@link Viewer}, containing a {@link VBOSceneModel} configured with a
+ * KTX2TextureTranscoder.
+ *
+ * We'll then programmatically create a simple object within the VBOSceneModel, consisting of
+ * a single mesh with a texture loaded from a KTX2 ArrayBuffer, which our VBOSceneModel internally transcodes, using
+ * its KTX2TextureTranscoder.
+ *
+ * ````javascript
+ * const viewer = new Viewer({
+ *     canvasId: "myCanvas",
+ *     transparent: true
+ * });
+ *
+ * viewer.scene.camera.eye = [-21.80, 4.01, 6.56];
+ * viewer.scene.camera.look = [0, -5.75, 0];
+ * viewer.scene.camera.up = [0.37, 0.91, -0.11];
+ *
+ * const textureTranscoder = new KTX2TextureTranscoder({
+ *     viewer,
+ *     transcoderPath: "./../dist/basis/" // <------ Path to BasisU transcoder module
+ * });
+ *
+ * const vboSceneModel = new VBOSceneModel(viewer.scene, {
+ *      id: "myModel",
+ *      textureTranscoder // <<-------------------- Configure model with our transcoder
+ * });
+ *
+ * utils.loadArraybuffer("../assets/textures/compressed/sample_uastc_zstd.ktx2",(arrayBuffer) => {
+ *
+ *     vboSceneModel.createTexture({
+ *         id: "myColorTexture",
+ *         buffers: [arrayBuffer] // <<----- KTX2 texture asset
+ *     });
+ *
+ *     vboSceneModel.createTexture({
+ *         id: "myMetallicRoughnessTexture",
+ *         src: "../assets/textures/alpha/crosshatchAlphaMap.jpg" // <<----- JPEG texture asset
+ *     });
+ *
+ *     vboSceneModel.createTextureSet({
+ *        id: "myTextureSet",
+ *        colorTextureId: "myColorTexture",
+ *        metallicRoughnessTextureId: "myMetallicRoughnessTexture"
+ *     });
+ *
+ *     vboSceneModel.createMesh({
+ *          id: "myMesh",
+ *          textureSetId: "myTextureSet",
+ *          primitive: "triangles",
+ *          positions: [1, 1, 1, ...],
+ *          normals: [0, 0, 1, 0, ...],
+ *          uv: [1, 0, 0, ...],
+ *          indices: [0, 1, 2, ...],
+ *     });
+ *
+ *     vboSceneModel.createEntity({
+ *         id: "myEntity",
+ *         meshIds: ["myMesh"]
+ *     });
+ *
+ *     vboSceneModel.finalize();
+ * });
+ * ````
+ *
+ * @implements {TextureTranscoder}
+ */
+class KTX2TextureTranscoder {
+
+    /**
+     * Creates a new KTX2TextureTranscoder.
+     *
+     * @param {Viewer} viewer The Viewer that our KTX2TextureTranscoder will be used with. This KTX2TextureTranscoder
+     * must only be used to transcode textures for this Viewer. This is because the Viewer's capabilities will decide
+     * what target GPU formats this KTX2TextureTranscoder will transcode to.
+     * @param {String} [transcoderPath="https://cdn.jsdelivr.net/npm/@xeokit/xeokit-sdk/dist/basis/"] Path to the Basis
+     * transcoder module that internally does the heavy lifting for our KTX2TextureTranscoder. If we omit this configuration,
+     * then our KTX2TextureTranscoder will load it from ````https://cdn.jsdelivr.net/npm/@xeokit/xeokit-sdk/dist/basis/```` by
+     * default. Therefore, make sure your application is connected to the internet if you wish to use the default transcoder path.
+     * @param {Number} [workerLimit] The maximum number of Workers to use for transcoding.
+     */
+    constructor({viewer, transcoderPath, workerLimit}) {
+
+        this._transcoderPath = transcoderPath || "https://cdn.jsdelivr.net/npm/@xeokit/xeokit-sdk/dist/basis/";
+        this._transcoderBinary = null;
+        this._transcoderPending = null;
+        this._workerPool = new WorkerPool$1();
+        this._workerSourceURL = '';
+
+        if (workerLimit) {
+            this._workerPool.setWorkerLimit(workerLimit);
+        }
+
+        const viewerCapabilities = viewer.capabilities;
+
+        this._workerConfig = {
+            astcSupported: viewerCapabilities.astcSupported,
+            etc1Supported: viewerCapabilities.etc1Supported,
+            etc2Supported: viewerCapabilities.etc2Supported,
+            dxtSupported: viewerCapabilities.dxtSupported,
+            bptcSupported: viewerCapabilities.bptcSupported,
+            pvrtcSupported: viewerCapabilities.pvrtcSupported
+        };
+
+        this._supportedFileTypes = ["xkt2"];
+    }
+
+    _init() {
+        if (!this._transcoderPending) {
+            const jsLoader = new FileLoader();
+            jsLoader.setPath(this._transcoderPath);
+            jsLoader.setWithCredentials(this.withCredentials);
+            const jsContent = jsLoader.loadAsync('basis_transcoder.js');
+            const binaryLoader = new FileLoader();
+            binaryLoader.setPath(this._transcoderPath);
+            binaryLoader.setResponseType('arraybuffer');
+            binaryLoader.setWithCredentials(this.withCredentials);
+            const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm');
+            this._transcoderPending = Promise.all([jsContent, binaryContent])
+                .then(([jsContent, binaryContent]) => {
+                    const fn = KTX2TextureTranscoder.BasisWorker.toString();
+                    const body = [
+                        '/* constants */',
+                        'let _EngineFormat = ' + JSON.stringify(KTX2TextureTranscoder.EngineFormat),
+                        'let _TranscoderFormat = ' + JSON.stringify(KTX2TextureTranscoder.TranscoderFormat),
+                        'let _BasisFormat = ' + JSON.stringify(KTX2TextureTranscoder.BasisFormat),
+                        '/* basis_transcoder.js */',
+                        jsContent,
+                        '/* worker */',
+                        fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))
+                    ].join('\n');
+                    this._workerSourceURL = URL.createObjectURL(new Blob([body]));
+                    this._transcoderBinary = binaryContent;
+                    this._workerPool.setWorkerCreator(() => {
+                        const worker = new Worker(this._workerSourceURL);
+                        const transcoderBinary = this._transcoderBinary.slice(0);
+                        worker.postMessage({
+                            type: 'init',
+                            config: this._workerConfig,
+                            transcoderBinary
+                        }, [transcoderBinary]);
+                        return worker;
+                    });
+                });
+            if (activeTranscoders > 0) {
+                console.warn('KTX2TextureTranscoder: Multiple active KTX2TextureTranscoder may cause performance issues.' + ' Use a single KTX2TextureTranscoder instance, or call .dispose() on old instances.');
+            }
+            activeTranscoders++;
+        }
+        return this._transcoderPending;
+    }
+
+    /**
+     * Transcodes texture data from transcoded buffers into a {@link Texture2D}.
+     *
+     * @param {ArrayBuffer[]} buffers Transcoded texture data. Given as an array of buffers so that we can support multi-image textures, such as cube maps.
+     * @param {*} config Transcoding options.
+     * @param {Texture2D} texture The texture to load.
+     * @returns {Promise} Resolves when the texture has loaded.
+     */
+    transcode(buffers, texture, config = {}) {
+        return new Promise((resolve, reject) => {
+            const taskConfig = config;
+            this._init().then(() => {
+                return this._workerPool.postMessage({
+                    type: 'transcode',
+                    buffers,
+                    taskConfig: taskConfig
+                }, buffers);
+            }).then((e) => {
+                const transcodeResult = e.data;
+                const {mipmaps, width, height, format, type, error, dfdTransferFn, dfdFlags} = transcodeResult;
+                if (type === 'error') {
+                    return reject(error);
+                }
+                texture.setCompressedData({
+                    mipmaps,
+                    props: {
+                        format: format,
+                        minFilter: mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter,
+                        magFilter: mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter,
+                        encoding: dfdTransferFn === KTX2TransferSRGB ? sRGBEncoding : LinearEncoding,
+                        premultiplyAlpha: !!(dfdFlags & KTX2_ALPHA_PREMULTIPLIED)
+                    }
+                });
+                resolve();
+            });
+        });
+    }
+
+    /**
+     * Destroys this KTX2TextureTranscoder
+     */
+    destroy() {
+        URL.revokeObjectURL(this._workerSourceURL);
+        this._workerPool.destroy();
+        activeTranscoders--;
+    }
+}
+
+/**
+ * @private
+ */
+KTX2TextureTranscoder.BasisFormat = {
+    ETC1S: 0,
+    UASTC_4x4: 1
+};
+
+/**
+ * @private
+ */
+KTX2TextureTranscoder.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
+};
+
+/**
+ * @private
+ */
+KTX2TextureTranscoder.EngineFormat = {
+    RGBAFormat: RGBAFormat,
+    RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
+    RGBA_BPTC_Format: RGBA_BPTC_Format,
+    RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
+    RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
+    RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
+    RGB_ETC1_Format: RGB_ETC1_Format,
+    RGB_ETC2_Format: RGB_ETC2_Format,
+    RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
+    RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format
+};
+
+/* WEB WORKER */
+
+/**
+ * @private
+ * @constructor
+ */
+KTX2TextureTranscoder.BasisWorker = function () {
+
+    let config;
+    let transcoderPending;
+    let BasisModule;
+
+    const EngineFormat = _EngineFormat; // eslint-disable-line no-undef
+    const TranscoderFormat = _TranscoderFormat; // eslint-disable-line no-undef
+    const BasisFormat = _BasisFormat; // eslint-disable-line no-undef
+
+    self.addEventListener('message', 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,
+                            dfdTransferFn,
+                            dfdFlags
+                        } = 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,
+                            dfdTransferFn,
+                            dfdFlags
+                        }, buffers);
+                    } catch (error) {
+                        console.error(`[KTX2TextureTranscoder.BasisWorker]: ${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); // eslint-disable-line no-undef
+        }).then(() => {
+            BasisModule.initializeBasis();
+            if (BasisModule.KTX2File === undefined) {
+                console.warn('KTX2TextureTranscoder: Please update Basis Universal transcoder.');
+            }
+        });
+    }
+
+    function transcode(buffer) {
+        const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer));
+
+        function cleanup() {
+            ktx2File.close();
+            ktx2File.delete();
+        }
+
+        if (!ktx2File.isValid()) {
+            cleanup();
+            throw new Error('KTX2TextureTranscoder: Invalid or unsupported .ktx2 file');
+        }
+        const basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S;
+        const width = ktx2File.getWidth();
+        const height = ktx2File.getHeight();
+        const levels = ktx2File.getLevels();
+        const hasAlpha = ktx2File.getHasAlpha();
+        const dfdTransferFn = ktx2File.getDFDTransferFunc();
+        const dfdFlags = ktx2File.getDFDFlags();
+        const {transcoderFormat, engineFormat} = getTranscoderFormat(basisFormat, width, height, hasAlpha);
+        if (!width || !height || !levels) {
+            cleanup();
+            throw new Error('KTX2TextureTranscoder: Invalid texture');
+        }
+        if (!ktx2File.startTranscoding()) {
+            cleanup();
+            throw new Error('KTX2TextureTranscoder: .startTranscoding failed');
+        }
+        const mipmaps = [];
+        for (let mip = 0; mip < levels; mip++) {
+            const levelInfo = ktx2File.getImageLevelInfo(mip, 0, 0);
+            const mipWidth = levelInfo.origWidth;
+            const mipHeight = levelInfo.origHeight;
+            const dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, 0, 0, transcoderFormat));
+            const status = ktx2File.transcodeImage(dst, mip, 0, 0, transcoderFormat, 0, -1, -1);
+            if (!status) {
+                cleanup();
+                throw new Error('KTX2TextureTranscoder: .transcodeImage failed.');
+            }
+            mipmaps.push({data: dst, width: mipWidth, height: mipHeight});
+        }
+        cleanup();
+        return {width, height, hasAlpha, mipmaps, format: engineFormat, dfdTransferFn, dfdFlags};
+    }
+
+    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
+    // device capabilities, and texture dimensions. The list below ranks the formats separately
+    // for ETC1S and UASTC.
+    //
+    // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
+    // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
+    // chooses RGBA32 only as a last resort and does not expose that option to the caller.
+
+    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],
+        engineFormat: [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 (hasAlpha && opt.transcoderFormat.length < 2) 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('KTX2TextureTranscoder: No suitable compressed texture format found. Decoding to RGBA32.');
+        transcoderFormat = TranscoderFormat.RGBA32;
+        engineFormat = EngineFormat.RGBAFormat;
+        return {
+            transcoderFormat,
+            engineFormat
+        };
+    }
+
+    function isPowerOfTwo(value) {
+        if (value <= 2) return true;
+        return (value & value - 1) === 0 && value !== 0;
+    }
+};
+
+const cachedTranscoders = {};
+
+/**
+ * Returns a new {@link KTX2TextureTranscoder}.
+ *
+ * The ````transcoderPath```` config will be set to: "https://cdn.jsdelivr.net/npm/@xeokit/xeokit-sdk/dist/basis/"
+ *
+ * @private
+ */
+function getKTX2TextureTranscoder(viewer) {
+    const sceneId = viewer.scene.id;
+    let transcoder = cachedTranscoders[sceneId];
+    if (!transcoder) {
+        transcoder = new KTX2TextureTranscoder({viewer});
+        cachedTranscoders[sceneId] = transcoder;
+        viewer.scene.on("destroyed", () => {
+            delete cachedTranscoders[sceneId];
+            transcoder.destroy();
+        });
+    }
+    return transcoder;
+}
+
 const tempVec3a$9 = math.vec3();
 const tempMat4$1 = math.mat4();
 
@@ -66961,7 +68012,7 @@ class VBOSceneModel extends Component {
 
         super(owner, cfg);
 
-        this._textureTranscoder = cfg.textureTranscoder;
+        this._textureTranscoder = cfg.textureTranscoder || getKTX2TextureTranscoder(this.scene.viewer);
 
         this._maxGeometryBatchSize = cfg.maxGeometryBatchSize;
 
@@ -67937,7 +68988,7 @@ class VBOSceneModel extends Component {
      * @param {String} [cfg.src] Image file for the texture. Assumed to be transcoded if not having a recognized image file
      * extension (jpg, jpeg, png etc.). If transcoded, then assumes ````VBOSceneModel```` is configured with a {@link TextureTranscoder}.
      * @param {ArrayBuffer[]} [cfg.buffers] Transcoded texture data. Assumes ````VBOSceneModel```` is
-     * configured with a {@link TextureTranscoder}. Given as an array of buffers so we can potentially support multi-image textures, such as cube maps.
+     * configured with a {@link TextureTranscoder}. This parameter is given as an array of buffers so we can potentially support multi-image textures, such as cube maps.
      * @param {HTMLImageElement} [cfg.image] HTML Image object to load into this texture. Overrides ````src```` and ````buffers````. Never transcoded.
      * @param {Number} [cfg.minFilter=LinearMipmapLinearFilter] How the texture is sampled when a texel covers less than one pixel.
      * Supported values are {@link LinearMipmapLinearFilter}, {@link LinearMipMapNearestFilter}, {@link NearestMipMapNearestFilter}, {@link NearestMipMapLinearFilter} and {@link LinearMipMapLinearFilter}.
@@ -67957,8 +69008,8 @@ class VBOSceneModel extends Component {
             this.error("Texture already created: " + textureId);
             return;
         }
-        if (!cfg.src && !cfg.image) {
-            this.error("Param expected: `src` or `image'");
+        if (!cfg.src && !cfg.image && !cfg.buffers) {
+            this.error("Param expected: `src`, `image' or 'buffers'");
             return null;
         }
         let minFilter = cfg.minFilter || LinearMipmapLinearFilter;
@@ -74059,7 +75110,7 @@ class WorkerThread {
 
 }
 
-class WorkerPool$1 {
+class WorkerPool {
   constructor(props) {
     _defineProperty(this, "name", 'unnamed');
 
@@ -74267,7 +75318,7 @@ class WorkerFarm {
     let workerPool = this.workerPools.get(name);
 
     if (!workerPool) {
-      workerPool = new WorkerPool$1({
+      workerPool = new WorkerPool({
         name,
         source,
         url
@@ -100446,7 +101497,7 @@ function inflate(deflatedData) {
 
     return {
         metadata: JSON.parse(pako.inflate(deflatedData.metadata, {to: 'string'})),
-        textureData: new Uint8ClampedArray(inflate(deflatedData.textureData)),
+        textureData: new Uint8Array(inflate(deflatedData.textureData)),
         eachTextureDataPortion: new Uint32Array(inflate(deflatedData.eachTextureDataPortion)),
         eachTextureDimensions: new Uint16Array(inflate(deflatedData.eachTextureDimensions)),
         positions: new Uint16Array(inflate(deflatedData.positions)),
@@ -100486,7 +101537,7 @@ const decompressColor = (function () {
     };
 })();
 
-const imagDataToImage = (function () {
+((function () {
     const canvas = document.createElement('canvas');
     const context = canvas.getContext('2d');
     return function (imagedata) {
@@ -100495,14 +101546,14 @@ const imagDataToImage = (function () {
         context.putImageData(imagedata, 0, 0);
         return canvas.toDataURL();
     };
-})();
+}))();
 
 function load(viewer, options, inflatedData, sceneModel) {
 
     const metadata = inflatedData.metadata;
     const textureData = inflatedData.textureData;
     const eachTextureDataPortion = inflatedData.eachTextureDataPortion;
-    const eachTextureDimensions = inflatedData.eachTextureDimensions;
+    inflatedData.eachTextureDimensions;
     const positions = inflatedData.positions;
     const normals = inflatedData.normals;
     const colors = inflatedData.colors;
@@ -100563,20 +101614,13 @@ function load(viewer, options, inflatedData, sceneModel) {
         const textureDataPortionSize = textureDataPortionEnd - textureDataPortionStart;
         const textureDataPortionExists = (textureDataPortionSize > 0);
         if (textureDataPortionExists) {
-            const imageDataSubarray = textureData.subarray(textureDataPortionStart, textureDataPortionEnd);
-            const width = eachTextureDimensions[textureIndex * 2 + 0];
-            const height = eachTextureDimensions[textureIndex * 2 + 1];
-            const imageData = new ImageData(imageDataSubarray, width, height);
-
-            //////////////////////////////////////////////////////////////
-            // TODO: This is super inefficient - replace with Basis:
-            //////////////////////////////////////////////////////////////
 
-            const image = imagDataToImage(imageData);
+            const imageDataSubarray = new Uint8Array(textureData.subarray(textureDataPortionStart, textureDataPortionEnd));
+            const arrayBuffer = imageDataSubarray.buffer;
 
             sceneModel.createTexture({
                 id: `texture-${textureIndex}`,
-                src: image
+                buffers: [arrayBuffer]
             });
         }
     }
@@ -100998,6 +102042,7 @@ parsers[ParserV10.version] = ParserV10;
  * * An *````.XKT````* file is a single BLOB containing a model, compressed using geometry quantization
  * and [pako](https://nodeca.github.io/pako/).
  * * Supports double-precision coordinates.
+ * * Supports compressed textures.
  * * Set the position, scale and rotation of each model as you load it.
  * * Filter which IFC types get loaded.
  * * Configure initial default appearances for IFC types.
@@ -101116,17 +102161,26 @@ parsers[ParserV10.version] = ParserV10;
  * model.destroy();
  * ````
  *
- * ## Loading XKT files containing KTX2 textures
+ * ## Loading XKT files containing textures
  *
- * An XKTLoaderPlugin that is configured with a {@link KTX2TextureTranscoder} will allow us to load XKT files that
- * contain KTX2 textures. If we don't configure a KTX2TextureTranscoder, then the XKTLoaderPlugin will simply ignore
- * the textures in the XKT.
+ * XKTLoaderPlugin uses a {@link KTX2TextureTranscoder} to load textures in XKT files (XKT v10+). An XKTLoaderPlugin has its own
+ * default KTX2TextureTranscoder, configured to load the Basis Codec from the CDN. If we wish, we can override that with our own
+ * KTX2TextureTranscoder instance that's configured to load the Codec locally.
  *
  * In the example below, we'll create a {@link Viewer} and add an XKTLoaderPlugin
- * configured with a KTX2TextureTranscoder. Then we'll use the XKTLoaderPlugin to load an
- * XKT file that contains KTX2 textures, which the plugin will transcode using
+ * configured with a KTX2TextureTranscoder that finds the Codec in our local file system. Then we'll use the
+ * XKTLoaderPlugin to load an XKT file that contains KTX2 textures, which the plugin will transcode using
  * its KTX2TextureTranscoder.
  *
+ * We'll configure our KTX2TextureTranscoder to load the Basis Codec from a local directory. If we were happy with loading the
+ * Codec from our CDN (ie. our app will always have an Internet connection) then we could just leave out the
+ * KTX2TextureTranscoder altogether, and let the XKTLoaderPlugin use its internal default KTX2TextureTranscoder, which is configured to
+ * load the Codec from the CDN. We'll stick with loading our own Codec, in case we want to run our app without an Internet connection.
+ *
+ * <a href="https://xeokit.github.io/xeokit-sdk/examples/#loading_XKT_Textures_HousePlan"><img src="https://xeokit.github.io/xeokit-sdk/assets/images/xktWithTextures.png"></a>
+ *
+ * * [[Run this example](https://xeokit.github.io/xeokit-sdk/examples/#loading_XKT_Textures_HousePlan)]
+ *
  * ````javascript
  * const viewer = new Viewer({
  *     canvasId: "myCanvas",
@@ -154212,1016 +155266,6 @@ class PerformanceModel extends VBOSceneModel {
     }
 }
 
-class LoadingManager {
-
-    constructor(onLoad, onProgress, onError) {
-
-        this.isLoading = false;
-        this.itemsLoaded = 0;
-        this.itemsTotal = 0;
-        this.urlModifier = undefined;
-        this.handlers = [];
-
-        this.onStart = undefined;
-        this.onLoad = onLoad;
-        this.onProgress = onProgress;
-        this.onError = onError;
-    }
-
-    itemStart(url) {
-        this.itemsTotal++;
-        if (this.isLoading === false) {
-            if (this.onStart !== undefined) {
-                this.onStart(url, this.itemsLoaded, this.itemsTotal);
-            }
-        }
-        this.isLoading = true;
-    }
-
-    itemEnd(url) {
-        this.itemsLoaded++;
-        if (this.onProgress !== undefined) {
-            this.onProgress(url, this.itemsLoaded, this.itemsTotal);
-        }
-        if (this.itemsLoaded === this.itemsTotal) {
-            this.isLoading = false;
-            if (this.onLoad !== undefined) {
-                this.onLoad();
-            }
-        }
-    }
-
-    itemError(url) {
-        if (this.onError !== undefined) {
-            this.onError(url);
-        }
-    }
-
-    resolveURL(url) {
-        if (this.urlModifier) {
-            return this.urlModifier(url);
-        }
-        return url;
-    }
-
-    setURLModifier(transform) {
-        this.urlModifier = transform;
-        return this;
-    }
-
-    addHandler(regex, loader) {
-        this.handlers.push(regex, loader);
-        return this;
-    }
-
-    removeHandler(regex) {
-        const index = this.handlers.indexOf(regex);
-        if (index !== -1) {
-            this.handlers.splice(index, 2);
-        }
-        return this;
-    }
-
-    getHandler(file) {
-        for (let i = 0, l = this.handlers.length; i < l; i += 2) {
-            const regex = this.handlers[i];
-            const loader = this.handlers[i + 1];
-            if (regex.global) regex.lastIndex = 0; // see #17920
-            if (regex.test(file)) {
-                return loader;
-            }
-        }
-        return null;
-    }
-}
-
-const DefaultLoadingManager = new LoadingManager();
-
-class Loader {
-
-    constructor(manager) {
-
-        this.manager = (manager !== undefined) ? manager : DefaultLoadingManager;
-
-        this.crossOrigin = 'anonymous';
-        this.withCredentials = false;
-        this.path = '';
-        this.resourcePath = '';
-        this.requestHeader = {};
-    }
-
-    load( /* url, onLoad, onProgress, onError */) {
-    }
-
-    loadAsync(url, onProgress) {
-        const scope = this;
-        return new Promise(function (resolve, reject) {
-            scope.load(url, resolve, onProgress, reject);
-        });
-    }
-
-    parse( /* data */) {
-    }
-
-    setCrossOrigin(crossOrigin) {
-        this.crossOrigin = crossOrigin;
-        return this;
-    }
-
-    setWithCredentials(value) {
-        this.withCredentials = value;
-        return this;
-    }
-
-    setPath(path) {
-        this.path = path;
-        return this;
-    }
-
-    setResourcePath(resourcePath) {
-        this.resourcePath = resourcePath;
-        return this;
-    }
-
-    setRequestHeader(requestHeader) {
-        this.requestHeader = requestHeader;
-        return this;
-    }
-}
-
-/**
- * @author Deepkolos / https://github.com/deepkolos
- */
-
-class WorkerPool {
-
-    constructor(pool = 4) {
-        this.pool = pool;
-        this.queue = [];
-        this.workers = [];
-        this.workersResolve = [];
-        this.workerStatus = 0;
-    }
-
-    _initWorker(workerId) {
-        if (!this.workers[workerId]) {
-            const worker = this.workerCreator();
-            worker.addEventListener('message', this._onMessage.bind(this, workerId));
-            this.workers[workerId] = worker;
-        }
-    }
-
-    _getIdleWorker() {
-        for (let i = 0; i < this.pool; i++)
-            if (!(this.workerStatus & (1 << i))) return i;
-        return -1;
-    }
-
-    _onMessage(workerId, msg) {
-        const resolve = this.workersResolve[workerId];
-        resolve && resolve(msg);
-        if (this.queue.length) {
-            const {resolve, msg, transfer} = this.queue.shift();
-            this.workersResolve[workerId] = resolve;
-            this.workers[workerId].postMessage(msg, transfer);
-        } else {
-            this.workerStatus ^= 1 << workerId;
-        }
-    }
-
-    setWorkerCreator(workerCreator) {
-        this.workerCreator = workerCreator;
-    }
-
-    setWorkerLimit(pool) {
-        this.pool = pool;
-    }
-
-    postMessage(msg, transfer) {
-        return new Promise((resolve) => {
-            const workerId = this._getIdleWorker();
-            if (workerId !== -1) {
-                this._initWorker(workerId);
-                this.workerStatus |= 1 << workerId;
-                this.workersResolve[workerId] = resolve;
-                this.workers[workerId].postMessage(msg, transfer);
-            } else {
-                this.queue.push({resolve, msg, transfer});
-            }
-        });
-    }
-
-    destroy() {
-
-        this.workers.forEach((worker) => worker.terminate());
-        this.workersResolve.length = 0;
-        this.workers.length = 0;
-        this.queue.length = 0;
-        this.workerStatus = 0;
-
-    }
-
-}
-
-/**
- * Transcodes texture data.
- *
- * A {@link SceneModel} configured with an appropriate TextureTranscoder will allow us to add textures from
- * transcoded buffers or files. For a concrete example, see {@link VBOSceneModel}, which can be configured with
- * a {@link KTX2TextureTranscoder}, which allows us to add textures from KTX2 buffers and files.
- *
- * @interface
- */
-class TextureTranscoder {
-
-    /**
-     * Transcodes texture data from transcoded buffers into a {@link Texture2D}.
-     *
-     * @param {ArrayBuffer[]} buffers Transcoded texture data. Given as an array of buffers so that we can support
-     * multi-image textures, such as cube maps.
-     * @param {*} config Transcoding options.
-     * @param {Texture2D} texture The texture to load.
-     * @returns {Promise} Resolves when the texture has loaded.
-     */
-    transcode(buffers, texture, config = {}) {
-    }
-
-    /**
-     * Destroys this transcoder.
-     */
-    destroy() {
-    }
-}
-
-const Cache = {
-
-    enabled: false,
-    files: {},
-
-    add: function (key, file) {
-        if (this.enabled === false) {
-            return;
-        }
-        this.files[key] = file;
-    },
-
-    get: function (key) {
-        if (this.enabled === false) {
-            return;
-        }
-        return this.files[key];
-    },
-
-    remove: function (key) {
-        delete this.files[key];
-    },
-
-    clear: function () {
-        this.files = {};
-    }
-};
-
-const loading = {};
-
-class FileLoader extends Loader {
-
-    constructor(manager) {
-        super(manager);
-    }
-
-    load(url, onLoad, onProgress, onError) {
-        if (url === undefined) {
-            url = '';
-        }
-        if (this.path !== undefined) {
-            url = this.path + url;
-        }
-        url = this.manager.resolveURL(url);
-        const cached = Cache.get(url);
-        if (cached !== undefined) {
-            this.manager.itemStart(url);
-            setTimeout(() => {
-                if (onLoad) {
-                    onLoad(cached);
-                }
-                this.manager.itemEnd(url);
-            }, 0);
-            return cached;
-        }
-        if (loading[url] !== undefined) {
-            loading[url].push({onLoad, onProgress, onError});
-            return;
-        }
-        loading[url] = [];
-        loading[url].push({onLoad, onProgress, onError});
-        const req = new Request(url, {
-            headers: new Headers(this.requestHeader),
-            credentials: this.withCredentials ? 'include' : 'same-origin'
-        });
-        const mimeType = this.mimeType;
-        const responseType = this.responseType;
-        fetch(req).then(response => {
-            if (response.status === 200 || response.status === 0) {
-                // Some browsers return HTTP Status 0 when using non-http protocol
-                // e.g. 'file://' or 'data://'. Handle as success.
-                if (response.status === 0) {
-                    console.warn('FileLoader: HTTP Status 0 received.');
-                }
-                if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
-                    return response;
-                }
-                const callbacks = loading[url];
-                const reader = response.body.getReader();
-                const contentLength = response.headers.get('Content-Length');
-                const total = contentLength ? parseInt(contentLength) : 0;
-                const lengthComputable = total !== 0;
-                let loaded = 0;
-                const stream = new ReadableStream({
-                    start(controller) {
-                        readData();
-
-                        function readData() {
-                            reader.read().then(({done, value}) => {
-                                if (done) {
-                                    controller.close();
-                                } else {
-                                    loaded += value.byteLength;
-                                    const event = new ProgressEvent('progress', {lengthComputable, loaded, total});
-                                    for (let i = 0, il = callbacks.length; i < il; i++) {
-                                        const callback = callbacks[i];
-                                        if (callback.onProgress) {
-                                            callback.onProgress(event);
-                                        }
-                                    }
-                                    controller.enqueue(value);
-                                    readData();
-                                }
-                            });
-                        }
-                    }
-                });
-                return new Response(stream);
-            } else {
-                throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
-            }
-        }).then(response => {
-            switch (responseType) {
-                case 'arraybuffer':
-                    return response.arrayBuffer();
-                case 'blob':
-                    return response.blob();
-                case 'document':
-                    return response.text()
-                        .then(text => {
-                            const parser = new DOMParser();
-                            return parser.parseFromString(text, mimeType);
-                        });
-                case 'json':
-                    return response.json();
-                default:
-                    if (mimeType === undefined) {
-                        return response.text();
-                    } else {
-                        // sniff encoding
-                        const re = /charset="?([^;"\s]*)"?/i;
-                        const exec = re.exec(mimeType);
-                        const label = exec && exec[1] ? exec[1].toLowerCase() : undefined;
-                        const decoder = new TextDecoder(label);
-                        return response.arrayBuffer().then(ab => decoder.decode(ab));
-                    }
-            }
-        }).then(data => {
-            // Add to cache only on HTTP success, so that we do not cache
-            // error response bodies as proper responses to requests.
-            Cache.add(url, data);
-            const callbacks = loading[url];
-            delete loading[url];
-            for (let i = 0, il = callbacks.length; i < il; i++) {
-                const callback = callbacks[i];
-                if (callback.onLoad) {
-                    callback.onLoad(data);
-                }
-            }
-        }).catch(err => {
-            // Abort errors and other errors are handled the same
-            const callbacks = loading[url];
-            if (callbacks === undefined) {
-                // When onLoad was called and url was deleted in `loading`
-                this.manager.itemError(url);
-                throw err;
-
-            }
-            delete loading[url];
-            for (let i = 0, il = callbacks.length; i < il; i++) {
-                const callback = callbacks[i];
-                if (callback.onError) {
-                    callback.onError(err);
-                }
-            }
-            this.manager.itemError(url);
-        }).finally(() => {
-            this.manager.itemEnd(url);
-        });
-        this.manager.itemStart(url);
-    }
-
-    setResponseType(value) {
-        this.responseType = value;
-        return this;
-    }
-
-    setMimeType(value) {
-        this.mimeType = value;
-        return this;
-    }
-}
-
-const KTX2TransferSRGB = 2;
-const KTX2_ALPHA_PREMULTIPLIED = 1;
-
-let activeTranscoders = 0;
-
-/**
- * Transcodes texture data from KTX2.
- *
- * ## Overview
- *
- * * Uses the Basis Universal codec to transcode KTX2 texture assets.
- * * An {@link XKTLoaderPlugin} that is configured with a KTX2TextureTranscoder will allow us to load KTX2 textures in
- * XKT files. Textures in XKT are always KTX2. If we do not configure a KTX2TextureTranscoder, the XKTLoaderPlugin will
- * simply ignore the textures in the XKT.
- * * A {@link SceneModel} implementation (eg. {@link VBOSceneModel}) that is configured with a KTX2TextureTranscoder will
- * allow us to load textures into it from KTX2 files or ArrayBuffers.
- *
- * ## What is KTX2?
- *
- * A KTX2 file stores GPU texture data in the Khronos Texture 2.0 (KTX2) container format. It contains image data for
- * a texture asset compressed with Basis Universal (BasisU) supercompression that can be transcoded to different formats
- * depending on the support provided by the target devices. KTX2 provides a lightweight format for distributing texture
- * assets to GPUs. Due to BasisU compression, KTX2 files can store any image format supported by GPUs.
- *
- * ## Loading XKT files containing KTX2 textures
- *
- * An {@link XKTLoaderPlugin} that is configured with a KTX2TextureTranscoder will allow us to load XKT files that
- * contain KTX2 textures. If we don't configure a KTX2TextureTranscoder, then the XKTLoaderPlugin will simply ignore
- * the textures in the XKT.
- *
- * In the example below, we'll create a {@link Viewer} and add an {@link XKTLoaderPlugin}
- * configured with a KTX2TextureTranscoder. Then we'll use the XKTLoaderPlugin to load an
- * XKT file that contains KTX2 textures, which the plugin will transcode using
- * its KTX2TextureTranscoder.
- *
- * ````javascript
- * const viewer = new Viewer({
- *     canvasId: "myCanvas",
- *     transparent: true
- * });
- *
- * viewer.camera.eye = [-2.56, 8.38, 8.27];
- * viewer.camera.look = [13.44, 3.31, -14.83];
- * viewer.camera.up = [0.10, 0.98, -0.14];
- *
- * const textureTranscoder = new KTX2TextureTranscoder({
- *     viewer,
- *     transcoderPath: "./../dist/basis/" // <------ Path to Basis Universal transcoder
- * });
- *
- * const xktLoader = new XKTLoaderPlugin(viewer, {
- *     textureTranscoder // <<------------- Transcodes KTX2 textures in XKT files
- * });
- *
- * const sceneModel = xktLoader.load({
- *     id: "myModel",
- *     src: "./HousePlan.xkt" // <<------ XKT file with KTX2 textures
- * });
- * ````
- *
- * ## Loading KTX2 files into a VBOSceneModel
- *
- * A {@link SceneModel} that is configured with a KTX2TextureTranscoder will
- * allow us to load textures into it from KTX2-transcoded buffers or files.
- *
- * In the example below, we'll create a {@link Viewer}, containing a {@link VBOSceneModel} configured with a
- * KTX2TextureTranscoder. We'll then programmatically create a simple object within the VBOSceneModel, consisting of
- * a single mesh with a texture loaded from a KTX2 file, which our VBOSceneModel internally transcodes, using
- * its KTX2TextureTranscoder. Note how we configure our KTX2TextureTranscoder with a path to the Basis Universal
- * transcoder WASM module.
- *
- * ````javascript
- * const viewer = new Viewer({
- *     canvasId: "myCanvas",
- *     transparent: true
- * });
- *
- * viewer.scene.camera.eye = [-21.80, 4.01, 6.56];
- * viewer.scene.camera.look = [0, -5.75, 0];
- * viewer.scene.camera.up = [0.37, 0.91, -0.11];
- *
- * const textureTranscoder = new KTX2TextureTranscoder({
- *     viewer,
- *     transcoderPath: "./../dist/basis/" // <------ Path to BasisU transcoder module
- * });
- *
- * const vboSceneModel = new VBOSceneModel(viewer.scene, {
- *      id: "myModel",
- *      textureTranscoder // <<-------------------- Configure model with our transcoder
- *  });
- *
- * vboSceneModel.createTexture({
- *      id: "myColorTexture",
- *      src: "../assets/textures/compressed/sample_uastc_zstd.ktx2" // <<----- KTX2 texture asset
- * });
- *
- * vboSceneModel.createTexture({
- *      id: "myMetallicRoughnessTexture",
- *      src: "../assets/textures/alpha/crosshatchAlphaMap.jpg" // <<----- JPEG texture asset
- * });
- *
- * vboSceneModel.createTextureSet({
- *      id: "myTextureSet",
- *      colorTextureId: "myColorTexture",
- *      metallicRoughnessTextureId: "myMetallicRoughnessTexture"
- *  });
- *
- * vboSceneModel.createMesh({
- *      id: "myMesh",
- *      textureSetId: "myTextureSet",
- *      primitive: "triangles",
- *      positions: [1, 1, 1, ...],
- *      normals: [0, 0, 1, 0, ...],
- *      uv: [1, 0, 0, ...],
- *      indices: [0, 1, 2, ...],
- *  });
- *
- * vboSceneModel.createEntity({
- *      id: "myEntity",
- *      meshIds: ["myMesh"]
- *  });
- *
- * vboSceneModel.finalize();
- * ````
- *
- * ## Loading KTX2 ArrayBuffers into a VBOSceneModel
- *
- * A {@link SceneModel} that is configured with a KTX2TextureTranscoder will allow us to load textures into
- * it from KTX2 ArrayBuffers.
- *
- * In the example below, we'll create a {@link Viewer}, containing a {@link VBOSceneModel} configured with a
- * KTX2TextureTranscoder. We'll then programmatically create a simple object within the VBOSceneModel, consisting of
- * a single mesh with a texture loaded from a KTX2 ArrayBuffer, which our VBOSceneModel internally transcodes, using
- * its KTX2TextureTranscoder.
- *
- * ````javascript
- * const viewer = new Viewer({
- *     canvasId: "myCanvas",
- *     transparent: true
- * });
- *
- * viewer.scene.camera.eye = [-21.80, 4.01, 6.56];
- * viewer.scene.camera.look = [0, -5.75, 0];
- * viewer.scene.camera.up = [0.37, 0.91, -0.11];
- *
- * const textureTranscoder = new KTX2TextureTranscoder({
- *     viewer,
- *     transcoderPath: "./../dist/basis/" // <------ Path to BasisU transcoder module
- * });
- *
- * const vboSceneModel = new VBOSceneModel(viewer.scene, {
- *      id: "myModel",
- *      textureTranscoder // <<-------------------- Configure model with our transcoder
- * });
- *
- * utils.loadArraybuffer("../assets/textures/compressed/sample_uastc_zstd.ktx2",(arrayBuffer) => {
- *
- *     vboSceneModel.createTexture({
- *         id: "myColorTexture",
- *         buffers: [arrayBuffer] // <<----- KTX2 texture asset
- *     });
- *
- *     vboSceneModel.createTexture({
- *         id: "myMetallicRoughnessTexture",
- *         src: "../assets/textures/alpha/crosshatchAlphaMap.jpg" // <<----- JPEG texture asset
- *     });
- *
- *     vboSceneModel.createTextureSet({
- *        id: "myTextureSet",
- *        colorTextureId: "myColorTexture",
- *        metallicRoughnessTextureId: "myMetallicRoughnessTexture"
- *     });
- *
- *     vboSceneModel.createMesh({
- *          id: "myMesh",
- *          textureSetId: "myTextureSet",
- *          primitive: "triangles",
- *          positions: [1, 1, 1, ...],
- *          normals: [0, 0, 1, 0, ...],
- *          uv: [1, 0, 0, ...],
- *          indices: [0, 1, 2, ...],
- *     });
- *
- *     vboSceneModel.createEntity({
- *         id: "myEntity",
- *         meshIds: ["myMesh"]
- *     });
- *
- *     vboSceneModel.finalize();
- * });
- * ````
- *
- * @implements {TextureTranscoder}
- */
-class KTX2TextureTranscoder {
-
-    /**
-     * Creates a new KTX2TextureTranscoder.
-     *
-     * @param {Viewer} viewer The Viewer that our KTX2TextureTranscoder will be used with. This KTX2TextureTranscoder
-     * must only be used to transcode textures for this Viewer. This is because the Viewer's capabilities will decide
-     * what target GPU formats this KTX2TextureTranscoder will transcode to.
-     * @param {String} transcoderPath Path to the Basis transcoder module that internally does the heavy lifting for our KTX2TextureTranscoder.
-     * @param {Number} [workerLimit] The maximum number of Workers to use for transcoding.
-     */
-    constructor({viewer, transcoderPath, workerLimit}) {
-
-        this._transcoderPath = transcoderPath;
-        this._transcoderBinary = null;
-        this._transcoderPending = null;
-        this._workerPool = new WorkerPool();
-        this._workerSourceURL = '';
-
-        if (workerLimit) {
-            this._workerPool.setWorkerLimit(workerLimit);
-        }
-
-        const viewerCapabilities = viewer.capabilities;
-
-        this._workerConfig = {
-            astcSupported: viewerCapabilities.astcSupported,
-            etc1Supported: viewerCapabilities.etc1Supported,
-            etc2Supported: viewerCapabilities.etc2Supported,
-            dxtSupported: viewerCapabilities.dxtSupported,
-            bptcSupported: viewerCapabilities.bptcSupported,
-            pvrtcSupported: viewerCapabilities.pvrtcSupported
-        };
-
-        this._supportedFileTypes = ["xkt2"];
-    }
-
-    _init() {
-        if (!this._transcoderPending) {
-            const jsLoader = new FileLoader();
-            jsLoader.setPath(this._transcoderPath);
-            jsLoader.setWithCredentials(this.withCredentials);
-            const jsContent = jsLoader.loadAsync('basis_transcoder.js');
-            const binaryLoader = new FileLoader();
-            binaryLoader.setPath(this._transcoderPath);
-            binaryLoader.setResponseType('arraybuffer');
-            binaryLoader.setWithCredentials(this.withCredentials);
-            const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm');
-            this._transcoderPending = Promise.all([jsContent, binaryContent])
-                .then(([jsContent, binaryContent]) => {
-                    const fn = KTX2TextureTranscoder.BasisWorker.toString();
-                    const body = [
-                        '/* constants */',
-                        'let _EngineFormat = ' + JSON.stringify(KTX2TextureTranscoder.EngineFormat),
-                        'let _TranscoderFormat = ' + JSON.stringify(KTX2TextureTranscoder.TranscoderFormat),
-                        'let _BasisFormat = ' + JSON.stringify(KTX2TextureTranscoder.BasisFormat),
-                        '/* basis_transcoder.js */',
-                        jsContent,
-                        '/* worker */',
-                        fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))
-                    ].join('\n');
-                    this._workerSourceURL = URL.createObjectURL(new Blob([body]));
-                    this._transcoderBinary = binaryContent;
-                    this._workerPool.setWorkerCreator(() => {
-                        const worker = new Worker(this._workerSourceURL);
-                        const transcoderBinary = this._transcoderBinary.slice(0);
-                        worker.postMessage({
-                            type: 'init',
-                            config: this._workerConfig,
-                            transcoderBinary
-                        }, [transcoderBinary]);
-                        return worker;
-                    });
-                });
-            if (activeTranscoders > 0) {
-                console.warn('KTX2TextureTranscoder: Multiple active KTX2TextureTranscoder may cause performance issues.' + ' Use a single KTX2TextureTranscoder instance, or call .dispose() on old instances.');
-            }
-            activeTranscoders++;
-        }
-        return this._transcoderPending;
-    }
-
-    /**
-     * Transcodes texture data from transcoded buffers into a {@link Texture2D}.
-     *
-     * @param {ArrayBuffer[]} buffers Transcoded texture data. Given as an array of buffers so that we can support multi-image textures, such as cube maps.
-     * @param {*} config Transcoding options.
-     * @param {Texture2D} texture The texture to load.
-     * @returns {Promise} Resolves when the texture has loaded.
-     */
-    transcode(buffers, texture, config = {}) {
-        return new Promise((resolve, reject) => {
-            const taskConfig = config;
-            this._init().then(() => {
-                return this._workerPool.postMessage({
-                    type: 'transcode',
-                    buffers,
-                    taskConfig: taskConfig
-                }, buffers);
-            }).then((e) => {
-                const transcodeResult = e.data;
-                const {mipmaps, width, height, format, type, error, dfdTransferFn, dfdFlags} = transcodeResult;
-                if (type === 'error') {
-                    return reject(error);
-                }
-                texture.setCompressedData({
-                    mipmaps,
-                    props: {
-                        format: format,
-                        minFilter: mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter,
-                        magFilter: mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter,
-                        encoding: dfdTransferFn === KTX2TransferSRGB ? sRGBEncoding : LinearEncoding,
-                        premultiplyAlpha : !!(dfdFlags & KTX2_ALPHA_PREMULTIPLIED)
-                    }
-                });
-                resolve();
-            });
-        });
-    }
-
-    /**
-     * Destroys this KTX2TextureTranscoder
-     */
-    destroy() {
-        URL.revokeObjectURL(this._workerSourceURL);
-        this._workerPool.destroy();
-        activeTranscoders--;
-    }
-}
-
-/**
- * @private
- */
-KTX2TextureTranscoder.BasisFormat = {
-    ETC1S: 0,
-    UASTC_4x4: 1
-};
-
-/**
- * @private
- */
-KTX2TextureTranscoder.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
-};
-
-/**
- * @private
- */
-KTX2TextureTranscoder.EngineFormat = {
-    RGBAFormat: RGBAFormat,
-    RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
-    RGBA_BPTC_Format: RGBA_BPTC_Format,
-    RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
-    RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
-    RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
-    RGB_ETC1_Format: RGB_ETC1_Format,
-    RGB_ETC2_Format: RGB_ETC2_Format,
-    RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
-    RGB_S3TC_DXT1_Format: RGB_S3TC_DXT1_Format
-};
-
-/* WEB WORKER */
-
-/**
- * @private
- * @constructor
- */
-KTX2TextureTranscoder.BasisWorker = function () {
-
-    let config;
-    let transcoderPending;
-    let BasisModule;
-
-    const EngineFormat = _EngineFormat; // eslint-disable-line no-undef
-    const TranscoderFormat = _TranscoderFormat; // eslint-disable-line no-undef
-    const BasisFormat = _BasisFormat; // eslint-disable-line no-undef
-
-    self.addEventListener('message', 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,
-                            dfdTransferFn,
-                            dfdFlags
-                        } = 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,
-                            dfdTransferFn,
-                            dfdFlags
-                        }, buffers);
-                    } catch (error) {
-                        console.error(`[KTX2TextureTranscoder.BasisWorker]: ${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); // eslint-disable-line no-undef
-        }).then(() => {
-            BasisModule.initializeBasis();
-            if (BasisModule.KTX2File === undefined) {
-                console.warn('KTX2TextureTranscoder: Please update Basis Universal transcoder.');
-            }
-        });
-    }
-
-    function transcode(buffer) {
-        const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer));
-
-        function cleanup() {
-            ktx2File.close();
-            ktx2File.delete();
-        }
-
-        if (!ktx2File.isValid()) {
-            cleanup();
-            throw new Error('KTX2TextureTranscoder: Invalid or unsupported .ktx2 file');
-        }
-        const basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S;
-        const width = ktx2File.getWidth();
-        const height = ktx2File.getHeight();
-        const levels = ktx2File.getLevels();
-        const hasAlpha = ktx2File.getHasAlpha();
-        const dfdTransferFn = ktx2File.getDFDTransferFunc();
-        const dfdFlags = ktx2File.getDFDFlags();
-        const {transcoderFormat, engineFormat} = getTranscoderFormat(basisFormat, width, height, hasAlpha);
-        if (!width || !height || !levels) {
-            cleanup();
-            throw new Error('KTX2TextureTranscoder: Invalid texture');
-        }
-        if (!ktx2File.startTranscoding()) {
-            cleanup();
-            throw new Error('KTX2TextureTranscoder: .startTranscoding failed');
-        }
-        const mipmaps = [];
-        for (let mip = 0; mip < levels; mip++) {
-            const levelInfo = ktx2File.getImageLevelInfo(mip, 0, 0);
-            const mipWidth = levelInfo.origWidth;
-            const mipHeight = levelInfo.origHeight;
-            const dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, 0, 0, transcoderFormat));
-            const status = ktx2File.transcodeImage(dst, mip, 0, 0, transcoderFormat, 0, -1, -1);
-            if (!status) {
-                cleanup();
-                throw new Error('KTX2TextureTranscoder: .transcodeImage failed.');
-            }
-            mipmaps.push({data: dst, width: mipWidth, height: mipHeight});
-        }
-        cleanup();
-        return {width, height, hasAlpha, mipmaps, format: engineFormat, dfdTransferFn, dfdFlags};
-    }
-
-    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
-    // device capabilities, and texture dimensions. The list below ranks the formats separately
-    // for ETC1S and UASTC.
-    //
-    // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
-    // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
-    // chooses RGBA32 only as a last resort and does not expose that option to the caller.
-
-    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],
-        engineFormat: [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 (hasAlpha && opt.transcoderFormat.length < 2) 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('KTX2TextureTranscoder: No suitable compressed texture format found. Decoding to RGBA32.');
-        transcoderFormat = TranscoderFormat.RGBA32;
-        engineFormat = EngineFormat.RGBAFormat;
-        return {
-            transcoderFormat,
-            engineFormat
-        };
-    }
-
-    function isPowerOfTwo(value) {
-        if (value <= 2) return true;
-        return (value & value - 1) === 0 && value !== 0;
-    }
-};
-
 const screenPos = math.vec4();
 const viewPos = math.vec4();
 
@@ -161998,11 +162042,9 @@ class LASLoaderPlugin extends Plugin {
             try {
                 parse$3(arrayBuffer, LASLoader, options).then((parsedData) => {
 
-                    const loaderData = parsedData.loaderData;
-                    const loaderDataHeader = loaderData.header;
-                    const pointsFormatId = loaderDataHeader.pointsFormatId;
-
                     const attributes = parsedData.attributes;
+                    const loaderData = parsedData.loaderData;
+                    const pointsFormatId = loaderData.pointsFormatId !== undefined ? loaderData.pointsFormatId : -1;
 
                     if (!attributes.POSITION) {
                         sceneModel.finalize();
@@ -163333,7 +163375,7 @@ class CityJSONLoaderPlugin extends Plugin {
 
     _parseGeometrySurfacesWithSharedMaterial(ctx, geometry, objectMaterial, meshIds) {
 
-        ctx.performanceModel;
+        const sceneModel = ctx.sceneModel;
         const sharedIndices = [];
         const geometryCfg = {
             positions: [],
@@ -163379,7 +163421,7 @@ class CityJSONLoaderPlugin extends Plugin {
 
             const meshId = "" + ctx.nextId++;
 
-            performanceModel.createMesh({
+            sceneModel.createMesh({
                 id: meshId,
                 primitive: "triangles",
                 positions: geometryCfg.positions,
@@ -163599,6 +163641,7 @@ exports.NearestFilter = NearestFilter;
 exports.NearestMipMapLinearFilter = NearestMipMapLinearFilter;
 exports.NearestMipMapNearestFilter = NearestMipMapNearestFilter;
 exports.NearestMipmapLinearFilter = NearestMipmapLinearFilter;
+exports.NearestMipmapNearestFilter = NearestMipmapNearestFilter;
 exports.Node = Node$1;
 exports.OBJLoaderPlugin = OBJLoaderPlugin;
 exports.ObjectsMemento = ObjectsMemento;
@@ -163672,7 +163715,7 @@ exports.VBOSceneModel = VBOSceneModel;
 exports.ViewCullPlugin = ViewCullPlugin;
 exports.Viewer = Viewer;
 exports.WebIFCLoaderPlugin = WebIFCLoaderPlugin;
-exports.WorkerPool = WorkerPool;
+exports.WorkerPool = WorkerPool$1;
 exports.XKTDefaultDataSource = XKTDefaultDataSource;
 exports.XKTLoaderPlugin = XKTLoaderPlugin;
 exports.XML3DLoaderPlugin = XML3DLoaderPlugin;
@@ -163685,6 +163728,7 @@ exports.buildPlaneGeometry = buildPlaneGeometry;
 exports.buildSphereGeometry = buildSphereGeometry;
 exports.buildTorusGeometry = buildTorusGeometry;
 exports.buildVectorTextGeometry = buildVectorTextGeometry;
+exports.getKTX2TextureTranscoder = getKTX2TextureTranscoder;
 exports.load3DSGeometry = load3DSGeometry;
 exports.loadOBJGeometry = loadOBJGeometry;
 exports.math = math;