@galacean/engine-loader 1.1.0-beta.8 → 1.1.1

package/package.json

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

package/types/GLTFLoader.d.ts

@@ -12,4 +12,5 @@ export interface GLTFParams {
      * Keep raw mesh data for glTF parser, default is false.
      */
     keepMeshData?: boolean;
+    [key: string]: any;
 }

package/types/PrimitiveMeshLoader.d.ts

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

package/types/Texture2DLoader.d.ts

@@ -1,4 +1,4 @@
-import { TextureFormat } from "@galacean/engine-core";
+import { TextureFilterMode, TextureFormat, TextureWrapMode } from "@galacean/engine-core";
 /**
  * Texture2D loader params interface.
  */
@@ -7,4 +7,12 @@ export interface Texture2DParams {
     format: TextureFormat;
     /** Whether to use multi-level texture, default is true. */
     mipmap: boolean;
+    /** Wrapping mode for texture coordinate S. */
+    wrapModeU: TextureWrapMode;
+    /** Wrapping mode for texture coordinate T. */
+    wrapModeV: TextureWrapMode;
+    /** Filter mode for texture. */
+    filterMode: TextureFilterMode;
+    /** Anisotropic level for texture. */
+    anisoLevel: number;
 }

package/types/gltf/GLTFUtils.d.ts

