@galacean/engine-loader 1.0.0 → 1.1.0-alpha.1

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;

package/types/resource-deserialize/index.d.ts

@@ -1,8 +1,8 @@
 import { Engine } from "@galacean/engine-core";
 export { MeshDecoder } from "./resources/mesh/MeshDecoder";
 export { Texture2DDecoder } from "./resources/texture2D/TextureDecoder";
-export { ReflectionParser } from "./resources/prefab/ReflectionParser";
-export { PrefabParser } from "./resources/prefab/PrefabParser";
+export { ReflectionParser } from "./resources/parser/ReflectionParser";
+export { PrefabParser } from "./resources/parser/PrefabParser";
 export * from "./resources/animationClip/AnimationClipDecoder";
 export type { IModelMesh } from "./resources/mesh/IModelMesh";
 /**
@@ -12,7 +12,7 @@ export type { IModelMesh } from "./resources/mesh/IModelMesh";
  * @returns
  */
 export declare function decode<T>(arrayBuffer: ArrayBuffer, engine: Engine): Promise<T>;
-export * from "./resources/prefab/PrefabDesign";
+export * from "./resources/schema";
 export * from "./resources/scene/SceneParser";
 export * from "./resources/scene/MeshLoader";
 export * from "./resources/scene/EditorTextureLoader";

package/types/resource-deserialize/resources/mesh/MeshDecoder.d.ts

@@ -1,5 +1,5 @@
-import { ModelMesh } from "@galacean/engine-core";
 import type { Engine } from "@galacean/engine-core";
