More work

src/Misc/KTX2/LiteTranscoder.ts

@@ -2,8 +2,11 @@ import { Nullable } from '../../types';
 import { Tools } from '../tools';
 import { Transcoder, sourceTextureFormat, transcodeTarget } from './transcoder';
 import { WASMMemoryManager } from './wasmMemoryManager';
-import { IKTX2_SupercompressionGlobalData, IKTX2_ImageDesc } from './KTX2FileReader';
+import { KTX2FileReader, IKTX2_ImageDesc } from './KTX2FileReader';
 
+/**
+ * @hidden
+ */
 export class LiteTranscoder extends Transcoder {
 
     private _modulePath: string;
@@ -42,7 +45,7 @@ export class LiteTranscoder extends Transcoder {
         this._memoryManager = memoryMgr;
     }
 
-    public transcode(src: sourceTextureFormat, dst: transcodeTarget, level: number, width: number, height: number, levelUncompressedByteLength: number, hasAlpha: boolean, sgd: IKTX2_SupercompressionGlobalData, imageDesc: Nullable<IKTX2_ImageDesc>, encodedData: Uint8Array): Promise<Nullable<Uint8Array>> {
+    public transcode(src: sourceTextureFormat, dst: transcodeTarget, level: number, width: number, height: number, uncompressedByteLength: number, ktx2Reader: KTX2FileReader, imageDesc: Nullable<IKTX2_ImageDesc>, encodedData: Uint8Array): Promise<Nullable<Uint8Array>> {
         return this._loadModule().then((moduleWrapper: any) => {
             const transcoder: any = moduleWrapper.module;
 

src/Misc/KTX2/khronosTextureContainer2.ts

@@ -62,14 +62,13 @@ export class KhronosTextureContainer2 {
         return transcoder;
     }
 
-    private async _createTexture(kfr: KTX2FileReader, internalTexture: InternalTexture) {
+    private async _createMipmaps(kfr: KTX2FileReader, internalTexture: InternalTexture) {
         /*await this.zstd.init();*/
 
         //var mipmaps = [];
-        var width = kfr.header.pixelWidth;
-        var height = kfr.header.pixelHeight;
-        var srcTexFormat = kfr.textureFormat;
-        var hasAlpha = kfr.hasAlpha;
+        const width = kfr.header.pixelWidth;
+        const height = kfr.header.pixelHeight;
+        const srcTexFormat = kfr.textureFormat;
 
         let targetFormat = transcodeTarget.BC7_M5_RGBA;
         let transcodedFormat = COMPRESSED_RGBA_BPTC_UNORM_EXT;
@@ -84,21 +83,21 @@ export class KhronosTextureContainer2 {
 
         let firstImageDescIndex = 0;
 
-        for (var level = 0; level < kfr.header.levelCount; level ++) {
+        for (let level = 0; level < kfr.header.levelCount; level ++) {
             if (level > 0) {
                 firstImageDescIndex += Math.max(kfr.header.layerCount, 1) * kfr.header.faceCount * Math.max(kfr.header.pixelDepth >> (level - 1), 1);
             }
 
-            var levelWidth = width / Math.pow(2, level);
-            var levelHeight = height / Math.pow(2, level);
+            const levelWidth = width / Math.pow(2, level);
+            const levelHeight = height / Math.pow(2, level);
 
-            var numImagesInLevel = 1; // kfr.header.faceCount
-            var imageOffsetInLevel = 0;
-            var levelByteLength = kfr.levels[level].byteLength;
-            var levelUncompressedByteLength = kfr.levels[level].uncompressedByteLength;
+            const numImagesInLevel = kfr.header.faceCount; // note that cubemap are not supported yet (see KTX2FileReader), so faceCount == 1
+            const levelByteLength = kfr.levels[level].byteLength;
+            const levelUncompressedByteLength = kfr.levels[level].uncompressedByteLength;
 
             let levelDataBuffer = kfr.data.buffer;
             let levelDataOffset = kfr.levels[level].byteOffset;
+            let imageOffsetInLevel = 0;
 
             if (kfr.header.supercompressionScheme === supercompressionScheme.ZStandard) {
                 //levelDataBuffer = this.zstd.decode(new Uint8Array(levelDataBuffer, levelDataOffset, levelByteLength), levelUncompressedByteLength);
@@ -107,7 +106,7 @@ export class KhronosTextureContainer2 {
 
             //const levelImageByteLength = imageInfo.numBlocksX * imageInfo.numBlocksY * DFD bytesPlane0;
 
-            for (var imageIndex = 0; imageIndex < numImagesInLevel; imageIndex ++) {
+            for (let imageIndex = 0; imageIndex < numImagesInLevel; imageIndex ++) {
                 let encodedData: Uint8Array;
                 let imageDesc: Nullable<IKTX2_ImageDesc> = null;
 
@@ -121,7 +120,7 @@ export class KhronosTextureContainer2 {
                     imageOffsetInLevel += levelByteLength;
                 }
 
-                texturePromises.push(transcoder.transcode(srcTexFormat, targetFormat, level, levelWidth, levelHeight, levelUncompressedByteLength, hasAlpha, kfr.supercompressionGlobalData, imageDesc, encodedData));
+                texturePromises.push(transcoder.transcode(srcTexFormat, targetFormat, level, levelWidth, levelHeight, levelUncompressedByteLength, kfr, imageDesc, encodedData));
             }
         }
 
@@ -158,8 +157,7 @@ export class KhronosTextureContainer2 {
     public uploadAsync(data: ArrayBufferView, internalTexture: InternalTexture): Promise<void> {
         const kfr = new KTX2FileReader(data);
 
-        return this._createTexture(kfr, internalTexture);
-
+        return this._createMipmaps(kfr, internalTexture);
     }
 
     /**

src/Misc/KTX2/mscTranscoder.ts

@@ -1,6 +1,6 @@
 import { Nullable } from '../../types';
 import { Transcoder, sourceTextureFormat, transcodeTarget } from './transcoder';
-import { IKTX2_SupercompressionGlobalData, IKTX2_ImageDesc } from './KTX2FileReader';
+import { KTX2FileReader, IKTX2_ImageDesc } from './KTX2FileReader';
 
 declare var MSC_TRANSCODER: any;
 
@@ -32,8 +32,9 @@ export class MSCTranscoder extends Transcoder {
         return true;
     }
 
-    public transcode(src: sourceTextureFormat, dst: transcodeTarget, level: number, width: number, height: number, levelUncompressedByteLength: number, hasAlpha: boolean, sgd: IKTX2_SupercompressionGlobalData, imageDesc: Nullable<IKTX2_ImageDesc>, encodedData: Uint8Array): Promise<Nullable<Uint8Array>> {
+    public transcode(src: sourceTextureFormat, dst: transcodeTarget, level: number, width: number, height: number, uncompressedByteLength: number, ktx2Reader: KTX2FileReader, imageDesc: Nullable<IKTX2_ImageDesc>, encodedData: Uint8Array): Promise<Nullable<Uint8Array>> {
         const isVideo = false;
+
         return this._getMSCBasisTranscoder().then(() => {
             const basisModule = this._mscBasisModule;
 
@@ -41,10 +42,10 @@ export class MSCTranscoder extends Transcoder {
             const TextureFormat: any = basisModule.TextureFormat;
             const ImageInfo: any = basisModule.ImageInfo;
 
-            var transcoder = src === sourceTextureFormat.UASTC4x4 ? new basisModule.UastcImageTranscoder() : new basisModule.BasisLzEtc1sImageTranscoder();
-            var texFormat = src === sourceTextureFormat.UASTC4x4 ? TextureFormat.UASTC4x4 : TextureFormat.ETC1S;
+            const transcoder = src === sourceTextureFormat.UASTC4x4 ? new basisModule.UastcImageTranscoder() : new basisModule.BasisLzEtc1sImageTranscoder();
+            const texFormat = src === sourceTextureFormat.UASTC4x4 ? TextureFormat.UASTC4x4 : TextureFormat.ETC1S;
 
-            var imageInfo = new ImageInfo(texFormat, width, height, level);
+            const imageInfo = new ImageInfo(texFormat, width, height, level);
 
             const targetFormat = TranscodeTarget[transcodeTarget[dst]]; // works because the labels of the sourceTextureFormat enum are the same than the property names used in TranscodeTarget!
 
@@ -55,14 +56,10 @@ export class MSCTranscoder extends Transcoder {
             let result: any;
 
             if (src === sourceTextureFormat.ETC1S) {
-                var numEndpoints = sgd.endpointCount;
-                var numSelectors = sgd.selectorCount;
-                var endpoints = sgd.endpointsData;
-                var selectors = sgd.selectorsData;
-                var tables = sgd.tablesData;
+                const sgd = ktx2Reader.supercompressionGlobalData;
 
-                transcoder.decodePalettes(numEndpoints, endpoints, numSelectors, selectors);
-                transcoder.decodeTables(tables);
+                transcoder.decodePalettes(sgd.endpointCount, sgd.endpointsData, sgd.selectorCount, sgd.selectorsData);
+                transcoder.decodeTables(sgd.tablesData);
 
                 imageInfo.flags = imageDesc!.imageFlags;
                 imageInfo.rgbByteOffset = 0;
@@ -74,11 +71,11 @@ export class MSCTranscoder extends Transcoder {
             } else {
                 imageInfo.flags = 0;
                 imageInfo.rgbByteOffset = 0;
-                imageInfo.rgbByteLength = levelUncompressedByteLength;
+                imageInfo.rgbByteLength = uncompressedByteLength;
                 imageInfo.alphaByteOffset = 0;
                 imageInfo.alphaByteLength = 0;
 
-                result = transcoder.transcodeImage(targetFormat, encodedData, imageInfo, 0, hasAlpha, isVideo);
+                result = transcoder.transcodeImage(targetFormat, encodedData, imageInfo, 0, ktx2Reader.hasAlpha, isVideo);
             }
 
             if (result && result.transcodedImage !== undefined) {
@@ -90,4 +87,4 @@ export class MSCTranscoder extends Transcoder {
             return null;
         });
     }
-}
+}

src/Misc/KTX2/transcoder.ts

@@ -1,6 +1,6 @@
 import { Nullable } from '../../types';
 import { WASMMemoryManager } from './wasmMemoryManager';
-import { IKTX2_SupercompressionGlobalData, IKTX2_ImageDesc } from './KTX2FileReader';
+import { KTX2FileReader, IKTX2_ImageDesc } from './KTX2FileReader';
 
 /**
  * @hidden
@@ -44,7 +44,7 @@ export class Transcoder {
     public setMemoryManager(memoryMgr: WASMMemoryManager): void {
     }
 
-    public transcode(src: sourceTextureFormat, dst: transcodeTarget, level: number, width: number, height: number, levelUncompressedByteLength: number, hasAlpha: boolean, sgd: IKTX2_SupercompressionGlobalData, imageDesc: Nullable<IKTX2_ImageDesc>, encodedData: Uint8Array): Promise<Nullable<Uint8Array>> {
+    public transcode(src: sourceTextureFormat, dst: transcodeTarget, level: number, width: number, height: number, uncompressedByteLength: number, ktx2Reader: KTX2FileReader, imageDesc: Nullable<IKTX2_ImageDesc>, encodedData: Uint8Array): Promise<Nullable<Uint8Array>> {
         return Promise.resolve(null);
     }
 }