@@ -40,9 +40,10 @@ export declare class GLTFUtils {
     /**
      * Parse the glb format.
      */
-    static parseGLB(context: GLTFParserContext, glb: ArrayBuffer): {
-        glTF: IGLTF;
-        buffers: ArrayBuffer[];
+    static parseGLB(context: GLTFParserContext, originBuffer: ArrayBuffer): {
+        glTF?: IGLTF;
+        buffers?: ArrayBuffer[];
+        originBuffer?: ArrayBuffer;
     };
     static parseSampler(texture: Texture2D, samplerInfo: ISamplerInfo): void;
     static getSamplerInfo(sampler: ISampler): ISamplerInfo;

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

@@ -0,0 +1,13 @@
+declare module "@galacean/engine-core" {
+    interface EngineConfiguration {
+        /** glTF loader options. */
+        glTF?: {
+            /** Meshopt options. If set this option and workCount is great than 0, workers will be created. */
+            meshOpt?: {
+                /** Worker count for transcoder, default is 4. */
+                workerCount: number;
+            };
+        };
+    }
+}
+export {};

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

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

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

@@ -0,0 +1,8 @@
+declare const MeshoptDecoder: {
+    workerCount: number;
+    ready: Promise<void>;
+    useWorkers: () => void;
+    decodeGltfBuffer: (count: any, stride: any, source: any, mode: any, filter: any) => Promise<Uint8Array>;
+    release(): void;
+};
+export { MeshoptDecoder };

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

@@ -0,0 +1,5 @@
+import { GLTFParserContext } from "./GLTFParserContext";
+import { GLTFParser } from "./GLTFParser";
+export declare class GLTFBufferViewParser extends GLTFParser {
+    parse(context: GLTFParserContext, index: number): Promise<Uint8Array>;
+}

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

@@ -1,5 +1,6 @@
 import { Buffer, Entity, ResourceManager, TypedArray } from "@galacean/engine-core";
 import { BufferDataRestoreInfo, GLTFContentRestorer } from "../../GLTFContentRestorer";
+import { GLTFParams } from "../../GLTFLoader";
 import { GLTFResource } from "../GLTFResource";
 import type { IGLTF } from "../GLTFSchema";
 import { GLTFParser } from "./GLTFParser";
@@ -9,7 +10,7 @@ import { GLTFParser } from "./GLTFParser";
 export declare class GLTFParserContext {
     glTFResource: GLTFResource;
     resourceManager: ResourceManager;
-    keepMeshData: boolean;
+    params: GLTFParams;
     private static readonly _parsers;
     static addParser(parserType: GLTFParserType, parser: GLTFParser): void;
     glTF: IGLTF;
@@ -17,7 +18,7 @@ export declare class GLTFParserContext {
     contentRestorer: GLTFContentRestorer;
     buffers?: ArrayBuffer[];
     private _resourceCache;
-    constructor(glTFResource: GLTFResource, resourceManager: ResourceManager, keepMeshData: boolean);
+    constructor(glTFResource: GLTFResource, resourceManager: ResourceManager, params: GLTFParams);
     get<T>(type: GLTFParserType.Entity, index: number): Entity;
     get<T>(type: GLTFParserType.Entity): Entity[];
     get<T>(type: GLTFParserType.Schema): Promise<T>;
@@ -25,6 +26,7 @@ export declare class GLTFParserContext {
     get<T>(type: GLTFParserType, index: number): Promise<T>;
     get<T>(type: GLTFParserType): Promise<T[]>;
     parse(): Promise<GLTFResource>;
+    private _createAnimator;
     private _handleSubAsset;
 }
 /**

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

@@ -6,7 +6,6 @@ export declare class GLTFSceneParser extends GLTFParser {
     private _parseEntityComponent;
     private _createCamera;
     private _createRenderer;
-    private _createAnimator;
     private _computeLocalBounds;
     private _computeApproximateBindMatrix;
 }

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

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

package/types/index.d.ts

@@ -22,6 +22,6 @@ export * from "./SceneLoader";
 export type { Texture2DParams } from "./Texture2DLoader";
 export { parseSingleKTX } from "./compressed-texture";
 export * from "./gltf";
-export { KTX2Loader } from "./ktx2/KTX2Loader";
+export { KTX2Loader, KTX2Transcoder } from "./ktx2/KTX2Loader";
 export { KTX2TargetFormat } from "./ktx2/KTX2TargetFormat";
 export * from "./resource-deserialize";

package/types/ktx2/KTX2Loader.d.ts

@@ -5,6 +5,7 @@ export declare class KTX2Loader extends Loader<Texture2D | TextureCube> {
     private static _isBinomialInit;
     private static _binomialLLCTranscoder;
     private static _khronosTranscoder;
+    private static _priorityFormats;
     private static _supportedMap;
     /**
      * Destroy ktx2 transcoder worker.
@@ -24,30 +25,40 @@ export declare class KTX2Loader extends Loader<Texture2D | TextureCube> {
     private static _getBinomialLLCTranscoder;
     private static _getKhronosTranscoder;
     private static _getEngineTextureFormat;
-    initialize(engine: Engine, configuration: EngineConfiguration): Promise<void>;
+    initialize(_: 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. */
+    /** Priority transcoding format queue which is preferred options, default is BC7/ASTC/BC3_BC1/ETC/PVRTC/R8G8B8A8. */
+    /** @deprecated */
     priorityFormats: KTX2TargetFormat[];
 }
+/** Used for initialize KTX2 transcoder. */
+export declare enum KTX2Transcoder {
+    /** BinomialLLC transcoder. */
+    BinomialLLC = 0,
+    /** Khronos transcoder. */
+    Khronos = 1
+}
 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[][];
+            /** 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;
         };
     }
 }

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

@@ -20,7 +20,7 @@ export interface InitMessage extends BaseMessage {
 export interface BinomialTranscodeMessage extends BaseMessage {
     type: "transcode";
     format: number;
-    buffer: ArrayBuffer;
+    buffer: Uint8Array;
 }
 export type IBinomialMessage = InitMessage | BinomialTranscodeMessage;
 export type TranscodeResult = {

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

@@ -4,5 +4,5 @@ import { AbstractTranscoder, TranscodeResult } from "./AbstractTranscoder";
 export declare class BinomialLLCTranscoder extends AbstractTranscoder {
     constructor(workerLimitCount: number);
     _initTranscodeWorkerPool(): Promise<any>;
-    transcode(buffer: ArrayBuffer, format: KTX2TargetFormat): Promise<TranscodeResult>;
+    transcode(buffer: Uint8Array, format: KTX2TargetFormat): Promise<TranscodeResult>;
 }

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

@@ -3,4 +3,4 @@ import { TranscodeResult } from "./AbstractTranscoder";
 export declare function TranscodeWorkerCode(): void;
 export declare const _init: () => (wasmBinary?: ArrayBuffer) => any;
 export declare const init: (wasmBinary?: ArrayBuffer) => any;
-export declare function transcode(buffer: ArrayBuffer, targetFormat: any, KTX2File: any): TranscodeResult;
+export declare function transcode(buffer: Uint8Array, targetFormat: any, KTX2File: any): TranscodeResult;

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

@@ -0,0 +1,36 @@
+import { Entity, Engine, Scene } from "@galacean/engine-core";
+import type { IPrefabFile } from "../schema";
+import { ReflectionParser } from "./ReflectionParser";
+import { ParserContext } from "./ParserContext";
+/** @Internal */
+export default abstract class HierarchyParser<T extends Scene | Entity, V extends ParserContext<IPrefabFile, T>> {
+    readonly context: V;
+    /**
+     * The promise of parsed object.
+     */
+    readonly promise: Promise<T>;
+    protected _resolve: (item: T) => void;
+    protected _reject: (reason: any) => void;
+    protected _engine: Engine;
+    protected _reflectionParser: ReflectionParser;
+    private prefabContextMap;
+    private prefabPromiseMap;
+    constructor(context: V);
+    /** start parse the scene or prefab or others */
+    start(): void;
+    protected abstract handleRootEntity(id: string): void;
+    private _parseEntities;
+    private _parseComponents;
+    private _parsePrefabModification;
+    private _parsePrefabRemovedEntities;
+    private _parsePrefabRemovedComponents;
+    private _clearAndResolve;
+    private _organizeEntities;
+    private _getEntityByConfig;
+    private _parseEntity;
+    private _parseGLTF;
+    private _parseStrippedEntity;
+    private _parseChildren;
+    private _applyEntityData;
+    private _traverseAddEntityToMap;
+}

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

@@ -0,0 +1,29 @@
+import { Component, EngineObject, Entity, ResourceManager } from "@galacean/engine-core";
+import type { IEntity } from "../schema";
+/**
+ * Parser context
+ * @export
+ * @abstract
+ * @class ParserContext
+ * @template T
+ * @template I
+ */
+export declare class ParserContext<T extends Object, I extends EngineObject> {
+    readonly originalData: T;
+    readonly engine: any;
+    target?: I;
+    entityMap: Map<string, Entity>;
+    components: Map<string, Component>;
+    assets: Map<string, any>;
+    entityConfigMap: Map<string, IEntity>;
+    rootIds: string[];
+    strippedIds: string[];
+    readonly resourceManager: ResourceManager;
+    constructor(originalData: T, engine: any, target?: I);
+    /**
+     * Destroy the context.
+     * @abstract
+     * @memberof ParserContext
+     */
+    destroy(): void;
+}

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

@@ -10,7 +10,7 @@ export declare class ReflectionParser {
     parseClassObject(item: IClassObject): Promise<any>;
     parsePropsAndMethods(instance: any, item: Omit<IClassObject, "class">): Promise<any>;
     parseMethod(instance: any, methodName: string, methodParams: Array<IBasicType>): Promise<any>;
-    parseBasicType(value: IBasicType): Promise<any>;
+    parseBasicType(value: IBasicType, originValue?: any): Promise<any>;
     private _getEntityByConfig;
     private static _isClass;
     private static _isAssetRef;

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

@@ -1,5 +1,14 @@
-import { Entity } from "@galacean/engine-core";
-import type { IEntity } from "./PrefabDesign";
-export declare class PrefabParser {
-    static parseChildren(entitiesConfig: Map<string, IEntity>, entities: Map<string, Entity>, parentId: string): void;
+import { Entity, Engine } from "@galacean/engine-core";
+import type { IPrefabFile } from "../schema";
+import { PrefabParserContext } from "./PrefabParserContext";
+import HierarchyParser from "../parser/HierarchyParser";
+export declare class PrefabParser extends HierarchyParser<Entity, PrefabParserContext> {
+    /**
+     * Parse prefab data.
+     * @param engine - the engine of the parser context
+     * @param prefabData - prefab data which is exported by editor
+     * @returns a promise of prefab
+     */
+    static parse(engine: Engine, prefabData: IPrefabFile): PrefabParser;
+    protected handleRootEntity(id: string): void;
 }

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

@@ -0,0 +1,5 @@
+import { Entity } from "@galacean/engine-core";
+import { IPrefabFile } from "../schema";
+import { ParserContext } from "../parser/ParserContext";
+export declare class PrefabParserContext extends ParserContext<IPrefabFile, Entity> {
+}

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

@@ -1,3 +1,4 @@
+import { Layer } from "@galacean/engine-core";
 export interface IVector3 {
     x: number;
     y: number;
@@ -33,6 +34,7 @@ export interface IBasicEntity {
     scale?: IVector3;
     children?: Array<string>;
     parent?: string;
+    layer?: Layer;
 }
 export type IEntity = IBasicEntity | IRefEntity;
 export interface IRefEntity extends IBasicEntity {

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

@@ -79,7 +79,7 @@ export interface IMaterialSchema {
     shader: string;
     shaderData: {
         [key: string]: {
-            type: "Vector2" | "Vector3" | "Vector4" | "Color" | "Float" | "Texture";
+            type: "Vector2" | "Vector3" | "Vector4" | "Color" | "Float" | "Texture" | "Boolean" | "Integer";
             value: IVector3 | IVector2 | IColor | number | IAssetRef;
         };
     };

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

@@ -1,6 +1,6 @@
 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";
+import type { IColor, IPrefabFile, IVector3 } from "./BasicSchema";
 export declare enum SpecularMode {
     Sky = "Sky",
     Custom = "Custom"
@@ -30,6 +30,8 @@ export interface IScene extends IPrefabFile {
             shadowResolution: ShadowResolution;
             shadowDistance: number;
             shadowCascades: ShadowCascadesMode;
+            shadowTwoCascadeSplits: number;
+            shadowFourCascadeSplits: IVector3;
         };
     };
     files: Array<{

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

@@ -2,7 +2,7 @@ export declare class BufferReader {
     data: Uint8Array;
     private _dataView;
     private _littleEndian;
-    private _offset;
+    private _position;
     private _baseOffset;
     constructor(data: Uint8Array, byteOffset?: number, byteLength?: number, littleEndian?: boolean);
     get position(): number;