galacean · gz65555 · Mar 18, 2025 · Mar 18, 2025 · Mar 19, 2025 · Apr 20, 2025
diff --git a/cypress.config.ts b/cypress.config.ts
@@ -3,6 +3,7 @@ import { compare } from "odiff-bin";
 
 const path = require("path");
 const fs = require("fs-extra");
+const { ChildProcess, spawn } = require("child_process");
 
 const downloadDirectory = path.join(__dirname, "e2e/downloads");
 let isRunningInCommandLine = false;
@@ -19,9 +20,14 @@ export default defineConfig({
     videosFolder: "e2e/videos",
     specPattern: "e2e/tests/*.cy.ts",
     downloadsFolder: "e2e/downloads",
+    experimentalInteractiveRunEvents: true,
     video: false,
     setupNodeEvents(on, config) {
-      // implement node event listeners here
+      const server = spawn("npm", ["run", "e2e:case"], { stdio: "inherit" });
+      on("after:run", () => {
+        console.log("Shutting down test server...");
+        if (server) server.kill();
+      });
       on("before:browser:launch", (browser, launchOptions) => {
         console.log("launching browser %s is headless? %s", browser.name, browser.isHeadless);
         // supply the absolute path to an unpacked extension's folder
@@ -38,40 +44,41 @@ export default defineConfig({
           isRunningInCommandLine = true;
         }
         launchOptions.args.push("--force-device-scale-factor=1");
+
         return launchOptions;
-      }),
-        on("task", {
-          async compare({ fileName, options }) {
-            const baseFolder = "e2e/fixtures/originImage/";
-            const newFolder = path.join("e2e/downloads");
-            const diffFolder = path.join("e2e/diff", options.specFolder);
-            if (!fs.existsSync(diffFolder)) {
-              fs.mkdirSync(diffFolder, { recursive: true });
-            }
-            const baseImage = path.join(baseFolder, fileName);
-            const newImage = path.join(newFolder, fileName);
-            const diffImage = path.join(diffFolder, fileName);
-            console.log("comparing base image %s to the new image %s", baseImage, newImage);
-            if (options) {
-              console.log("odiff options %o", options);
-            }
-            const started = +new Date();
+      });
+      on("task", {
+        async compare({ fileName, options }) {
+          const baseFolder = "e2e/fixtures/originImage/";
+          const newFolder = path.join("e2e/downloads");
+          const diffFolder = path.join("e2e/diff", options.specFolder);
+          if (!fs.existsSync(diffFolder)) {
+            fs.mkdirSync(diffFolder, { recursive: true });
+          }
+          const baseImage = path.join(baseFolder, fileName);
+          const newImage = path.join(newFolder, fileName);
+          const diffImage = path.join(diffFolder, fileName);
+          console.log("comparing base image %s to the new image %s", baseImage, newImage);
+          if (options) {
+            console.log("odiff options %o", options);
+          }
+          const started = +new Date();
 
-            const result = await compare(baseImage, newImage, diffImage, options);
-            const finished = +new Date();
-            const elapsed = finished - started;
-            console.log("odiff took %dms", elapsed);
+          const result = await compare(baseImage, newImage, diffImage, options);
+          const finished = +new Date();
+          const elapsed = finished - started;
+          console.log("odiff took %dms", elapsed);
 
+          //@ts-ignore
+          if (result.match === false && result.diffPercentage <= 0.1) {
             //@ts-ignore
-            if (result.match === false && result.diffPercentage <= 0.1) {
-              //@ts-ignore
-              result.match = true;
-            }
-
-            console.log(result);
-            return result;
+            result.match = true;
           }
-        });
+
+          console.log(result);
+          return result;
+        }
+      });
     }
   },
   chromeWebSecurity: false

diff --git a/e2e/.dev/public/autumn_field_puresky_1k.ktx2 b/e2e/.dev/public/autumn_field_puresky_1k.ktx2
diff --git a/e2e/case/texture-hdr-ktx2.ts b/e2e/case/texture-hdr-ktx2.ts
@@ -0,0 +1,55 @@
+/**
+ * @title HDR KTX2
+ * @category Texture
+ */
+import {
+  BloomEffect,
+  Camera,
+  DirectLight,
+  Logger,
+  MeshRenderer,
+  PostProcess,
+  PrimitiveMesh,
+  Texture2D,
+  TonemappingEffect,
+  UnlitMaterial,
+  Vector3,
+  WebGLEngine
+} from "@galacean/engine";
+import { OrbitControl } from "@galacean/engine-toolkit";
+import { initScreenshot, updateForE2E } from "./.mockForE2E";
+
+Logger.enable();
+
+WebGLEngine.create({ canvas: "canvas", ktx2Loader: { workerCount: 0 } }).then((engine) => {
+  engine.canvas.resizeByClientSize(2);
+  const scene = engine.sceneManager.activeScene;
+  const rootEntity = scene.createRootEntity();
+
+  // camera
+  const cameraEntity = rootEntity.createChild("camera_node");
+  cameraEntity.transform.position = new Vector3(0, 1, 5);
+  const camera = cameraEntity.addComponent(Camera);
+  cameraEntity.addComponent(OrbitControl).target = new Vector3(0, 0, 0);
+
+  const lightNode = rootEntity.createChild("light_node");
+  lightNode.addComponent(DirectLight).intensity = 0.6;
+  lightNode.transform.lookAt(new Vector3(0, 0, 1));
+  lightNode.transform.rotate(new Vector3(0, 90, 0));
+
+  const planeEntity = rootEntity.createChild("plane");
+  const meshRenderer = planeEntity.addComponent(MeshRenderer);
+  meshRenderer.mesh = PrimitiveMesh.createCuboid(engine);
+  const mtl = new UnlitMaterial(engine);
+  meshRenderer.setMaterial(mtl);
+  const postProcess = rootEntity.addComponent(PostProcess);
+  postProcess.addEffect(BloomEffect);
+  postProcess.addEffect(TonemappingEffect);
+
+  engine.resourceManager.load<Texture2D>("/autumn_field_puresky_1k.ktx2").then((tex) => {
+    mtl.baseTexture = tex;
+    updateForE2E(engine);
+
+    initScreenshot(engine, camera);
+  });
+});
diff --git a/e2e/config.ts b/e2e/config.ts
@@ -146,6 +146,11 @@
       category: "Texture",
       caseFileName: "texture-R8G8",
       threshold: 0.1
+    },
+    KTX2HDR: {
+      category: "Texture",
+      caseFileName: "texture-hdr-ktx2",
+      threshold: 0.1
     }
   },
   Shadow: {

diff --git a/packages/core/src/texture/enums/TextureFormat.ts b/packages/core/src/texture/enums/TextureFormat.ts
@@ -24,13 +24,14 @@ export enum TextureFormat {
   R8 = 36,
   /** RG float format, 8 bits per channel. */
   R8G8 = 37,
-
   /** RGB compressed format, 4 bits per pixel. */
   BC1 = 10,
   /** RGBA compressed format, 8 bits per pixel. */
   BC3 = 11,
   /** RGB(A) compressed format, 128 bits per 4x4 pixel block. */
   BC7 = 12,
+  /** RGB HDR compressed format, 8 bits per pixel.. */
+  BC6H = 100,
   /** RGB compressed format, 4 bits per pixel. */
   ETC1_RGB = 13,
   /** RGB compressed format, 4 bits per pixel. */

diff --git a/packages/loader/src/index.ts b/packages/loader/src/index.ts
@@ -30,7 +30,7 @@ export * from "./SceneLoader";
 export type { Texture2DParams } from "./Texture2DLoader";
 export { parseSingleKTX } from "./compressed-texture";
 export * from "./gltf";
-export { KTX2Loader, KTX2Transcoder } from "./ktx2/KTX2Loader";
+export { KTX2Loader } from "./ktx2/KTX2Loader";
 export { KTX2TargetFormat } from "./ktx2/KTX2TargetFormat";
 export * from "./resource-deserialize";
 export * from "./prefab/PrefabResource";
diff --git a/packages/loader/src/ktx2/KTX2Container.ts b/packages/loader/src/ktx2/KTX2Container.ts
@@ -6,9 +6,10 @@ export enum DFDTransferFunction {
   sRGB = 2
 }
 
-enum ColorModel {
+export enum ColorModel {
   ETC1S = 163,
-  UASTC = 166
+  UASTC_LDR_4X4 = 166,
+  UASTC_HDR_4X4 = 167
 }
 
 export enum SupercompressionScheme {
@@ -52,8 +53,8 @@ export class KTX2Container {
     return this.dataFormatDescriptor.transferFunction === DFDTransferFunction.sRGB;
   }
 
-  get isUASTC() {
-    return this.dataFormatDescriptor.colorModel === ColorModel.UASTC;
+  get colorModel(): ColorModel {
+    return this.dataFormatDescriptor.colorModel;
   }
 
   private parse(data: Uint8Array) {

diff --git a/packages/loader/src/ktx2/KTX2Loader.ts b/packages/loader/src/ktx2/KTX2Loader.ts
@@ -15,32 +15,30 @@
   resourceLoader
 } from "@galacean/engine-core";
 import { MathUtil } from "@galacean/engine-math";
-import { DFDTransferFunction, KTX2Container } from "./KTX2Container";
+import { DFDTransferFunction, KTX2Container, ColorModel } from "./KTX2Container";
 import { KTX2TargetFormat } from "./KTX2TargetFormat";
 import { TranscodeResult } from "./transcoder/AbstractTranscoder";
 import { BinomialLLCTranscoder } from "./transcoder/BinomialLLCTranscoder";
-import { KhronosTranscoder } from "./transcoder/KhronosTranscoder";
 
 @resourceLoader(AssetType.KTX2, ["ktx2"])
 export class KTX2Loader extends Loader<Texture2D | TextureCube> {
-  private static _isBinomialInit: boolean = false;
   private static _binomialLLCTranscoder: BinomialLLCTranscoder;
-  private static _khronosTranscoder: KhronosTranscoder;
   private static _priorityFormats = {
-    etc1s: [
+    [ColorModel.ETC1S]: [
       KTX2TargetFormat.ETC,
       KTX2TargetFormat.BC7,
       KTX2TargetFormat.ASTC,
       KTX2TargetFormat.BC1_BC3,
       KTX2TargetFormat.PVRTC
     ],
-    uastc: [
+    [ColorModel.UASTC_LDR_4X4]: [
       KTX2TargetFormat.ASTC,
       KTX2TargetFormat.BC7,
       KTX2TargetFormat.ETC,
       KTX2TargetFormat.BC1_BC3,
       KTX2TargetFormat.PVRTC
-    ]
+    ],
+    [ColorModel.UASTC_HDR_4X4]: [KTX2TargetFormat.BC6H, KTX2TargetFormat.R16G16B16A16]
   };
   private static _capabilityMap = {
     [KTX2TargetFormat.ASTC]: {
@@ -59,6 +57,14 @@
       [DFDTransferFunction.linear]: [GLCapabilityType.s3tc],
       [DFDTransferFunction.sRGB]: [GLCapabilityType.s3tc_srgb]
     },
+    [KTX2TargetFormat.BC6H]: {
+      [DFDTransferFunction.linear]: [GLCapabilityType.bptc],
+      [DFDTransferFunction.sRGB]: [GLCapabilityType.bptc]
+    },
+    [KTX2TargetFormat.R16G16B16A16]: {
+      [DFDTransferFunction.linear]: [GLCapabilityType.textureHalfFloatLinear],
+      [DFDTransferFunction.sRGB]: [GLCapabilityType.textureHalfFloat]
+    },
     [KTX2TargetFormat.PVRTC]: { [DFDTransferFunction.linear]: [GLCapabilityType.pvrtc, GLCapabilityType.pvrtc_webkit] }
   };
 
@@ -68,35 +74,27 @@
    */
   static release(): void {
     if (this._binomialLLCTranscoder) this._binomialLLCTranscoder.destroy();
-    if (this._khronosTranscoder) this._khronosTranscoder.destroy();
     this._binomialLLCTranscoder = null;
-    this._khronosTranscoder = null;
-    this._isBinomialInit = false;
   }
 
   /** @internal */
   static _parseBuffer(buffer: Uint8Array, engine: Engine, params?: KTX2Params) {
     const ktx2Container = new KTX2Container(buffer);
-    const formatPriorities =
-      params?.priorityFormats ?? KTX2Loader._priorityFormats[ktx2Container.isUASTC ? "uastc" : "etc1s"];
+    const formatPriorities = params?.priorityFormats ?? KTX2Loader._priorityFormats[ktx2Container.colorModel];
     const targetFormat = KTX2Loader._decideTargetFormat(engine, ktx2Container, formatPriorities);
-    let transcodeResultPromise: Promise<TranscodeResult>;
-    if (KTX2Loader._isBinomialInit || !KhronosTranscoder.transcoderMap[targetFormat] || !ktx2Container.isUASTC) {
-      const binomialLLCWorker = KTX2Loader._getBinomialLLCTranscoder();
-      transcodeResultPromise = binomialLLCWorker.init().then(() => binomialLLCWorker.transcode(buffer, targetFormat));
-    } else {
-      const khronosWorker = KTX2Loader._getKhronosTranscoder();
-      transcodeResultPromise = khronosWorker.init().then(() => khronosWorker.transcode(ktx2Container));
-    }
-    return transcodeResultPromise.then((result) => {
-      return {
-        ktx2Container,
-        engine,
-        result,
-        targetFormat,
-        params: ktx2Container.keyValue["GalaceanTextureParams"] as Uint8Array
-      };
-    });
+    const binomialLLCWorker = KTX2Loader._getBinomialLLCTranscoder();
+    return binomialLLCWorker
+      .init()
+      .then(() => binomialLLCWorker.transcode(buffer, targetFormat))
+      .then((result) => {
+        return {
+          ktx2Container,
+          engine,
+          result,
+          targetFormat,
+          params: ktx2Container.keyValue["GalaceanTextureParams"] as Uint8Array
+        };
+      });
   }
 
   /** @internal */
@@ -190,14 +188,9 @@
   }
 
   private static _getBinomialLLCTranscoder(workerCount: number = 4) {
-    KTX2Loader._isBinomialInit = true;
     return (this._binomialLLCTranscoder ??= new BinomialLLCTranscoder(workerCount));
   }
 
-  private static _getKhronosTranscoder(workerCount: number = 4) {
-    return (this._khronosTranscoder ??= new KhronosTranscoder(workerCount, KTX2TargetFormat.ASTC));
-  }
-
   private static _getEngineTextureFormat(
     basisFormat: KTX2TargetFormat,
     transcodeResult: TranscodeResult
@@ -216,6 +209,10 @@
         return hasAlpha ? TextureFormat.PVRTC_RGBA4 : TextureFormat.PVRTC_RGB4;
       case KTX2TargetFormat.R8G8B8A8:
         return TextureFormat.R8G8B8A8;
+      case KTX2TargetFormat.BC6H:
+        return TextureFormat.BC6H;
+      case KTX2TargetFormat.R16G16B16A16:
+        return TextureFormat.R16G16B16A16;
     }
   }
 
@@ -227,11 +224,7 @@
         KTX2Loader._priorityFormats["uastc"] = options.priorityFormats;
       }
 
-      if (options.transcoder === KTX2Transcoder.Khronos) {
-        return KTX2Loader._getKhronosTranscoder(options.workerCount).init();
-      } else {
-        return KTX2Loader._getBinomialLLCTranscoder(options.workerCount).init();
-      }
+      return KTX2Loader._getBinomialLLCTranscoder(options.workerCount).init();
     }
   }
 
@@ -268,14 +261,6 @@
   priorityFormats: KTX2TargetFormat[];
 }
 
-/** Used for initialize KTX2 transcoder. */
-export enum KTX2Transcoder {
-  /** BinomialLLC transcoder. */
-  BinomialLLC,
-  /** Khronos transcoder. */
-  Khronos
-}
-
 declare module "@galacean/engine-core" {
   interface EngineConfiguration {
     /** KTX2 loader options. If set this option and workCount is great than 0, workers will be created. */
@@ -285,8 +270,6 @@
       /** Global transcoding format queue which will be used if not specified in per-instance param, default is BC7/ASTC/BC3_BC1/ETC/PVRTC/R8G8B8A8. */
       /** @deprecated */
       priorityFormats?: KTX2TargetFormat[];
-      /** Used for initialize KTX2 transcoder, default is BinomialLLC. */
-      transcoder?: KTX2Transcoder;
     };
   }
 }
diff --git a/packages/loader/src/ktx2/KTX2TargetFormat.ts b/packages/loader/src/ktx2/KTX2TargetFormat.ts
@@ -17,5 +17,9 @@ export enum KTX2TargetFormat {
   /** RG format, 16 bits per pixel. */
   R8G8,
   /** RGBA format, 32 bits per pixel. */
-  R8G8B8A8
+  R8G8B8A8,
+  /** RGB HDR compressed format, 8 bits per pixel. */
+  BC6H,
+  /** RGBA format, 16 bits per channel. */
+  R16G16B16A16
 }