@galacean/engine-loader 1.0.0-beta.0 → 1.0.0-beta.10

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

@@ -0,0 +1,8 @@
+import { EngineObject } from "@galacean/engine-core";
+import { ParserContext } from "../parser/ParserContext";
+import { ExtensionSchema } from "./Schema";
+export declare abstract class ExtensionParser {
+    initialize(): void;
+    parseEngineResource(schema: ExtensionSchema, parseResource: EngineObject, context: ParserContext, ...extra: any[]): void | Promise<void>;
+    createEngineResource(schema: ExtensionSchema, context: ParserContext, ...extra: any[]): EngineObject | Promise<EngineObject>;
+}

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

@@ -1,4 +1,4 @@
-import { IMaterialNormalTextureInfo, ITextureInfo } from "../GLTFSchema";
+import type { IMaterialNormalTextureInfo, ITextureInfo } from "../GLTFSchema";
 /**
  * Interfaces from the KHR_lights_punctual extension
  */

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

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

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

@@ -0,0 +1,142 @@
+import { IMaterialNormalTextureInfo, ITextureInfo } from "../Schema";
+/**
+ * Interfaces from the KHR_lights_punctual extension
+ */
+export interface IKHRLightsPunctual_LightNode {
+    light: number;
+}
+export interface IKHRLightsPunctual_Light {
+    type: "directional" | "point" | "spot";
+    color?: number[];
+    intensity?: number;
+    range?: number;
+    spot?: {
+        innerConeAngle?: number;
+        outerConeAngle?: number;
+    };
+}
+export interface IKHRLightsPunctual {
+    lights: IKHRLightsPunctual_Light[];
+}
+/**
+ * Interfaces from the KHR_draco_mesh_compression extension
+ */
+export interface IKHRDracoMeshCompression {
+    bufferView: number;
+    attributes: {
+        [name: string]: number;
+    };
+}
+/**
+ * Interfaces from the KHR_materials_clearcoat extension
+ */
+export interface IKHRMaterialsClearcoat {
+    clearcoatFactor: number;
+    clearcoatTexture: ITextureInfo;
+    clearcoatRoughnessFactor: number;
+    clearcoatRoughnessTexture: ITextureInfo;
+    clearcoatNormalTexture: IMaterialNormalTextureInfo;
+}
+/**
+ * Interfaces from the KHR_materials_ior extension
+ */
+export interface IKHRMaterialsIor {
+    ior: number;
+}
+/**
+ * Interfaces from the KHR_materials_unlit extension
+ */
+export interface IKHRMaterialsUnlit {
+}
+/**
+ * Interfaces from the KHR_materials_pbrSpecularGlossiness extension
+ */
+export interface IKHRMaterialsPbrSpecularGlossiness {
+    diffuseFactor: number[];
+    diffuseTexture: ITextureInfo;
+    specularFactor: number[];
+    glossinessFactor: number;
+    specularGlossinessTexture: ITextureInfo;
+}
+/**
+ * Interfaces from the KHR_materials_sheen extension
+ */
+export interface IKHRMaterialsSheen {
+    sheenColorFactor?: number[];
+    sheenColorTexture?: ITextureInfo;
+    sheenRoughnessFactor?: number;
+    sheenRoughnessTexture?: ITextureInfo;
+}
+/**
+ * Interfaces from the KHR_materials_specular extension
+ */
+export interface IKHRMaterialsSpecular {
+    specularFactor: number;
+    specularColorFactor: number[];
+    specularTexture: ITextureInfo;
+}
+/**
+ * Interfaces from the KHR_materials_transmission extension
+ */
+export interface IKHRMaterialsTransmission {
+    transmissionFactor?: number;
+    transmissionTexture?: ITextureInfo;
+}
+/**
+ * Interfaces from the KHR_materials_translucency extension
+ */
+export interface IKHRMaterialsTranslucency {
+    translucencyFactor?: number;
+    translucencyTexture?: ITextureInfo;
+}
+/**
+ * Interfaces from the KHR_materials_variants extension
+ */
+export interface IKHRMaterialVariants_Mapping {
+    mappings: Array<{
+        variants: number[];
+        material: number;
+    }>;
+    extensions?: any;
+    extras?: any;
+}
+export interface IKHRMaterialVariants_Variant {
+    name: string;
+    extensions?: any;
+    extras?: any;
+}
+export interface IKHRMaterialVariants_Variants {
+    variants: Array<IKHRMaterialVariants_Variant>;
+}
+/**
+ * Interfaces from the KHR_texture_basisu extension
+ */
+export interface IKHRTextureBasisU {
+    source: number;
+}
+/**
+ * Interfaces from the KHR_texture_transform extension
+ */
+export interface IKHRTextureTransform {
+    offset?: number[];
+    rotation?: number;
+    scale?: number[];
+    texCoord?: number;
+}
+/**
+ * Interfaces from the KHR_xmp extension
+ */
+export interface IKHRXmp {
+    packets: Array<{
+        [key: string]: unknown;
+    }>;
+}
+export interface IKHRXmp_Node {
+    packet: number;
+}
+export interface IGalaceanMaterialRemap {
+    refId: string;
+    key?: string;
+    isClone?: boolean;
+}
+export type ExtensionSchema = IKHRLightsPunctual_Light | IKHRDracoMeshCompression | IKHRMaterialsClearcoat | IKHRMaterialsIor | IKHRMaterialsUnlit | IKHRMaterialsPbrSpecularGlossiness | IKHRMaterialsSheen | IKHRMaterialsSpecular | IKHRMaterialsTransmission | IKHRMaterialsTranslucency | IKHRMaterialVariants_Mapping | IKHRMaterialVariants_Variants | IKHRTextureBasisU | IKHRTextureTransform | IKHRXmp | IKHRXmp_Node;

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

