@galacean/engine-loader 0.0.0-experimental-2.0-game.19 → 0.0.0-experimental-2.0-migrate.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-loader",
-  "version": "0.0.0-experimental-2.0-game.19",
+  "version": "0.0.0-experimental-2.0-migrate.2",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -19,9 +19,9 @@
     "libs/**/*"
   ],
   "dependencies": {
-    "@galacean/engine-core": "0.0.0-experimental-2.0-game.19",
-    "@galacean/engine-rhi-webgl": "0.0.0-experimental-2.0-game.19",
-    "@galacean/engine-math": "0.0.0-experimental-2.0-game.19"
+    "@galacean/engine-core": "0.0.0-experimental-2.0-migrate.2",
+    "@galacean/engine-rhi-webgl": "0.0.0-experimental-2.0-migrate.2",
+    "@galacean/engine-math": "0.0.0-experimental-2.0-migrate.2"
   },
   "scripts": {
     "b:types": "tsc"

package/types/HDRDecoder.d.ts

@@ -1,22 +1,41 @@
 /**
- * HDR panorama to cubemap decoder.
+ * HDR (Radiance RGBE) image decoder.
+ *
+ * Decodes .hdr files into pixel data. Supports parsing the header
+ * and decoding RLE-compressed RGBE scanlines into R16G16B16A16 half-float pixels.
  */
 export declare class HDRDecoder {
     private static _float2HalfTables;
     private static _floatView;
     private static _uint32View;
-    private static _one;
-    private static _faces;
+    /**
+     * Parse the header of an HDR file.
+     * @returns Header info including width, height, and data start position.
+     */
     static parseHeader(uint8array: Uint8Array): IHDRHeader;
-    static decodeFaces(bufferArray: Uint8Array, header: IHDRHeader, onFace: (faceIndex: number, data: Uint16Array) => void): void;
+    /**
+     * Decode an HDR file buffer into R16G16B16A16 half-float pixel data.
+     * @param buffer - The full HDR file as Uint8Array.
+     * @returns Object with width, height, and half-float pixel data.
+     */
+    static decode(buffer: Uint8Array): {
+        width: number;
+        height: number;
+        pixels: Uint16Array;
+    };
+    /**
+     * Convert RGBE pixel data to R16G16B16A16 half-float.
+     */
+    static _rgbeToHalfFloat(rgbe: Uint8Array, width: number, height: number): Uint16Array;
+    /**
+     * Decode RLE-compressed RGBE scanlines into raw RGBE pixel data.
+     */
+    static _readPixels(buffer: Uint8Array, width: number, height: number): Uint8Array;
     private static _generateFloat2HalfTables;
-    private static _createCubemapData;
     private static _readStringLine;
-    private static _readPixels;
 }
-interface IHDRHeader {
+export interface IHDRHeader {
     width: number;
     height: number;
     dataPosition: number;
 }
-export {};

package/types/SceneLoader.d.ts

@@ -1 +1,8 @@
-export {};
+import { ResourceManager, Scene } from "@galacean/engine-core";
+import type { RefItem } from "./schema/CommonSchema";
+import { type SceneFile } from "./schema/SceneSchema";
+/**
+ * Apply scene-level data (ambient, background, shadow, fog, AO) to a Scene.
+ * @internal
+ */
+export declare function applySceneData(scene: Scene, sceneData: SceneFile["scene"], resourceManager: ResourceManager, refs: RefItem[]): Promise<void>;

package/types/{Texture2DLoader.d.ts → TextureLoader.d.ts}

@@ -1,9 +1,9 @@
 import { TextureFilterMode, TextureFormat, TextureWrapMode } from "@galacean/engine-core";
 /**
- * Texture2D loader params interface.
+ * Texture loader params interface.
  */
-export interface Texture2DParams {
-    /** Texture format. default  `TextureFormat.R8G8B8A8` */
+export interface TextureParams {
+    /** Texture format. default `TextureFormat.R8G8B8A8` */
     format: TextureFormat;
     /** Whether to use multi-level texture, default is true. */
     mipmap: boolean;
@@ -15,6 +15,6 @@ export interface Texture2DParams {
     filterMode: TextureFilterMode;
     /** Anisotropic level for texture. */
     anisoLevel: number;
-    /** Whether the texture data is in sRGB color space, otherwise is linear color space. @defaultValue `true` */
+    /** Whether the texture data is in sRGB color space. @defaultValue `true` */
     isSRGBColorSpace: boolean;
 }

package/types/gltf/GLTFResource.d.ts

@@ -37,6 +37,11 @@ export declare class GLTFResource extends ReferResource {
      * @returns Root entity
      */
     instantiateSceneRoot(sceneIndex?: number): Entity;
+    /**
+     * Scene root templates indexed by the glTF `scenes` array.
+     * @remarks This is also the canonical sub-asset query surface, for example `?q=scenes[0]`.
+     */
+    get scenes(): ReadonlyArray<Entity>;
     protected _onDestroy(): void;
     private _disassociationSuperResource;
     /**

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

@@ -1,4 +1,5 @@
 import type { IMaterialNormalTextureInfo, ITextureInfo } from "../GLTFSchema";
+import type { RefItem } from "../../schema/CommonSchema";
 /**
  * Interfaces from the KHR_lights_punctual extension
  */
@@ -133,9 +134,7 @@ export interface IEXTMeshoptCompressionSchema {
     count: number;
     filter?: "NONE" | "OCTAHEDRAL" | "QUATERNION" | "EXPONENTIAL";
 }
-export interface IGalaceanMaterialRemap {
-    url: string;
-    key?: string;
+export interface IGalaceanMaterialRemap extends RefItem {
     isClone?: boolean;
 }
 export interface IGalaceanAnimation {

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

@@ -2,6 +2,7 @@ import { AssetPromise, Entity } from "@galacean/engine-core";
 import { GLTFParser } from "./GLTFParser";
 import { GLTFParserContext } from "./GLTFParserContext";
 export declare class GLTFSceneParser extends GLTFParser {
+    private static _tempMatrix;
     parse(context: GLTFParserContext, index: number): AssetPromise<Entity>;
     private _parseEntityComponent;
     private _createCamera;

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

@@ -3,6 +3,9 @@ import { GLTFParser } from "./GLTFParser";
 import { GLTFParserContext } from "./GLTFParserContext";
 export declare class GLTFSkinParser extends GLTFParser {
     parse(context: GLTFParserContext, index: number): AssetPromise<Skin>;
-    private _findSkinRootBoneByLCA;
-    private _findRootBoneByLCA;
+    /**
+     * Resolve the skeleton rootBone as the lowest common ancestor of the joints' parent chains.
+     * Returns null when joints share no common ancestor.
+     */
+    private _findSkeletonRootBone;
 }

package/types/index.d.ts

@@ -16,18 +16,16 @@ import "./SourceFontLoader";
 import "./SpriteAtlasLoader";
 import "./SpriteLoader";
 import "./TextLoader";
-import "./Texture2DLoader";
-import "./TextureCubeLoader";
+import "./TextureLoader";
 import "./AudioLoader";
 import "./ktx2/KTX2Loader";
 import "./ShaderLoader";
-import "./ShaderChunkLoader";
 import "./PhysicsMaterialLoader";
 import "./RenderTargetLoader";
 export { GLTFLoader } from "./GLTFLoader";
 export type { GLTFParams } from "./GLTFLoader";
-export * from "./SceneLoader";
-export type { Texture2DParams } from "./Texture2DLoader";
+import "./SceneLoader";
+export type { TextureParams } from "./TextureLoader";
 export { parseSingleKTX } from "./compressed-texture";
 export * from "./gltf";
 export { KTX2Loader } from "./ktx2/KTX2Loader";

package/types/prefab/PrefabParser.d.ts

@@ -1,12 +1,15 @@
 import { Engine, Entity } from "@galacean/engine-core";
-import { IEntity, IHierarchyFile, ParserContext } from "../resource-deserialize";
+import type { HierarchyFile } from "../schema/HierarchySchema";
+import type { PrefabFile } from "../schema/PrefabSchema";
 import { HierarchyParser } from "../resource-deserialize/resources/parser/HierarchyParser";
+import { ParserContext } from "../resource-deserialize/resources/parser/ParserContext";
 import { PrefabResource } from "./PrefabResource";
-export declare class PrefabParser extends HierarchyParser<PrefabResource, ParserContext<IHierarchyFile, Entity>> {
+export declare class PrefabParser extends HierarchyParser<PrefabResource, ParserContext> {
     readonly prefabResource: PrefabResource;
-    static parse(engine: Engine, url: string, data: IHierarchyFile): Promise<PrefabResource>;
-    constructor(data: IHierarchyFile, context: ParserContext<IHierarchyFile, Entity>, prefabResource: PrefabResource);
-    protected _applyEntityData(entity: Entity, entityConfig?: IEntity): Entity;
-    protected _handleRootEntity(id: string): void;
+    static parse(engine: Engine, url: string, data: PrefabFile): Promise<PrefabResource>;
+    constructor(data: HierarchyFile, context: ParserContext, prefabResource: PrefabResource);
+    protected _onEntityCreated(entity: Entity): void;
+    protected _getRootIndices(): number[];
+    protected _handleRootEntity(index: number): void;
     protected _clearAndResolve(): PrefabResource;
 }

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

@@ -3,7 +3,8 @@ export * from "./resources/animationClip/AnimationClipDecoder";
 export type { IModelMesh } from "./resources/mesh/IModelMesh";
 export { MeshDecoder } from "./resources/mesh/MeshDecoder";
 export { ReflectionParser } from "./resources/parser/ReflectionParser";
-export { Texture2DDecoder } from "./resources/texture2D/TextureDecoder";
+import "./resources/texture2D/Texture2DDecoder";
+import "./resources/textureCube/TextureCubeDecoder";
 /**
  * Decode engine binary resource.
  * @param arrayBuffer - array buffer of decode binary file
@@ -14,7 +15,7 @@ export declare function decode<T>(arrayBuffer: ArrayBuffer, engine: Engine, ...a
 export * from "./resources/parser/HierarchyParser";
 export * from "./resources/parser/ParserContext";
 export * from "./resources/scene/SceneParser";
-export * from "./resources/schema";
+export * from "../schema";
 export * from "./utils/BufferReader";
 export * from "./utils/Decorator";
 export * from "./utils/FileHeader";

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

@@ -1,43 +1,38 @@
 import { Engine, Entity, Scene } from "@galacean/engine-core";
 import { PrefabResource } from "../../../prefab/PrefabResource";
-import type { IEntity, IHierarchyFile } from "../schema";
+import type { HierarchyFile } from "../../../schema/HierarchySchema";
 import { ParserContext } from "./ParserContext";
 import { ReflectionParser } from "./ReflectionParser";
 /** @Internal */
-export declare abstract class HierarchyParser<T extends Scene | PrefabResource, V extends ParserContext<IHierarchyFile, T>> {
-    readonly data: IHierarchyFile;
+export declare abstract class HierarchyParser<T extends Scene | PrefabResource, V extends ParserContext> {
+    readonly data: HierarchyFile;
     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(data: IHierarchyFile, context: V);
-    /** start parse the scene or prefab or others */
+    constructor(data: HierarchyFile, context: V);
     start(): void;
-    protected _applyEntityData(entity: Entity, entityConfig?: IEntity): Entity;
-    protected abstract _handleRootEntity(id: string): void;
+    /** Root entity indices for this hierarchy (scene.rootEntities or [prefab.root]). */
+    protected abstract _getRootIndices(): number[];
+    protected abstract _handleRootEntity(index: number): void;
     protected abstract _clearAndResolve(): Scene | PrefabResource;
+    protected _onEntityCreated(_entity: Entity): void;
     private _parseEntities;
-    private _parseComponents;
-    private _parsePrefabModification;
-    private _parseAddedComponents;
-    private _parsePrefabRemovedEntities;
-    private _parsePrefabRemovedComponents;
     private _organizeEntities;
-    private _getEntityByConfig;
-    private _parseEntity;
-    private _parsePrefab;
-    private _parseStrippedEntity;
-    private _parseChildren;
-    private _addComponents;
-    private _generateInstanceContext;
-    private _parseComponentsPropsAndMethods;
-    private _addComponentPlugin;
-    private _addEntityPlugin;
+    private _parseComponents;
+    private _parseComponentsPropsAndCalls;
+    private _parsePrefabOverrides;
+    private _applyOverrides;
+    private _loadPrefabInstance;
+    /** Resolve an entity inside a prefab instance by walking the child-index path from root */
+    private static _resolveEntity;
+    /** Resolve a component on an entity by type name + per-type index */
+    private static _resolveComponent;
+    /** Resolve component class from config and add to entity. Throws if class is not registered. */
+    private static _addComponentFromConfig;
+    private static _isPrefabInstanceEntity;
+    /** Apply entity-level props (name, isActive, layer, transform) to an entity. */
+    private static _applyEntityProps;
 }

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

@@ -1,5 +1,5 @@
-import { AssetPromise, Component, Engine, EngineObject, Entity, ReferResource, ResourceManager, Scene } from "@galacean/engine-core";
-import type { IEntity, IHierarchyFile } from "../schema";
+import { AssetPromise, Component, Engine, Entity, ReferResource, ResourceManager, Scene } from "@galacean/engine-core";
+import type { ComponentSchema } from "../../../schema/HierarchySchema";
 export declare enum ParserType {
     Prefab = 0,
     Scene = 1
@@ -7,18 +7,18 @@ export declare enum ParserType {
 /**
  * @internal
  */
-export declare class ParserContext<T extends IHierarchyFile, I extends EngineObject> {
+export declare class ParserContext {
     readonly engine: Engine;
     readonly type: ParserType;
     readonly resource: ReferResource | Scene;
-    entityMap: Map<string, Entity>;
-    entityConfigMap: Map<string, IEntity>;
-    components: Map<string, Component>;
-    componentConfigMap: Map<string, any>;
-    rootIds: string[];
-    strippedIds: string[];
+    /** Runtime Entity instances, indexed by the flat entities[] position. */
+    entityInstances: Entity[];
+    /** Components waiting for props/calls application (Stage 4). */
+    pendingComponents: Array<{
+        instance: Component;
+        config: ComponentSchema;
+    }>;
     readonly resourceManager: ResourceManager;
-    private _tasks;
     private _loaded;
     private _total;
     constructor(engine: Engine, type: ParserType, resource: ReferResource | Scene);
@@ -26,5 +26,5 @@ export declare class ParserContext<T extends IHierarchyFile, I extends EngineObj
     /** @internal */
     _setTaskCompleteProgress: (loaded: number, total: number) => void;
     /** @internal */
-    _addDependentAsset(url: string, promise: AssetPromise<any>): void;
+    _addDependentAsset(promise: AssetPromise<any>): void;
 }

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

@@ -1,22 +1,45 @@
-import { EngineObject, Entity, Signal } from "@galacean/engine-core";
-import type { IBasicType, IClass, IEntity, IHierarchyFile, IMethodParams, ISignalRef } from "../schema";
+import { Component } from "@galacean/engine-core";
+import type { CallSpec, MutationBlock, RefItem } from "../../../schema/CommonSchema";
 import { ParserContext } from "./ParserContext";
 export declare class ReflectionParser {
     private readonly _context;
-    constructor(_context: ParserContext<IHierarchyFile, EngineObject>);
-    parseEntity(entityConfig: IEntity): Promise<Entity>;
-    parseClassObject(item: IClass): Promise<any>;
-    parsePropsAndMethods(instance: any, item: Omit<IClass, "class">): Promise<any>;
-    parseMethod(instance: any, methodName: string, methodParams: IMethodParams): Promise<any>;
-    parseSignal(signalRef: ISignalRef): Promise<Signal>;
-    parseBasicType(value: IBasicType, originValue?: any): Promise<any>;
-    private _getEntityByConfig;
-    private _resolveEntityByPath;
-    private static _isClass;
-    private static _isClassType;
-    private static _isAssetRef;
-    private static _isEntityRef;
-    private static _isComponentRef;
-    private static _isSignalRef;
-    private static _isMethodObject;
+    private readonly _refs;
+    /** @internal shared with HierarchyParser; each use must length=0 -> getComponents -> read -> length=0 synchronously. */
+    static _componentBuffer: Component[];
+    constructor(_context: ParserContext, _refs: RefItem[]);
+    /**
+     * Apply v2 props to a component/object instance.
+     * Each prop value is resolved recursively (handling $ref, $type, $class, $entity, $component, $signal).
+     */
+    parseProps(instance: any, props?: Record<string, unknown>): Promise<any>;
+    /**
+     * Execute calls sequentially on a target instance.
+     * Call args are resolved with the same v2 value rules as props.
+     */
+    parseCalls(instance: any, calls?: CallSpec[]): Promise<any>;
+    /**
+     * Apply props and calls from the same mutation block without imposing ordering between them.
+     */
+    parseMutationBlock(target: any, block?: MutationBlock): Promise<any>;
+    /**
+     * Resolve a v2 value with $ prefix detection.
+     *
+     * Priority:
+     * 1. null/undefined/primitive → passthrough
+     * 2. Array → recurse each element
+     * 3. { $ref }       → asset reference
+     * 4. { $type }      → polymorphic type construct
+     * 5. { $class }     → registered class constructor
+     * 6. { $entity }    → entity reference by path (flat index + optional children descent)
+     * 7. { $component } → component reference
+     * 8. { $signal }    → signal binding
+     * 9. plain object   → recurse values (modify originValue in place if exists)
+     */
+    private _resolveValue;
+    private _getRegisteredClass;
+    /** Promise-adapt {@link _getRegisteredClass} so $type/$class branches can fold into the resolver chain. */
+    private _resolveRegisteredClass;
+    private _resolveSignal;
+    private _resolveComponent;
+    private _resolveEntityRef;
 }

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

@@ -1,17 +1,16 @@
 import { Scene } from "@galacean/engine-core";
+import type { SceneFile } from "../../../schema/SceneSchema";
 import { HierarchyParser } from "../parser/HierarchyParser";
 import { ParserContext } from "../parser/ParserContext";
-import { type IScene } from "../schema";
 /** @Internal */
-export declare class SceneParser extends HierarchyParser<Scene, ParserContext<IScene, Scene>> {
+export declare class SceneParser extends HierarchyParser<Scene, ParserContext> {
     readonly scene: Scene;
-    constructor(data: IScene, context: ParserContext<IScene, Scene>, scene: Scene);
+    constructor(data: SceneFile, context: ParserContext, scene: Scene);
     /**
      * @internal
      */
-    _collectDependentAssets(data: IScene): void;
-    protected _handleRootEntity(id: string): void;
+    _collectDependentAssets(data: SceneFile): void;
+    protected _getRootIndices(): number[];
+    protected _handleRootEntity(index: number): void;
     protected _clearAndResolve(): Scene;
-    private _parseDependentAssets;
-    private _searchDependentAssets;
 }

package/types/schema/BasicSchema.d.ts

@@ -0,0 +1,21 @@
+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;
+}

package/types/schema/CommonSchema.d.ts

@@ -0,0 +1,33 @@
+export type Vec3Tuple = [number, number, number];
+export type Vec4Tuple = [number, number, number, number];
+export interface RefItem {
+    url: string;
+    key?: string;
+}
+/** path[0] = flat index into top-level entities[]; subsequent indices descend via children. */
+export type EntityRef = number[];
+export interface ComponentRef {
+    entity: EntityRef;
+    type: string;
+    index: number;
+}
+/** Reference to a registered runtime class constructor. */
+export interface ClassRef {
+    $class: string;
+}
+export interface SignalListener {
+    target: {
+        $component: ComponentRef;
+    };
+    methodName: string;
+    args?: unknown[];
+}
+export interface CallSpec {
+    method: string;
+    args?: unknown[];
+    result?: MutationBlock;
+}
+export interface MutationBlock {
+    props?: Record<string, unknown>;
+    calls?: CallSpec[];
+}

package/types/schema/HierarchySchema.d.ts

@@ -0,0 +1,71 @@
+import type { MutationBlock, RefItem, Vec3Tuple } from "./CommonSchema";
+export interface ComponentSchema extends MutationBlock {
+    type: string;
+    script?: number;
+}
+export interface EntityOverrideProps {
+    name?: string;
+    isActive?: boolean;
+    layer?: number;
+    position?: Vec3Tuple;
+    rotation?: Vec3Tuple;
+    scale?: Vec3Tuple;
+}
+export interface AddedEntityOverride {
+    /** Parent path from prefab instance root via children indices. `[]` = instance root. */
+    parent: number[];
+    /** Index into the top-level entities[] array. */
+    entity: number;
+}
+export interface AddedComponentOverride {
+    /** Target entity path from prefab instance root via children indices. `[]` = instance root. */
+    target: number[];
+    /** Index into the top-level components[] array. */
+    component: number;
+}
+export interface EntityPropOverride extends EntityOverrideProps {
+    /** Path from prefab instance root via children indices. `[]` = instance root. */
+    path: number[];
+}
+export interface ComponentSelector {
+    type: string;
+    index: number;
+}
+export interface ComponentOverride extends MutationBlock {
+    /** Path from prefab instance root via children indices. `[]` = instance root. */
+    path: number[];
+    selector: ComponentSelector;
+}
+export interface RemovedComponentOverride {
+    /** Path from prefab instance root via children indices. `[]` = instance root. */
+    path: number[];
+    selectors: ComponentSelector[];
+}
+export interface InstanceOverrides {
+    entityProps?: EntityPropOverride[];
+    componentProps?: ComponentOverride[];
+    /** Each element is a path from prefab instance root via children indices. */
+    removedEntities?: number[][];
+    removedComponents?: RemovedComponentOverride[];
+    addedEntities?: AddedEntityOverride[];
+    addedComponents?: AddedComponentOverride[];
+}
+export interface InstanceSchema {
+    asset: number;
+    overrides?: InstanceOverrides;
+}
+export interface NormalEntitySchema extends EntityOverrideProps {
+    children?: number[];
+    components?: number[];
+}
+export interface PrefabInstanceEntitySchema {
+    instance: InstanceSchema;
+}
+export type EntitySchema = NormalEntitySchema | PrefabInstanceEntitySchema;
+/** Common base for v2 scene and prefab files. */
+export interface HierarchyFile {
+    version: "2.0";
+    refs: RefItem[];
+    entities: EntitySchema[];
+    components: ComponentSchema[];
+}

package/types/schema/MaterialSchema.d.ts

@@ -0,0 +1,27 @@
+import type { RefItem } from "./CommonSchema";
+import type { IColor, IVector2, IVector3 } from "./BasicSchema";
+export interface IMaterialSchema {
+    name: string;
+    shader: string;
+    shaderData: {
+        [key: string]: {
+            type: MaterialLoaderType;
+            value: IVector3 | IVector2 | IColor | number | RefItem;
+        };
+    };
+    macros: Array<{
+        name: string;
+        value?: string;
+    }>;
+    shaderRef: RefItem;
+}
+export declare enum MaterialLoaderType {
+    Vector2 = "Vector2",
+    Vector3 = "Vector3",
+    Vector4 = "Vector4",
+    Color = "Color",
+    Float = "Float",
+    Texture = "Texture",
+    Boolean = "Boolean",
+    Integer = "Integer"
+}

package/types/schema/PrefabSchema.d.ts

@@ -0,0 +1,4 @@
+import type { HierarchyFile } from "./HierarchySchema";
+export interface PrefabFile extends HierarchyFile {
+    root: number;
+}

package/types/schema/SceneSchema.d.ts

@@ -0,0 +1,63 @@
+import { BackgroundMode, BackgroundTextureFillMode, DiffuseMode, FogMode, ShadowCascadesMode, ShadowResolution } from "@galacean/engine-core";
+import type { HierarchyFile } from "./HierarchySchema";
+import type { Vec3Tuple, Vec4Tuple } from "./CommonSchema";
+export declare enum SpecularMode {
+    Sky = 0,
+    Custom = 1
+}
+export interface SceneFile extends HierarchyFile {
+    scene: {
+        name?: string;
+        rootEntities: number[];
+        background: {
+            mode: BackgroundMode;
+            color: Vec4Tuple;
+            texture?: number;
+            textureFillMode?: BackgroundTextureFillMode;
+            skyMesh?: number;
+            skyMaterial?: number;
+        };
+        ambient?: {
+            diffuseMode: DiffuseMode;
+            ambientLight?: number;
+            customAmbientLight?: number;
+            diffuseSolidColor?: Vec4Tuple;
+            diffuseIntensity: number;
+            specularIntensity: number;
+            specularMode: SpecularMode;
+        };
+        shadow?: {
+            castShadows?: boolean;
+            enableTransparentShadow?: boolean;
+            shadowResolution?: ShadowResolution;
+            shadowDistance?: number;
+            shadowCascades?: ShadowCascadesMode;
+            shadowTwoCascadeSplits?: number;
+            shadowFourCascadeSplits?: Vec3Tuple;
+            shadowFadeBorder?: number;
+        };
+        fog?: {
+            fogMode?: FogMode;
+            fogStart?: number;
+            fogEnd?: number;
+            fogDensity?: number;
+            fogColor?: Vec4Tuple;
+        };
+        physics?: {
+            gravity?: Vec3Tuple;
+            fixedTimeStep?: number;
+        };
+        ambientOcclusion?: {
+            enabledAmbientOcclusion?: boolean;
+            quality?: number;
+            intensity?: number;
+            radius?: number;
+            bias?: number;
+            power?: number;
+            bilateralThreshold?: number;
+            minHorizonAngle?: number;
+        };
+        /** Not supported in scene yet; presence triggers a warning. */
+        postProcess?: unknown;
+    };
+}