+import { ModelMesh } from "@galacean/engine-core";
 import type { BufferReader } from "../../utils/BufferReader";
 /**
  * @todo refactor

package/types/resource-deserialize/resources/parser/PrefabParser.d.ts

@@ -0,0 +1,5 @@
+import { Entity } from "@galacean/engine-core";
+import type { IEntity } from "../schema";
+export declare class PrefabParser {
+    static parseChildren(entitiesConfig: Map<string, IEntity>, entities: Map<string, Entity>, parentId: string): void;
+}

package/types/resource-deserialize/resources/parser/ReflectionParser.d.ts

@@ -0,0 +1,14 @@
+import { Engine, Entity } from "@galacean/engine-core";
+import type { IBasicType, IClassObject, IEntity } from "../schema";
+export declare class ReflectionParser {
+    static customParseComponentHandles: Map<string, Function>;
+    static registerCustomParseComponent(componentType: string, handle: Function): void;
+    static parseEntity(entityConfig: IEntity, engine: Engine): Promise<Entity>;
+    private static getEntityByConfig;
+    static parseClassObject(item: IClassObject, engine: Engine, resourceManager?: any): Promise<any>;
+    static parseBasicType(value: IBasicType, engine: Engine, resourceManager?: any): Promise<any>;
+    static parsePropsAndMethods(instance: any, item: Omit<IClassObject, "class">, engine: Engine, resourceManager?: any): Promise<any>;
+    static parseMethod(instance: any, methodName: string, methodParams: Array<IBasicType>, engine: Engine, resourceManager?: any): Promise<any>;
+    private static _isClass;
+    private static _isRef;
+}

package/types/resource-deserialize/resources/scene/SceneParser.d.ts

@@ -1,5 +1,5 @@
 import { Engine, Scene } from "@galacean/engine-core";
-import { IScene } from "../prefab/PrefabDesign";
+import type { IScene } from "../schema";
 import { SceneParserContext } from "./SceneParserContext";
 /** @Internal */
 export declare class SceneParser {

package/types/resource-deserialize/resources/scene/SceneParserContext.d.ts

@@ -1,5 +1,5 @@
 import { Component, Entity, Scene } from "@galacean/engine-core";
-import { IEntity, IScene } from "../prefab/PrefabDesign";
+import type { IEntity, IScene } from "../schema";
 export declare class SceneParserContext {
     readonly originalData: IScene;
     readonly scene: Scene;

package/types/resource-deserialize/resources/schema/BasicSchema.d.ts

@@ -0,0 +1,61 @@
+export interface IVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface IVector2 {
+    x: number;
+    y: number;
+}
+export interface IVector4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface IColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface IPrefabFile {
+    entities: Array<IEntity>;
+}
+export type IMethodParams = Array<IBasicType>;
+export type IClassObject = {
+    class: string;
+    constructParams?: IMethodParams;
+    methods?: {
+        [methodName: string]: Array<IMethodParams>;
+    };
+    props?: {
+        [key: string]: IBasicType | IMethodParams;
+    };
+};
+export type IBasicType = string | number | boolean | null | undefined | IAssetRef | IClassObject | IMethodParams;
+export type IAssetRef = {
+    key?: string;
+    refId: string;
+};
+export interface IBasicEntity {
+    name?: string;
+    id?: string;
+    components?: Array<IComponent>;
+    isActive?: boolean;
+    position?: IVector3;
+    rotation?: IVector3;
+    scale?: IVector3;
+    children?: Array<string>;
+    parent?: string;
+}
+export type IEntity = IBasicEntity | IRefEntity;
+export interface IRefEntity extends IBasicEntity {
+    assetRefId: string;
+    key?: string;
+    isClone?: boolean;
+}
+export type IComponent = {
+    id: string;
+    refId?: string;
+} & IClassObject;

package/types/resource-deserialize/resources/schema/MaterialSchema.d.ts

@@ -0,0 +1,91 @@
+import { BlendFactor, BlendOperation, ColorWriteMask, CompareFunction, CullMode, RenderQueueType, StencilOperation } from "@galacean/engine-core";
+import type { IAssetRef, IColor, IVector2, IVector3 } from "./BasicSchema";
+export interface IRenderState {
+    /** Blend state. */
+    blendState: {
+        /** The blend state of the render target. */
+        targetBlendState: {
+            /** Whether to enable blend. */
+            enabled: boolean;
+            /** color (RGB) blend operation. */
+            colorBlendOperation: BlendOperation;
+            /** alpha (A) blend operation. */
+            alphaBlendOperation: BlendOperation;
+            /** color blend factor (RGB) for source. */
+            sourceColorBlendFactor: BlendFactor;
+            /** alpha blend factor (A) for source. */
+            sourceAlphaBlendFactor: BlendFactor;
+            /** color blend factor (RGB) for destination. */
+            destinationColorBlendFactor: BlendFactor;
+            /** alpha blend factor (A) for destination. */
+            destinationAlphaBlendFactor: BlendFactor;
+            /** color mask. */
+            colorWriteMask: ColorWriteMask;
+        };
+        blendColor: IColor;
+        /** Whether to use (Alpha-to-Coverage) technology. */
+        alphaToCoverage: boolean;
+    };
+    /** Depth state. */
+    depthState: {
+        /** Whether to enable the depth test. */
+        enabled: boolean;
+        /** Whether the depth value can be written.*/
+        writeEnabled: boolean;
+        /** Depth comparison function. */
+        compareFunction: CompareFunction;
+    };
+    /** Stencil state. */
+    stencilState: {
+        /** Whether to enable stencil test. */
+        enabled: boolean;
+        /** Write the reference value of the stencil buffer. */
+        referenceValue: number;
+        /** Specifying a bit-wise mask that is used to AND the reference value and the stored stencil value when the test is done. */
+        mask: number;
+        /** Specifying a bit mask to enable or disable writing of individual bits in the stencil planes. */
+        writeMask: number;
+        /** The comparison function of the reference value of the front face of the geometry and the current buffer storage value. */
+        compareFunctionFront: CompareFunction;
+        /** The comparison function of the reference value of the back of the geometry and the current buffer storage value. */
+        compareFunctionBack: CompareFunction;
+        /** specifying the function to use for front face when both the stencil test and the depth test pass. */
+        passOperationFront: StencilOperation;
+        /** specifying the function to use for back face when both the stencil test and the depth test pass. */
+        passOperationBack: StencilOperation;
+        /** specifying the function to use for front face when the stencil test fails. */
+        failOperationFront: StencilOperation;
+        /** specifying the function to use for back face when the stencil test fails. */
+        failOperationBack: StencilOperation;
+        /** specifying the function to use for front face when the stencil test passes, but the depth test fails. */
+        zFailOperationFront: StencilOperation;
+        /** specifying the function to use for back face when the stencil test passes, but the depth test fails. */
+        zFailOperationBack: StencilOperation;
+    };
+    /** Raster state. */
+    rasterState: {
+        /** Specifies whether or not front- and/or back-facing polygons can be culled. */
+        cullMode: CullMode;
+        /** The multiplier by which an implementation-specific value is multiplied with to create a constant depth offset. */
+        depthBias: number;
+        /** The scale factor for the variable depth offset for each polygon. */
+        slopeScaledDepthBias: number;
+    };
+    /** Render queue type. */
+    renderQueueType: RenderQueueType;
+}
+export interface IMaterialSchema {
+    name: string;
+    shader: string;
+    shaderData: {
+        [key: string]: {
+            type: "Vector2" | "Vector3" | "Vector4" | "Color" | "Float" | "Texture";
+            value: IVector3 | IVector2 | IColor | number | IAssetRef;
+        };
+    };
+    macros: Array<{
+        name: string;
+        value?: string;
+    }>;
+    renderState: IRenderState;
+}

package/types/resource-deserialize/resources/schema/SceneSchema.d.ts

@@ -0,0 +1,41 @@
+import { BackgroundMode, DiffuseMode, ShadowCascadesMode, ShadowResolution } from "@galacean/engine-core";
+import type { IReferable } from "@galacean/engine-core/types/asset/IReferable";
+import type { IColor, IPrefabFile } from "./BasicSchema";
+export declare enum SpecularMode {
+    Sky = "Sky",
+    Custom = "Custom"
+}
+export interface IScene extends IPrefabFile {
+    scene: {
+        background: {
+            mode: BackgroundMode;
+            color: IColor;
+            texture?: IReferable;
+            skyMesh?: IReferable;
+            skyMaterial?: IReferable;
+        };
+        ambient: {
+            diffuseMode: DiffuseMode;
+            ambientLight: IReferable;
+            customAmbientLight: IReferable;
+            customSpecularTexture: IReferable;
+            diffuseSolidColor: IColor;
+            diffuseIntensity: number;
+            specularIntensity: number;
+            specularMode: SpecularMode;
+            bakerResolution: number;
+        };
+        shadow?: {
+            castShadows: boolean;
+            shadowResolution: ShadowResolution;
+            shadowDistance: number;
+            shadowCascades: ShadowCascadesMode;
+        };
+    };
+    files: Array<{
+        id: string;
+        type: string;
+        virtualPath: string;
+        path: string;
+    }>;
+}

package/types/resource-deserialize/resources/schema/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./BasicSchema";
+export * from "./MaterialSchema";
+export * from "./SceneSchema";

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