@@ -11,6 +11,7 @@ import "./KHR_materials_volume";
 import "./KHR_mesh_quantization";
 import "./KHR_texture_basisu";
 import "./KHR_texture_transform";
+import "./KHR_materials_ior";
 import "./GALACEAN_materials_remap";
 import "./GALACEAN_animation_event";
 export { GLTFExtensionParser, GLTFExtensionMode } from "./GLTFExtensionParser";

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

@@ -0,0 +1,7 @@
+import { AnimationClip, AssetPromise } from "@galacean/engine-core";
+import { Parser } from "./Parser";
+import { ParserContext } from "./ParserContext";
+export declare class AnimationParser extends Parser {
+    parse(context: ParserContext): AssetPromise<AnimationClip[]>;
+    private _addCurve;
+}

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

@@ -0,0 +1,7 @@
+import { AssetPromise } from "@galacean/engine-core";
+import { Parser } from "./Parser";
+import { ParserContext } from "./ParserContext";
+export declare class BufferParser extends Parser {
+    parse(context: ParserContext): AssetPromise<void>;
+    private _isGLB;
+}

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

@@ -0,0 +1,9 @@
+import { Parser } from "./Parser";
+import { ParserContext } from "./ParserContext";
+export declare class EntityParser extends Parser {
+    /** @internal */
+    static _defaultName: String;
+    parse(context: ParserContext): void;
+    private _buildEntityTree;
+    private _createSceneRoots;
+}

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

@@ -1,6 +1,6 @@
 import { AssetPromise, ModelMesh, TypedArray } from "@galacean/engine-core";
 import { ModelMeshRestoreInfo } from "../../GLTFContentRestorer";
