@galacean/engine-loader 1.0.0-beta.9 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-loader",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.1",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -15,10 +15,10 @@
     "types/**/*"
   ],
   "dependencies": {
-    "@galacean/engine-core": "1.0.0-beta.9",
-    "@galacean/engine-draco": "1.0.0-beta.9",
-    "@galacean/engine-math": "1.0.0-beta.9",
-    "@galacean/engine-rhi-webgl": "1.0.0-beta.9"
+    "@galacean/engine-core": "1.0.1",
+    "@galacean/engine-draco": "1.0.1",
+    "@galacean/engine-rhi-webgl": "1.0.1",
+    "@galacean/engine-math": "1.0.1"
   },
   "scripts": {
     "b:types": "tsc"

package/types/GLTFContentRestorer.d.ts

@@ -1,8 +1,8 @@
-import { AssetPromise, BlendShape, Buffer, ContentRestorer, ModelMesh, Texture2D } from "@galacean/engine-core";
+import { AssetPromise, BlendShape, Buffer, ContentRestorer, ModelMesh, Texture2D, TypedArray } from "@galacean/engine-core";
 import { RequestConfig } from "@galacean/engine-core/types/asset/request";
 import { Vector2 } from "@galacean/engine-math";
 import { GLTFResource } from "./gltf/GLTFResource";
-import { IBufferView } from "./gltf/GLTFSchema";
+import type { IBufferView } from "./gltf/GLTFSchema";
 /**
  * @internal
  */
@@ -65,18 +65,28 @@ export declare class BufferDataRestoreInfo {
  */
 export declare class RestoreDataAccessor {
     bufferIndex: number;
-    TypedArray: new (buffer: ArrayBuffer, byteOffset: number, length?: number) => ArrayBufferView;
+    TypedArray: new (buffer: ArrayBuffer, byteOffset: number, length?: number) => TypedArray;
     byteOffset: number;
     length: number;
-    constructor(bufferIndex: number, TypedArray: new (buffer: ArrayBuffer, byteOffset: number, length?: number) => ArrayBufferView, byteOffset: number, length: number);
+    constructor(bufferIndex: number, TypedArray: new (buffer: ArrayBuffer, byteOffset: number, length?: number) => TypedArray, byteOffset: number, length: number);
 }
 /**
  * @internal
  */
 export declare class BlendShapeRestoreInfo {
     blendShape: BlendShape;
-    position: BufferDataRestoreInfo;
-    normal?: BufferDataRestoreInfo;
-    tangent?: BufferDataRestoreInfo;
-    constructor(blendShape: BlendShape, position: BufferDataRestoreInfo, normal?: BufferDataRestoreInfo, tangent?: BufferDataRestoreInfo);
+    position: BlendShapeDataRestoreInfo;
+    normal?: BlendShapeDataRestoreInfo;
+    tangent?: BlendShapeDataRestoreInfo;
+    constructor(blendShape: BlendShape, position: BlendShapeDataRestoreInfo, normal?: BlendShapeDataRestoreInfo, tangent?: BlendShapeDataRestoreInfo);
+}
+/**
+ * @internal
+ */
+export declare class BlendShapeDataRestoreInfo {
+    buffer: BufferDataRestoreInfo;
+    stride: number;
+    byteOffset: number;
+    count: number;
+    constructor(buffer: BufferDataRestoreInfo, stride: number, byteOffset: number, count: number);
 }

package/types/ProjectLoader.d.ts

@@ -0,0 +1 @@
+export {};

package/types/gltf/GLTFResource.d.ts

@@ -1,8 +1,8 @@
-import { AnimationClip, Camera, Engine, EngineObject, Entity, Light, Material, ModelMesh, Skin, Texture2D } from "@galacean/engine-core";
+import { AnimationClip, Camera, Engine, Entity, Light, Material, ModelMesh, ReferResource, Skin, Texture2D } from "@galacean/engine-core";
 /**
  * Product after glTF parser, usually, `defaultSceneRoot` is only needed to use.
  */
-export declare class GLTFResource extends EngineObject {
+export declare class GLTFResource extends ReferResource {
     /** glTF file url. */
     url: string;
     /** Texture2D after TextureParser. */
@@ -28,8 +28,4 @@ export declare class GLTFResource extends EngineObject {
     /** Extensions data. */
     extensionsData: Record<string, any>;
     constructor(engine: Engine, url: string);
-    /**
-     * @internal
-     */
-    protected _onDestroy(): void;
 }

package/types/gltf/GLTFUtil.d.ts

@@ -1,7 +1,7 @@
 import { IndexFormat, TypedArray, VertexElementFormat } from "@galacean/engine-core";
 import { Color, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
-import { BufferInfo, ParserContext } from "./parser/ParserContext";
-import { AccessorComponentType, AccessorType, IAccessor, IBufferView, IGLTF } from "./Schema";
+import { AccessorComponentType, AccessorType, IAccessor, IBufferView, IGLTF } from "./GLTFSchema";
+import { BufferInfo, GLTFParserContext } from "./parser/GLTFParserContext";
 /**
  * @internal
  */
@@ -23,7 +23,7 @@ export declare class GLTFUtil {
      */
     static getComponentType(componentType: AccessorComponentType): Int8ArrayConstructor | Uint8ArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor;
     static getNormalizedComponentScale(componentType: AccessorComponentType): number;
-    static getAccessorBuffer(context: ParserContext, gltf: IGLTF, accessor: IAccessor): BufferInfo;
+    static getAccessorBuffer(context: GLTFParserContext, gltf: IGLTF, accessor: IAccessor): BufferInfo;
     /**
      * @deprecated
      * Get accessor data.

package/types/gltf/GLTFUtils.d.ts

@@ -17,9 +17,10 @@ export declare class GLTFUtils {
     /**
      * Get the TypedArray corresponding to the component type.
      */
-    static getComponentType(componentType: AccessorComponentType): Uint8ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor;
+    static getComponentType(componentType: AccessorComponentType): Float32ArrayConstructor | Uint32ArrayConstructor | Uint8ArrayConstructor | Uint16ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor;
     static getNormalizedComponentScale(componentType: AccessorComponentType): number;
-    static getAccessorBuffer(context: GLTFParserContext, bufferViews: IBufferView[], accessor: IAccessor): BufferInfo;
+    static getAccessorBuffer(context: GLTFParserContext, bufferViews: IBufferView[], accessor: IAccessor): Promise<BufferInfo>;
+    static bufferToVector3Array(data: TypedArray, byteStride: number, accessorByteOffset: number, count: number): Vector3[];
     /**
      * @deprecated
      * Get accessor data.

package/types/gltf/extensions/GLTFExtensionSchema.d.ts

@@ -1,4 +1,4 @@
-import { IMaterialNormalTextureInfo, ITextureInfo } from "../GLTFSchema";
+import type { IMaterialNormalTextureInfo, ITextureInfo } from "../GLTFSchema";
 /**
  * Interfaces from the KHR_lights_punctual extension
  */

package/types/gltf/parser/GLTFAnimationParser.d.ts

@@ -6,7 +6,7 @@ export declare class GLTFAnimationParser extends GLTFParser {
     /**
      * @internal
      */
-    static _parseStandardProperty(context: GLTFParserContext, animationClip: AnimationClip, animationInfo: IAnimation): void;
+    static _parseStandardProperty(context: GLTFParserContext, animationClip: AnimationClip, animationInfo: IAnimation): Promise<void>;
     private static _addCurve;
-    parse(context: GLTFParserContext): AssetPromise<AnimationClip[]>;
+    parse(context: GLTFParserContext): AssetPromise<AnimationClip[]> | void;
 }

package/types/gltf/parser/GLTFMeshParser.d.ts

@@ -1,6 +1,6 @@
 import { AssetPromise, ModelMesh, TypedArray } from "@galacean/engine-core";
 import { ModelMeshRestoreInfo } from "../../GLTFContentRestorer";
-import { IGLTF, IMesh, IMeshPrimitive } from "../GLTFSchema";
+import type { IAccessor, IGLTF, IMesh, IMeshPrimitive } from "../GLTFSchema";
 import { GLTFParser } from "./GLTFParser";
 import { BufferInfo, GLTFParserContext } from "./GLTFParserContext";
 export declare class GLTFMeshParser extends GLTFParser {
@@ -8,12 +8,12 @@ export declare class GLTFMeshParser extends GLTFParser {
     /**
      * @internal
      */
-    static _parseMeshFromGLTFPrimitive(context: GLTFParserContext, mesh: ModelMesh, meshRestoreInfo: ModelMeshRestoreInfo, gltfMesh: IMesh, gltfPrimitive: IMeshPrimitive, gltf: IGLTF, getVertexBufferData: (semantic: string) => TypedArray, getBlendShapeData: (semantic: string, shapeIndex: number) => BufferInfo, getIndexBufferData: () => TypedArray, keepMeshData: boolean): Promise<ModelMesh>;
+    static _parseMeshFromGLTFPrimitive(context: GLTFParserContext, mesh: ModelMesh, meshRestoreInfo: ModelMeshRestoreInfo, gltfMesh: IMesh, gltfPrimitive: IMeshPrimitive, gltf: IGLTF, getVertexBufferData: (semantic: string) => TypedArray, getBlendShapeData: (semantic: string, shapeIndex: number) => Promise<BufferInfo>, getIndexBufferData: () => Promise<TypedArray>, keepMeshData: boolean): Promise<ModelMesh>;
     /**
      * @internal
      */
-    static _createBlendShape(mesh: ModelMesh, meshRestoreInfo: ModelMeshRestoreInfo, glTFMesh: IMesh, glTFTargets: {
+    static _createBlendShape(mesh: ModelMesh, meshRestoreInfo: ModelMeshRestoreInfo, glTFMesh: IMesh, accessors: IAccessor[], glTFTargets: {
         [name: string]: number;
-    }[], getBlendShapeData: (semantic: string, shapeIndex: number) => BufferInfo): void;
-    parse(context: GLTFParserContext): AssetPromise<ModelMesh[][]>;
+    }[], getBlendShapeData: (semantic: string, shapeIndex: number) => Promise<BufferInfo>): Promise<void[]>;
+    parse(context: GLTFParserContext): AssetPromise<ModelMesh[][]> | void;
 }

package/types/gltf/parser/GLTFParser.d.ts

@@ -1,6 +1,6 @@
 import { AnimationClip, AssetPromise, EngineObject, Material, Mesh } from "@galacean/engine-core";
 import { GLTFExtensionMode, GLTFExtensionParser } from "../extensions/GLTFExtensionParser";
-import { GLTFExtensionOwnerSchema } from "../GLTFSchema";
+import type { GLTFExtensionOwnerSchema } from "../GLTFSchema";
 import { GLTFParserContext } from "./GLTFParserContext";
 /**
  * Base class of glTF parser.

package/types/gltf/parser/GLTFParserContext.d.ts

@@ -1,13 +1,12 @@
 import { AnimationClip, AssetPromise, Buffer, Entity, Material, ModelMesh, Texture2D, TypedArray } from "@galacean/engine-core";
 import { BufferDataRestoreInfo, GLTFContentRestorer } from "../../GLTFContentRestorer";
 import { GLTFResource } from "../GLTFResource";
-import { IGLTF } from "../GLTFSchema";
+import type { IGLTF } from "../GLTFSchema";
 /**
  * @internal
  */
 export declare class GLTFParserContext {
     glTF: IGLTF;
-    buffers: ArrayBuffer[];
     glTFResource: GLTFResource;
     keepMeshData: boolean;
     hasSkinned: boolean;
@@ -21,7 +20,13 @@ export declare class GLTFParserContext {
     masterPromiseInfo: PromiseInfo<GLTFResource>;
     promiseMap: Record<string, AssetPromise<any>>;
     contentRestorer: GLTFContentRestorer;
+    /** @internal */
+    _buffers: ArrayBuffer[] | Promise<ArrayBuffer[]>;
     constructor(url: string);
+    /**
+     * Get all the buffer data.
+     */
+    getBuffers(): Promise<ArrayBuffer[]>;
     private _initPromiseInfo;
 }
 /**

package/types/gltf/parser/GLTFSceneParser.d.ts

@@ -1,10 +1,10 @@
-import { Entity } from "@galacean/engine-core";
+import { AssetPromise, Entity } from "@galacean/engine-core";
 import { GLTFParser } from "./GLTFParser";
 import { GLTFParserContext } from "./GLTFParserContext";
 export declare class GLTFSceneParser extends GLTFParser {
     private static _defaultMaterial;
     private static _getDefaultMaterial;
-    parse(context: GLTFParserContext): import("@galacean/engine-core").AssetPromise<Entity>;
+    parse(context: GLTFParserContext): AssetPromise<Entity> | void;
     private _createCamera;
     private _createRenderer;
     private _createAnimator;

package/types/gltf/parser/GLTFSchemaParser.d.ts

@@ -0,0 +1,7 @@
+import { IGLTF } from "../GLTFSchema";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFSchemaParser extends GLTFParser {
+    parse(context: GLTFParserContext): Promise<IGLTF>;
+    private _isGLB;
+}

package/types/gltf/parser/GLTFSkinParser.d.ts

@@ -1,6 +1,7 @@
+import { AssetPromise } from "@galacean/engine-core";
 import { GLTFParserContext } from ".";
 import { GLTFParser } from "./GLTFParser";
 export declare class GLTFSkinParser extends GLTFParser {
-    parse(context: GLTFParserContext): void;
+    parse(context: GLTFParserContext): AssetPromise<void>;
     private _findSkeletonRootBone;
 }

package/types/gltf/parser/GLTFTextureParser.d.ts

@@ -1,8 +1,9 @@
 import { AssetPromise, Texture2D } from "@galacean/engine-core";
-import { GLTFParser } from "./GLTFParser";
 import { GLTFParserContext } from ".";
+import { GLTFParser } from "./GLTFParser";
 export declare class GLTFTextureParser extends GLTFParser {
     private static _wrapMap;
-    parse(context: GLTFParserContext): AssetPromise<Texture2D[]>;
+    parse(context: GLTFParserContext): AssetPromise<Texture2D[]> | void;
+    private _getSamplerInfo;
     private _parseSampler;
 }

package/types/ktx2/BinomialLLCTranscoder/BinomialLLCTranscoder.d.ts

@@ -0,0 +1,13 @@
+import { KTX2TargetFormat } from "../KTX2TargetFormat";
+import { TranscodeResult } from "../TranscodeResult";
+/** @internal */
+export declare class BinomialLLCTranscoder {
+    readonly workerLimit: number;
+    static MessageId: number;
+    private _transcodeWorkerPool;
+    private _initPromise;
+    constructor(workerLimit: number);
+    init(): Promise<any>;
+    transcode(buffer: ArrayBuffer, format: KTX2TargetFormat): Promise<TranscodeResult>;
+    destroy(): void;
+}

package/types/ktx2/BinomialLLCTranscoder/TranscodeWorkerCode.d.ts

@@ -0,0 +1,33 @@
+type MessageType = "init" | "transcode";
+export interface IBaseMessage {
+    type: MessageType;
+}
+export interface IInitMessage extends IBaseMessage {
+    type: "init";
+    transcoderWasm: ArrayBuffer;
+}
+export interface ITranscodeMessage extends IBaseMessage {
+    type: "transcode";
+    format: number;
+    buffer: ArrayBuffer;
+}
+export type IMessage = IInitMessage | ITranscodeMessage;
+export type TranscodeResult = {
+    width: number;
+    height: number;
+    hasAlpha: boolean;
+    format: number;
+    faces: Array<{
+        data: Uint8Array;
+        width: number;
+        height: number;
+    }>[];
+    faceCount: number;
+};
+export type TranscodeResponse = {
+    id: number;
+    type: "transcoded";
+} & TranscodeResult;
+/** @internal */
+export declare function TranscodeWorkerCode(): void;
+export {};

package/types/ktx2/KTX2Container.d.ts

@@ -0,0 +1,72 @@
+export declare enum SupercompressionScheme {
+    None = 0,
+    BasisLZ = 1,
+    Zstd = 2,
+    ZLib = 3
+}
+/** @internal */
+export declare class KTX2Container {
+    vkFormat: number;
+    typeSize: number;
+    pixelWidth: number;
+    pixelHeight: number;
+    pixelDepth: number;
+    layerCount: number;
+    faceCount: number;
+    supercompressionScheme: SupercompressionScheme;
+    levels: KTX2Level[];
+    dataFormatDescriptor: KTX2DataFormatDescriptorBasicFormat;
+    keyValue: {
+        [key: string]: string | Uint8Array;
+    };
+    globalData: KTX2GlobalDataBasisLZ | null;
+    constructor(buffer: Uint8Array);
+    get isSRGB(): boolean;
+    get isUASTC(): boolean;
+    private parse;
+}
+interface KTX2Level {
+    levelData: Uint8Array;
+    uncompressedByteLength: number;
+}
+interface KTX2DataFormatDescriptorBasicFormat {
+    vendorId: number;
+    descriptorType: number;
+    versionNumber: number;
+    /** @deprecated Inferred. */
+    descriptorBlockSize: number;
+    colorModel: number;
+    colorPrimaries: number;
+    transferFunction: number;
+    flags: number;
+    texelBlockDimension: [number, number, number, number];
+    bytesPlane: [number, number, number, number, number, number, number, number];
+    samples: KTX2BasicFormatSample[];
+}
+interface KTX2BasicFormatSample {
+    bitOffset: number;
+    bitLength: number;
+    /** @deprecated Renamed to 'channelType'. */
+    channelID?: number;
+    channelType: number;
+    samplePosition: number[];
+    sampleLower: number;
+    sampleUpper: number;
+}
+interface KTX2GlobalDataBasisLZ {
+    endpointCount: number;
+    selectorCount: number;
+    imageDescs: KTX2GlobalDataBasisLZImageDesc[];
+    endpointsData: Uint8Array;
+    selectorsData: Uint8Array;
+    tablesData: Uint8Array;
+    extendedData: Uint8Array;
+}
+interface KTX2GlobalDataBasisLZImageDesc {
+    imageFlags: number;
+    rgbSliceByteOffset: number;
+    rgbSliceByteLength: number;
+    alphaSliceByteOffset: number;
+    alphaSliceByteLength: number;
+}
+export {};

package/types/ktx2/KTX2Loader.d.ts

@@ -0,0 +1,53 @@
+import { AssetPromise, Engine, EngineConfiguration, LoadItem, Loader, ResourceManager, Texture2D, TextureCube } from "@galacean/engine-core";
+import { KTX2TargetFormat } from "./KTX2TargetFormat";
+import { TranscodeResult } from "./transcoder/AbstractTranscoder";
+export declare class KTX2Loader extends Loader<Texture2D | TextureCube> {
+    private static _isBinomialInit;
+    private static _binomialLLCTranscoder;
+    private static _khronosTranscoder;
+    private static _supportedMap;
+    /**
+     * Destroy ktx2 transcoder worker.
+     */
+    static destroy(): void;
+    /** @internal */
+    static _parseBuffer(buffer: Uint8Array, engine: Engine, params?: KTX2Params): Promise<{
+        engine: Engine;
+        result: TranscodeResult;
+        targetFormat: KTX2TargetFormat;
+        params: Uint8Array;
+    }>;
+    /** @internal */
+    static _createTextureByBuffer(engine: Engine, transcodeResult: TranscodeResult, targetFormat: KTX2TargetFormat, params?: Uint8Array): Texture2D | TextureCube;
+    private static _decideTargetFormat;
+    private static _detectSupportedFormat;
+    private static _getBinomialLLCTranscoder;
+    private static _getKhronosTranscoder;
+    private static _getEngineTextureFormat;
+    initialize(engine: Engine, configuration: EngineConfiguration): Promise<void>;
+    /**
+     * @internal
+     */
+    load(item: LoadItem & {
+        params?: KTX2Params;
+    }, resourceManager: ResourceManager): AssetPromise<Texture2D | TextureCube>;
+    private _isKhronosSupported;
+}
+/**
+ * KTX2 loader params interface.
+ */
+export interface KTX2Params {
+    /** Priority transcoding format queue, default is ASTC/ETC/DXT/PVRTC/RGBA8. */
+    priorityFormats: KTX2TargetFormat[];
+}
+declare module "@galacean/engine-core" {
+    interface EngineConfiguration {
+        /** KTX2 loader options. */
+        ktx2Loader?: {
+            /** Worker count for transcoder, default is 4. */
+            workerCount?: number;
+            /** Pre-initialization according to the priority transcoding format queue, default is ASTC/ETC/DXT/PVRTC/RGBA8. */
+            priorityFormats?: KTX2TargetFormat[] | KTX2TargetFormat[][];
+        };
+    }
+}

package/types/ktx2/KTX2TargetFormat.d.ts

@@ -0,0 +1,21 @@
+/**
+ * KTX2 transcode target format.
+ */
+export declare enum KTX2TargetFormat {
+    /** RGB(A) compressed format, 128 bits per 4x4 pixel block. */
+    ASTC = 0,
+    /** RGB(A) compressed format, 128 bits per 4x4 pixel block. */
+    BC7 = 1,
+    /** RGB(A) compressed format, 4 bits per pixel if no alpha channel, 8 bits per pixel if has alpha channel. */
+    BC1_BC3 = 2,
+    /** RGB(A) compressed format, 4 bits per pixel. */
+    PVRTC = 3,
+    /** RGB(A) compressed format, 4 bits per pixel if no alpha channel, 8 bits per pixel if has alpha channel. */
+    ETC = 4,
+    /** R format, 8 bits per pixel. */
+    R8 = 5,
+    /** RG format, 16 bits per pixel. */
+    R8G8 = 6,
+    /** RGBA format, 32 bits per pixel. */
+    R8G8B8A8 = 7
+}

package/types/ktx2/KhronosTranscoder/KhronosTranscoder.d.ts

@@ -0,0 +1,17 @@
+import { KTX2Container } from "../KTX2Container";
+import { KTX2TargetFormat } from "../KTX2TargetFormat";
+import { TranscodeResult } from "./TranscoderWorkerCode";
+/** @internal */
+export declare class KhronosTranscoder {
+    readonly workerLimit: number;
+    readonly type: KTX2TargetFormat;
+    static transcoderMap: {
+        0: string;
+    };
+    private _transcodeWorkerPool;
+    private _initPromise;
+    constructor(workerLimit: number, type: KTX2TargetFormat);
+    init(): Promise<any>;
+    transcode(ktx2Container: KTX2Container): Promise<TranscodeResult>;
+    destroy(): void;
+}

package/types/ktx2/KhronosTranscoder/TranscoderWorkerCode.d.ts

@@ -0,0 +1,34 @@
+export interface EncodedData {
+    buffer: Uint8Array;
+    levelWidth: number;
+    levelHeight: number;
+    uncompressedByteLength: number;
+}
+type MessageType = "init" | "transcode";
+export interface IBaseMessage {
+    type: MessageType;
+}
+export interface IInitMessage extends IBaseMessage {
+    type: "init";
+    transcoderWasm: ArrayBuffer;
+}
+export interface ITranscodeMessage extends IBaseMessage {
+    type: "transcode";
+    format: number;
+    needZstd: boolean;
+    data: EncodedData[][];
+}
+export type IMessage = IInitMessage | ITranscodeMessage;
+export type TranscodeResult = {
+    data: Array<{
+        data: Uint8Array;
+        width: number;
+        height: number;
+    }>;
+};
+export type TranscodeResponse = {
+    id: number;
+    type: "transcoded";
+} & TranscodeResult;
+export declare function TranscodeWorkerCode(): void;
+export {};

package/types/ktx2/TranscodeResult.d.ts

@@ -0,0 +1,10 @@
+export interface TranscodeResult {
+    width: number;
+    height: number;
+    hasAlpha: boolean;
+    mipmaps: Array<{
+        data: Uint8Array;
+        width: number;
+        height: number;
+    }>;
+}

package/types/ktx2/WorkerPool.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @internal
+ * WorkerPool, T is is post message type, U is return type.
+ */
+export declare class WorkerPool<T = any, U = any> {
+    readonly limitedCount: number;
+    private readonly _workerCreator;
+    private _taskQueue;
+    private _workerStatus;
+    private _workerItems;
+    /**
+     * Constructor of WorkerPool.
+     * @param limitedCount - worker limit count
+     * @param _workerCreator - creator of worker
+     */
+    constructor(limitedCount: number, _workerCreator: () => Worker | Promise<Worker>);
+    prepareWorker(): Promise<Worker[]>;
+    /**
+     * Post message to worker.
+     * @param message - Message which posted to worker
+     * @returns Return a promise of message
+     */
+    postMessage(message: T): Promise<U>;
+    /**
+     * Destroy the worker pool.
+     */
+    destroy(): void;
+    private _initWorker;
+    private _getIdleWorkerId;
+    private _onMessage;
+    private _nextTask;
+}

package/types/ktx2/constants.d.ts

@@ -0,0 +1,7 @@
+export declare enum SupercompressionScheme {
+    None = 0,
+    BasisLZ = 1,
+    Zstd = 2,
+    ZLib = 3
+}
+export declare const KHR_DF_SAMPLE_DATATYPE_SIGNED = 64;

package/types/ktx2/transcoder/AbstractTranscoder.d.ts

@@ -0,0 +1,55 @@
+import { WorkerPool } from "../WorkerPool";
+export declare abstract class AbstractTranscoder {
+    readonly workerLimitCount: number;
+    protected _transcodeWorkerPool: WorkerPool;
+    protected _initPromise: Promise<any>;
+    constructor(workerLimitCount: number);
+    init(): Promise<any>;
+    destroy(): void;
+    protected abstract _initTranscodeWorkerPool(): Promise<any>;
+    protected _createTranscodePool(workerURL: string, wasmBuffer: ArrayBuffer): Promise<Worker[]>;
+}
+type MessageType = "init" | "transcode";
+export interface BaseMessage {
+    type: MessageType;
+}
+export interface InitMessage extends BaseMessage {
+    type: "init";
+    transcoderWasm: ArrayBuffer;
+}
+export interface BinomialTranscodeMessage extends BaseMessage {
+    type: "transcode";
+    format: number;
+    buffer: ArrayBuffer;
+}
+export type IBinomialMessage = InitMessage | BinomialTranscodeMessage;
+export type TranscodeResult = {
+    width: number;
+    height: number;
+    hasAlpha: boolean;
+    format: number;
+    faces: Array<{
+        data: Uint8Array;
+        width: number;
+        height: number;
+    }>[];
+    faceCount: number;
+};
+export type TranscodeResponse = {
+    id: number;
+    type: "transcoded";
+} & TranscodeResult;
+export interface EncodedData {
+    buffer: Uint8Array;
+    levelWidth: number;
+    levelHeight: number;
+    uncompressedByteLength: number;
+}
+export interface KhronosTranscoderMessage extends BaseMessage {
+    type: "transcode";
+    format: number;
+    needZstd: boolean;
+    data: EncodedData[][];
+}
+export type IKhronosMessageMessage = InitMessage | KhronosTranscoderMessage;
+export {};

package/types/ktx2/transcoder/BinomialLLCTranscoder.d.ts

@@ -0,0 +1,8 @@
+import { KTX2TargetFormat } from "../KTX2TargetFormat";
+import { AbstractTranscoder, TranscodeResult } from "./AbstractTranscoder";
+/** @internal */
+export declare class BinomialLLCTranscoder extends AbstractTranscoder {
+    constructor(workerLimitCount: number);
+    _initTranscodeWorkerPool(): Promise<Worker[]>;
+    transcode(buffer: ArrayBuffer, format: KTX2TargetFormat): Promise<TranscodeResult>;
+}

package/types/ktx2/transcoder/BinomialLLCWorkerCode.d.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export declare function TranscodeWorkerCode(): void;

package/types/ktx2/transcoder/KhronosTranscoder.d.ts

@@ -0,0 +1,13 @@
+import { KTX2Container } from "../KTX2Container";
+import { KTX2TargetFormat } from "../KTX2TargetFormat";
+import { AbstractTranscoder, TranscodeResult } from "./AbstractTranscoder";
+/** @internal */
+export declare class KhronosTranscoder extends AbstractTranscoder {
+    readonly type: KTX2TargetFormat;
+    static transcoderMap: {
+        0: string;
+    };
+    constructor(workerLimitCount: number, type: KTX2TargetFormat);
+    _initTranscodeWorkerPool(): Promise<Worker[]>;
+    transcode(ktx2Container: KTX2Container): Promise<TranscodeResult>;
+}

package/types/ktx2/transcoder/KhronosWorkerCode.d.ts

@@ -0,0 +1 @@
+export declare function TranscodeWorkerCode(): void;