@galacean/engine-loader 1.2.0-beta.6 → 1.3.0-alpha.1

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/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/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/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/index.d.ts

@@ -4,6 +4,7 @@ import "./BufferLoader";
 import "./EnvLoader";
 import "./FontLoader";
 import "./GLTFLoader";
+import "./PrefabLoader";
 import "./HDRLoader";
 import "./JSONLoader";
 import "./KTXCubeLoader";
@@ -27,3 +28,5 @@ export * from "./gltf";
 export { KTX2Loader, KTX2Transcoder } from "./ktx2/KTX2Loader";
 export { KTX2TargetFormat } from "./ktx2/KTX2TargetFormat";
 export * from "./resource-deserialize";
+export * from "./prefab/PrefabResource";
+export { PrefabLoader } from "./PrefabLoader";

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

@@ -0,0 +1,13 @@
+import { KTX2TargetFormat } from "../KTX2TargetFormat";
+import { TranscodeResult } from "../TranscodeResult";
+/** @internal */
+export declare class BinomialLLCTranscoder {
+    readonly workerLimit: number;
+    static MessageId: number;
+    private _transcodeWorkerPool;
+    private _initPromise;
+    constructor(workerLimit: number);
+    init(): Promise<any>;
+    transcode(buffer: ArrayBuffer, format: KTX2TargetFormat): Promise<TranscodeResult>;
+    destroy(): void;
+}

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

@@ -0,0 +1,33 @@
+type MessageType = "init" | "transcode";
+export interface IBaseMessage {
+    type: MessageType;
+}
+export interface IInitMessage extends IBaseMessage {
+    type: "init";
+    transcoderWasm: ArrayBuffer;
+}
+export interface ITranscodeMessage extends IBaseMessage {
+    type: "transcode";
+    format: number;
+    buffer: ArrayBuffer;
+}
+export type IMessage = IInitMessage | ITranscodeMessage;
+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;
+/** @internal */
+export declare function TranscodeWorkerCode(): void;
+export {};

package/types/ktx2/KhronosTranscoder/KhronosTranscoder.d.ts

@@ -0,0 +1,17 @@
+import { KTX2Container } from "../KTX2Container";
+import { KTX2TargetFormat } from "../KTX2TargetFormat";
+import { TranscodeResult } from "./TranscoderWorkerCode";
+/** @internal */
+export declare class KhronosTranscoder {
+    readonly workerLimit: number;
+    readonly type: KTX2TargetFormat;
+    static transcoderMap: {
+        0: string;
+    };
+    private _transcodeWorkerPool;
+    private _initPromise;
+    constructor(workerLimit: number, type: KTX2TargetFormat);
+    init(): Promise<any>;
+    transcode(ktx2Container: KTX2Container): Promise<TranscodeResult>;
+    destroy(): void;
+}

package/types/ktx2/KhronosTranscoder/TranscoderWorkerCode.d.ts

@@ -0,0 +1,34 @@
+export interface EncodedData {
+    buffer: Uint8Array;
+    levelWidth: number;
+    levelHeight: number;
+    uncompressedByteLength: number;
+}
+type MessageType = "init" | "transcode";
+export interface IBaseMessage {
+    type: MessageType;
+}
+export interface IInitMessage extends IBaseMessage {
+    type: "init";
+    transcoderWasm: ArrayBuffer;
+}
+export interface ITranscodeMessage extends IBaseMessage {
+    type: "transcode";
+    format: number;
+    needZstd: boolean;
+    data: EncodedData[][];
+}
+export type IMessage = IInitMessage | ITranscodeMessage;
+export type TranscodeResult = {
+    data: Array<{
+        data: Uint8Array;
+        width: number;
+        height: number;
+    }>;
+};
+export type TranscodeResponse = {
+    id: number;
+    type: "transcoded";
+} & TranscodeResult;
+export declare function TranscodeWorkerCode(): void;
+export {};

package/types/ktx2/TranscodeResult.d.ts

@@ -0,0 +1,10 @@
+export interface TranscodeResult {
+    width: number;
+    height: number;
+    hasAlpha: boolean;
+    mipmaps: Array<{
+        data: Uint8Array;
+        width: number;
+        height: number;
+    }>;
+}

package/types/ktx2/constants.d.ts

@@ -0,0 +1,7 @@
+export declare enum SupercompressionScheme {
+    None = 0,
+    BasisLZ = 1,
+    Zstd = 2,
+    ZLib = 3
+}
+export declare const KHR_DF_SAMPLE_DATATYPE_SIGNED = 64;

package/types/ktx2/zstddec.d.ts