-import { IGLTF, IMesh, IMeshPrimitive } from "../GLTFSchema";
+import type { IGLTF, IMesh, IMeshPrimitive } from "../GLTFSchema";
 import { GLTFParser } from "./GLTFParser";
 import { BufferInfo, GLTFParserContext } from "./GLTFParserContext";
 export declare class GLTFMeshParser extends GLTFParser {

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

@@ -1,6 +1,6 @@
 import { AnimationClip, AssetPromise, EngineObject, Material, Mesh } from "@galacean/engine-core";
 import { GLTFExtensionMode, GLTFExtensionParser } from "../extensions/GLTFExtensionParser";
-import { GLTFExtensionOwnerSchema } from "../GLTFSchema";
+import type { GLTFExtensionOwnerSchema } from "../GLTFSchema";
 import { GLTFParserContext } from "./GLTFParserContext";
 /**
  * Base class of glTF parser.

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

@@ -1,7 +1,7 @@
 import { AnimationClip, AssetPromise, Buffer, Entity, Material, ModelMesh, Texture2D, TypedArray } from "@galacean/engine-core";
 import { BufferDataRestoreInfo, GLTFContentRestorer } from "../../GLTFContentRestorer";
 import { GLTFResource } from "../GLTFResource";
-import { IGLTF } from "../GLTFSchema";
+import type { IGLTF } from "../GLTFSchema";
 /**
  * @internal
  */

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

@@ -0,0 +1,8 @@
+import { AssetPromise, Material } from "@galacean/engine-core";
+import { Parser } from "./Parser";
+import { ParserContext } from "./ParserContext";
+export declare class MaterialParser extends Parser {
+    /** @internal */
+    static _parseTextureTransform(material: Material, extensions: any, context: ParserContext): void;
+    parse(context: ParserContext): AssetPromise<Material[]>;
+}

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

@@ -0,0 +1,13 @@
+import { AssetPromise, ModelMesh } from "@galacean/engine-core";
+import { Parser } from "./Parser";
+import { ParserContext } from "./ParserContext";
+export declare class MeshParser extends Parser {
+    private static _tempVector3;
+    parse(context: ParserContext): AssetPromise<ModelMesh[][]>;
+    private _parseMeshFromGLTFPrimitive;
+    private _createBlendShape;
+    /**
+     * @deprecated
+     */
+    private _parseMeshFromGLTFPrimitiveDraco;
+}

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

@@ -0,0 +1,21 @@
+import { AnimationClip, AssetPromise, EngineObject, Material, Mesh } from "@galacean/engine-core";
+import { ExtensionParser } from "../extensions/ExtensionParser";
+import { ExtensionSchema } from "../extensions/Schema";
+import { ParserContext } from "./ParserContext";
+export declare abstract class Parser {
+    private static _extensionParsers;
+    static parseEngineResource(extensionName: string, extensionSchema: ExtensionSchema, parseResource: EngineObject, context: ParserContext, ...extra: any[]): void;
+    static createEngineResource<T extends EngineObject>(extensionName: string, extensionSchema: ExtensionSchema, context: ParserContext, ...extra: any[]): T | Promise<T>;
+    static hasExtensionParser(extensionName: string): boolean;
+    static initialize(extensionName: string): void;
+    /**
+     * @internal
+     */
+    static _addExtensionParser(extensionName: string, extensionParser: ExtensionParser): void;
+    abstract parse(context: ParserContext): AssetPromise<any> | void | Material | AnimationClip | Mesh;
+}
+/**
+ * Declare ExtensionParser's decorator.
+ * @param extensionName - Extension name
+ */
+export declare function registerExtension(extensionName: string): (parser: new () => ExtensionParser) => void;

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

@@ -0,0 +1,46 @@
+import { AnimationClip, AssetPromise, Buffer, Entity, Material, ModelMesh, Texture2D, TypedArray } from "@galacean/engine-core";
+import { GLTFResource } from "../GLTFResource";
+import { IGLTF } from "../Schema";
+/**
+ * @internal
+ */
+export declare class ParserContext {
+    gltf: IGLTF;
+    buffers: ArrayBuffer[];
+    glTFResource: GLTFResource;
+    keepMeshData: boolean;
+    hasSkinned: boolean;
+    /** chain asset promise */
+    chainPromises: AssetPromise<any>[];
+    accessorBufferCache: Record<string, BufferInfo>;
+    texturesPromiseInfo: PromiseInfo<Texture2D[]>;
+    materialsPromiseInfo: PromiseInfo<Material[]>;
+    meshesPromiseInfo: PromiseInfo<ModelMesh[][]>;
+    animationClipsPromiseInfo: PromiseInfo<AnimationClip[]>;
+    defaultSceneRootPromiseInfo: PromiseInfo<Entity>;
+    masterPromiseInfo: PromiseInfo<GLTFResource>;
+    promiseMap: Record<string, AssetPromise<any>>;
+    constructor(url: string);
+    private _initPromiseInfo;
+}
+/**
+ * @internal
+ */
+export declare class BufferInfo {
+    data: TypedArray;
+    interleaved: boolean;
+    stride: number;
+    vertexBuffer: Buffer;
+    vertexBindingInfos: Record<number, number>;
+    constructor(data: TypedArray, interleaved: boolean, stride: number);
+}
+/**
+ * @internal
+ */
+export declare class PromiseInfo<T> {
+    promise: AssetPromise<T>;
+    resolve: (value?: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    setProgress: (progress: number) => void;
+    onCancel: (callback: () => void) => void;
+}

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

@@ -0,0 +1,11 @@
+import { AssetPromise, Entity } from "@galacean/engine-core";
+import { Parser } from "./Parser";
+import { ParserContext } from "./ParserContext";
+export declare class SceneParser extends Parser {
+    private static _defaultMaterial;
+    private static _getDefaultMaterial;
+    parse(context: ParserContext): AssetPromise<Entity>;
+    private _createCamera;
+    private _createRenderer;
+    private _createAnimator;
+}

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

@@ -0,0 +1,6 @@
+import { Parser } from "./Parser";
+import { ParserContext } from "./ParserContext";
+export declare class SkinParser extends Parser {
+    parse(context: ParserContext): void;
+    private _findSkeletonRootBone;
+}

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

@@ -0,0 +1,8 @@
+import { AssetPromise, Texture2D } from "@galacean/engine-core";
+import { Parser } from "./Parser";
+import { ParserContext } from "./ParserContext";
+export declare class TextureParser extends Parser {
+    private static _wrapMap;
+    parse(context: ParserContext): AssetPromise<Texture2D[]>;
+    private _parseSampler;
+}

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

@@ -0,0 +1,5 @@
+import { Parser } from "./Parser";
+import { ParserContext } from "./ParserContext";
+export declare class Validator extends Parser {
+    parse(context: ParserContext): 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";