@galacean/engine-loader 0.0.0-experimental-renderSort.3 → 0.0.0-experimental-shaderlab.2

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

@@ -0,0 +1,70 @@
+import type { BackgroundMode } from "@galacean/engine-core";
+import { IReferable } from "@galacean/engine-core/types/asset/IReferable";
+import { IColor } from "../mesh/IModelMesh";
+export interface IPrefabFile {
+    entities: Array<IEntity>;
+}
+export interface IScene extends IPrefabFile {
+    scene: {
+        background: {
+            mode: BackgroundMode;
+            color: IColor;
+            texture?: IReferable;
+            sky?: IReferable;
+        };
+        ambient: {
+            ambientLight: IReferable;
+            diffuseSolidColor: IColor;
+            diffuseIntensity: number;
+            specularIntensity: number;
+        };
+    };
+    files: Array<{
+        id: string;
+        type: string;
+        virtualPath: string;
+        path: string;
+    }>;
+}
+export interface IVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+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;
+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;
+};

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

@@ -0,0 +1,14 @@
+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/prefab/ReflectionParser.d.ts

@@ -0,0 +1,14 @@
+import { Engine, Entity } from "@galacean/engine-core";
+import { IBasicType, IClassObject, IEntity } from "./PrefabDesign";
+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,9 +1,9 @@
 import { Engine, Scene } from "@galacean/engine-core";
 import type { IScene } from "../schema";
 import { SceneParserContext } from "./SceneParserContext";
+import HierarchyParser from "../parser/HierarchyParser";
 /** @Internal */
-export declare class SceneParser {
-    readonly context: SceneParserContext;
+export declare class SceneParser extends HierarchyParser<Scene, SceneParserContext> {
     /**
      * Parse scene data.
      * @param engine - the engine of the parser context
@@ -11,19 +11,5 @@ export declare class SceneParser {
      * @returns a promise of scene
      */
     static parse(engine: Engine, sceneData: IScene): Promise<Scene>;
-    /**
-     * The promise of parsed scene.
-     */
-    readonly promise: Promise<Scene>;
-    private _resolve;
-    private _reject;
-    private _engine;
-    private _reflectionParser;
-    constructor(context: SceneParserContext);
-    /** start parse the scene */
-    start(): void;
-    private _parseEntities;
-    private _organizeEntities;
-    private _parseComponents;
-    private _clearAndResolveScene;
+    protected handleRootEntity(id: string): void;
 }

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

@@ -1,15 +1,9 @@
-import { Component, Engine, Entity, ResourceManager, Scene } from "@galacean/engine-core";
-import type { IEntity, IScene } from "../schema";
-export declare class SceneParserContext {
+import { Scene } from "@galacean/engine-core";
+import { IScene } from "../schema";
+import { ParserContext } from "../parser/ParserContext";
+export declare class SceneParserContext extends ParserContext<IScene, Scene> {
     readonly originalData: IScene;
+    readonly engine: any;
     readonly scene: Scene;
-    entityMap: Map<string, Entity>;
-    components: Map<string, Component>;
-    assets: Map<string, any>;
-    entityConfigMap: Map<string, IEntity>;
-    rootIds: string[];
-    readonly engine: Engine;
-    readonly resourceManager: ResourceManager;
-    constructor(originalData: IScene, scene: Scene);
-    destroy(): void;
+    constructor(originalData: IScene, engine: any, scene: Scene);
 }

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

@@ -36,11 +36,34 @@ export interface IBasicEntity {
     parent?: string;
     layer?: Layer;
 }
-export type IEntity = IBasicEntity | IRefEntity;
+export type IEntity = IBasicEntity | IRefEntity | IStrippedEntity;
 export interface IRefEntity extends IBasicEntity {
     assetRefId: string;
     key?: string;
     isClone?: boolean;
+    modifications: {
+        target: IPrefabModifyTarget;
+        methods?: {
+            [methodName: string]: Array<IMethodParams>;
+        };
+        props?: {
+            [key: string]: IBasicType | IMethodParams;
+        };
+    }[];
+    removedEntities: IPrefabModifyTarget[];
+    removedComponents: IPrefabModifyTarget[];
+}
+export interface IPrefabModifyTarget {
+    entityId?: string;
+    componentId?: string;
+}
+export interface IStrippedEntity extends IBasicEntity {
+    strippedId: string;
+    prefabInstanceId: string;
+    prefabSource: {
+        assetId: string;
+        entityId: string;
+    };
 }
 export type IComponent = {
     id: string;
@@ -64,3 +87,6 @@ export type IAssetRef = {
 export type IEntityRef = {
     entityId: string;
 };
+export type IShaderRef = {
+    refId: string;
+};

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

@@ -1,5 +1,5 @@
 import { BlendFactor, BlendOperation, ColorWriteMask, CompareFunction, CullMode, RenderQueueType, StencilOperation } from "@galacean/engine-core";
-import type { IAssetRef, IColor, IVector2, IVector3 } from "./BasicSchema";
+import type { IAssetRef, IColor, IShaderRef, IVector2, IVector3 } from "./BasicSchema";
 export interface IRenderState {
     /** Blend state. */
     blendState: {
@@ -88,4 +88,5 @@ export interface IMaterialSchema {
         value?: string;
     }>;
     renderState: IRenderState;
+    shaderRef: IShaderRef;
 }

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

@@ -1,4 +1,4 @@
-import { BackgroundMode, DiffuseMode, ShadowCascadesMode, ShadowResolution } from "@galacean/engine-core";
+import { BackgroundMode, DiffuseMode, FogMode, ShadowCascadesMode, ShadowResolution } from "@galacean/engine-core";
 import type { IReferable } from "@galacean/engine-core/types/asset/IReferable";
 import type { IColor, IPrefabFile, IVector3 } from "./BasicSchema";
 export declare enum SpecularMode {
@@ -32,6 +32,14 @@ export interface IScene extends IPrefabFile {
             shadowCascades: ShadowCascadesMode;
             shadowTwoCascadeSplits: number;
             shadowFourCascadeSplits: IVector3;
+            shadowFadeBorder: number;
+        };
+        fog?: {
+            fogMode: FogMode;
+            fogStart: number;
+            fogEnd: number;
+            fogDensity: number;
+            fogColor: IColor;
         };
     };
     files: Array<{