@@ -0,0 +1,62 @@
+/**
+ * From https://github.com/donmccurdy/zstddec by Don McCurdy
+ */
+interface DecoderExports {
+    memory: Uint8Array;
+    ZSTD_findDecompressedSize: (compressedPtr: number, compressedSize: number) => number;
+    ZSTD_decompress: (uncompressedPtr: number, uncompressedSize: number, compressedPtr: number, compressedSize: number) => number;
+    malloc: (ptr: number) => number;
+    free: (ptr: number) => void;
+}
+/**
+ * ZSTD (Zstandard) decoder.
+ */
+export declare class ZSTDDecoder {
+    static heap: Uint8Array;
+    static IMPORT_OBJECT: {
+        env: {
+            emscripten_notify_memory_growth: () => void;
+        };
+    };
+    static instance: {
+        exports: DecoderExports;
+    };
+    static WasmModuleURL: string;
+    _initPromise: Promise<any>;
+    init(): Promise<void>;
+    _init(result: WebAssembly.WebAssemblyInstantiatedSource): void;
+    decode(array: Uint8Array, uncompressedSize?: number): Uint8Array;
+}
+export {};
+/**
+ * BSD License
+ *
+ * For Zstandard software
+ *
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ *  * Neither the name Facebook nor the names of its contributors may be used to
+ *    endorse or promote products derived from this software without specific
+ *    prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */

package/types/prefab/PrefabParser.d.ts

@@ -0,0 +1,11 @@
+import { Engine, Entity } from "@galacean/engine-core";
+import { HierarchyParser } from "../resource-deserialize/resources/parser/HierarchyParser";
+import { PrefabResource } from "./PrefabResource";
+import { IHierarchyFile, ParserContext } from "../resource-deserialize";
+export declare class PrefabParser extends HierarchyParser<PrefabResource, ParserContext<IHierarchyFile, Entity>> {
+    readonly prefabResource: PrefabResource;
+    static parse(engine: Engine, url: string, data: IHierarchyFile): Promise<PrefabResource>;
+    constructor(data: IHierarchyFile, context: ParserContext<IHierarchyFile, Entity>, prefabResource: PrefabResource);
+    protected _handleRootEntity(id: string): void;
+    protected _clearAndResolve(): PrefabResource;
+}

package/types/prefab/PrefabResource.d.ts

@@ -0,0 +1,25 @@
+import { Engine, Entity, ReferResource } from "@galacean/engine-core";
+/**
+ * The Prefab resource.
+ */
+export declare class PrefabResource extends ReferResource {
+    readonly url: string;
+    /** @internal */
+    _root: Entity;
+    private _dependenceAssets;
+    /**
+     * @internal
+     * @param url - The url of the prefab
+     */
+    constructor(engine: Engine, url: string);
+    /**
+     * Instantiate prefab.
+     * @returns prefab's root entity
+     */
+    instantiate(): Entity;
+    /**
+     * @internal
+     */
+    _addDependenceAsset(resource: ReferResource): void;
+    protected _onDestroy(): void;
+}

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

@@ -2,7 +2,6 @@ import { Engine } from "@galacean/engine-core";
 export { MeshDecoder } from "./resources/mesh/MeshDecoder";
 export { Texture2DDecoder } from "./resources/texture2D/TextureDecoder";
 export { ReflectionParser } from "./resources/parser/ReflectionParser";
-export { PrefabParser } from "./resources/prefab/PrefabParser";
 export * from "./resources/animationClip/AnimationClipDecoder";
 export type { IModelMesh } from "./resources/mesh/IModelMesh";
 /**

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

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

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

@@ -1,29 +1,30 @@
-import { Component, EngineObject, Entity, ResourceManager } from "@galacean/engine-core";
-import type { IEntity } from "../schema";
+import { Component, Engine, EngineObject, Entity, ReferResource, ResourceManager, Scene } from "@galacean/engine-core";
+import type { IEntity, IHierarchyFile } from "../schema";
+export declare enum ParserType {
+    Prefab = 0,
+    Scene = 1
+}
 /**
  * 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;
+export declare class ParserContext<T extends IHierarchyFile, I extends EngineObject> {
+    readonly engine: Engine;
+    readonly type: ParserType;
+    readonly resource: ReferResource | Scene;
     entityMap: Map<string, Entity>;
-    components: Map<string, Component>;
-    assets: Map<string, any>;
     entityConfigMap: Map<string, IEntity>;
+    components: Map<string, Component>;
     rootIds: string[];
     strippedIds: string[];
     readonly resourceManager: ResourceManager;
-    constructor(originalData: T, engine: any, target?: I);
+    constructor(engine: Engine, type: ParserType, resource: ReferResource | Scene);
     /**
      * Destroy the context.
-     * @abstract
      * @memberof ParserContext
      */
-    destroy(): void;
+    clear(): void;
 }

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

@@ -1,11 +1,11 @@
 import { EngineObject, Entity } from "@galacean/engine-core";
-import type { IBasicType, IClassObject, IEntity, IPrefabFile } from "../schema";
+import type { IBasicType, IClassObject, IEntity, IHierarchyFile } from "../schema";
 import { ParserContext } from "./ParserContext";
 export declare class ReflectionParser {
     private readonly _context;
     static customParseComponentHandles: Map<string, Function>;
     static registerCustomParseComponent(componentType: string, handle: Function): void;
-    constructor(_context: ParserContext<IPrefabFile, EngineObject>);
+    constructor(_context: ParserContext<IHierarchyFile, EngineObject>);
     parseEntity(entityConfig: IEntity): Promise<Entity>;
     parseClassObject(item: IClassObject): Promise<any>;
     parsePropsAndMethods(instance: any, item: Omit<IClassObject, "class">): Promise<any>;