@galacean/engine-loader 1.1.0-alpha.0 → 1.1.0-alpha.2

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;

package/types/ktx2/zstddec.d.ts

@@ -0,0 +1,62 @@
+/**
+ * From https://github.com/donmccurdy/zstddec by Don McCurdy
+ */
+interface DecoderExports {
+    memory: Uint8Array;
+    ZSTD_findDecompressedSize: (compressedPtr: number, compressedSize: number) => number;
+    ZSTD_decompress: (uncompressedPtr: number, uncompressedSize: number, compressedPtr: number, compressedSize: number) => number;
+    malloc: (ptr: number) => number;
+    free: (ptr: number) => void;
+}
+/**
+ * ZSTD (Zstandard) decoder.
+ */
+export declare class ZSTDDecoder {
+    static heap: Uint8Array;
+    static IMPORT_OBJECT: {
+        env: {
+            emscripten_notify_memory_growth: () => void;
+        };
+    };
+    static instance: {
+        exports: DecoderExports;
+    };
+    static WasmModuleURL: string;
+    _initPromise: Promise<any>;
+    init(): Promise<void>;
+    _init(result: WebAssembly.WebAssemblyInstantiatedSource): void;
+    decode(array: Uint8Array, uncompressedSize?: number): Uint8Array;
+}
+export {};
+/**
+ * BSD License
+ *
+ * For Zstandard software
+ *
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ *  * Neither the name Facebook nor the names of its contributors may be used to
+ *    endorse or promote products derived from this software without specific
+ *    prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */

package/types/resource-deserialize/resources/prefab/PrefabDesign.d.ts

@@ -1,5 +1,5 @@
 import type { BackgroundMode } from "@galacean/engine-core";
-import { IReferable } from "@galacean/engine-core/types/asset/IReferable";
+import { IRefObject } from "@galacean/engine-core/types/asset/IRefObject";
 import { IColor } from "../mesh/IModelMesh";
 export interface IPrefabFile {
     entities: Array<IEntity>;
@@ -9,11 +9,11 @@ export interface IScene extends IPrefabFile {
         background: {
             mode: BackgroundMode;
             color: IColor;
-            texture?: IReferable;
-            sky?: IReferable;
+            texture?: IRefObject;
+            sky?: IRefObject;
         };
         ambient: {
-            ambientLight: IReferable;
+            ambientLight: IRefObject;
             diffuseSolidColor: IColor;
             diffuseIntensity: number;
             specularIntensity: number;

package/types/resource-deserialize/utils/BufferReader.d.ts

@@ -1,15 +1,11 @@
 export declare class BufferReader {
-    buffer: ArrayBuffer;
+    data: Uint8Array;
     private _dataView;
     private _littleEndian;
     private _offset;
-    static imageMapping: {
-        0: string;
-        1: string;
-        2: string;
-        3: string;
-    };
-    constructor(buffer: ArrayBuffer, byteOffset?: number, byteLength?: number, littleEndian?: boolean);
+    private _baseOffset;
+    constructor(data: Uint8Array, byteOffset?: number, byteLength?: number, littleEndian?: boolean);
+    get position(): number;
     get offset(): number;
     nextUint8(): number;
     nextUint16(): number;
@@ -25,8 +21,8 @@ export declare class BufferReader {
     /**
      * image data 放在最后
      */
-    nextImageData(count?: number): ArrayBuffer;
-    nextImagesData(count: number): ArrayBuffer[];
+    nextImageData(count?: number): Uint8Array;
+    nextImagesData(count: number): Uint8Array[];
     skip(bytes: number): this;
     scan(maxByteLength: number, term?: number): Uint8Array;
 }