@galacean/engine-loader 1.0.0-beta.18 → 1.0.0-beta.20

package/package.json

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

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

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

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/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/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;