@galacean/engine-loader 1.6.8 → 1.6.9

package/types/gltf/GLTFUtils.d.ts

@@ -0,0 +1,45 @@
+import { AssetPromise, IndexFormat, Texture2D, TypedArray, VertexElementFormat } from "@galacean/engine-core";
+import { Color, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { AccessorComponentType, AccessorType, IAccessor, IBufferView, IGLTF, ISampler, ISamplerInfo } from "./GLTFSchema";
+import { BufferInfo, GLTFParserContext } from "./parser/GLTFParserContext";
+/**
+ * @internal
+ */
+export declare class GLTFUtils {
+    static floatBufferToVector2Array(buffer: Float32Array): Vector2[];
+    static floatBufferToVector3Array(buffer: Float32Array): Vector3[];
+    static floatBufferToVector4Array(buffer: Float32Array): Vector4[];
+    static floatBufferToColorArray(buffer: Float32Array, isColor3: boolean): Color[];
+    /**
+     * Get the number of bytes occupied by accessor type.
+     */
+    static getAccessorTypeSize(accessorType: AccessorType): number;
+    /**
+     * Get the TypedArray corresponding to the component type.
+     */
+    static getComponentType(componentType: AccessorComponentType): Float32ArrayConstructor | Uint32ArrayConstructor | Uint8ArrayConstructor | Uint16ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor;
+    static getNormalizedComponentScale(componentType: AccessorComponentType): number;
+    static getAccessorBuffer(context: GLTFParserContext, bufferViews: IBufferView[], accessor: IAccessor): AssetPromise<BufferInfo>;
+    static bufferToVector3Array(buffer: TypedArray, byteOffset: number, count: number, normalized: boolean, componentType: AccessorComponentType): Vector3[];
+    static getBufferViewData(bufferView: IBufferView, buffers: ArrayBuffer[]): ArrayBuffer;
+    /**
+     * Get accessor data.
+     */
+    static processingSparseData(context: GLTFParserContext, accessor: IAccessor, bufferInfo: BufferInfo): AssetPromise<void>;
+    static getIndexFormat(type: AccessorComponentType): IndexFormat;
+    static getElementFormat(type: AccessorComponentType, size: number, normalized?: boolean): VertexElementFormat;
+    /**
+     * Load image buffer
+     */
+    static loadImageBuffer(imageBuffer: TypedArray, type: string): Promise<HTMLImageElement>;
+    /**
+     * Parse the glb format.
+     */
+    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,26 @@
+declare module "@galacean/engine-core" {
+    interface EngineConfiguration {
+        glTFLoader?: {
+            /** Meshopt options. If set this option and workCount is great than 0, workers will be created. */
+            meshOpt?: {
+                /**
+                 * Worker count for transcoder.
+                 * @defaultValue 4
+                 */
+                workerCount?: number;
+            };
+        };
+        /** @deprecated 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.
+                 * @defaultValue 4
+                 */
+                workerCount?: number;
+            };
+        };
+    }
+}
+export {};

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

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

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

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

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

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

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

@@ -0,0 +1,46 @@
+import { AssetPromise, EngineObject } from "@galacean/engine-core";
+import { GLTFExtensionOwnerSchema } from "../GLTFSchema";
+import { GLTFParserContext } from "../parser/GLTFParserContext";
+import { GLTFExtensionSchema } from "./GLTFExtensionSchema";
+/**
+ * Base class of glTF extension parser.
+ */
+export declare abstract class GLTFExtensionParser {
+    /**
+     * @internal
+     * The extension mode.
+     */
+    _mode: GLTFExtensionMode;
+    /**
+     * Create and parse the resource.
+     * @remarks This method overrides the default resource creation.
+     * @param context - The parser context
+     * @param extensionSchema - The extension schema
+     * @param extensionOwnerSchema - The extension owner schema
+     * @returns The resource or promise
+     */
+    createAndParse(context: GLTFParserContext, extensionSchema: GLTFExtensionSchema, extensionOwnerSchema: GLTFExtensionOwnerSchema, ...extra: any[]): EngineObject | AssetPromise<EngineObject | Uint8Array>;
+    /**
+     * Additive parse to the resource.
+     * @param context - The parser context
+     * @param parseResource - The parsed resource
+     * @param extensionSchema - The extension schema
+     * @param extensionOwnerSchema - The extension owner schema
+     * @returns The void or promise
+     */
+    additiveParse(context: GLTFParserContext, parseResource: EngineObject, extensionSchema: GLTFExtensionSchema, extensionOwnerSchema: GLTFExtensionOwnerSchema, ...extra: any[]): void | AssetPromise<void>;
+}
+/**
+ * glTF Extension mode.
+ */
+export declare enum GLTFExtensionMode {
+    /**
+     * Cerate instance and parse mode.
+     * @remarks
+     * If the glTF property has multiple extensions of `CreateAndParse` mode, only execute the last one.
+     * If this method is registered, the default pipeline processing will be ignored.
+     */
+    CreateAndParse = 0,
+    /** Additive parse mode. */
+    AdditiveParse = 1
+}

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

@@ -0,0 +1,168 @@
+import type { IMaterialNormalTextureInfo, ITextureInfo } from "../GLTFSchema";
+/**
+ * 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_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_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;
+    specularColorTexture?: 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;
+}
+/**
+ * Interfaces from the KHR_materials_clearcoat extension
+ */
+export interface IKHRMaterialsAnisotropy {
+    anisotropyStrength: number;
+    anisotropyRotation: number;
+    anisotropyTexture: ITextureInfo;
+}
+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 IEXTMeshoptCompressionSchema {
+    buffer: number;
+    byteOffset?: number;
+    byteLength: number;
+    byteStride: number;
+    mode: "ATTRIBUTES" | "TRIANGLES" | "INDICES";
+    count: number;
+    filter?: "NONE" | "OCTAHEDRAL" | "QUATERNION" | "EXPONENTIAL";
+}
+export interface IGalaceanMaterialRemap {
+    refId: string;
+    key?: string;
+    isClone?: boolean;
+}
+export interface IGalaceanAnimation {
+    events: {
+        time: number;
+        functionName: string;
+        parameter: any;
+    }[];
+}
+/**
+ * Interfaces from the KHR_materials_iridescence extension
+ */
+export interface IKHRMaterialsIridescence {
+    iridescenceFactor?: number;
+    iridescenceTexture?: ITextureInfo;
+    iridescenceIor?: number;
+    iridescenceThicknessMinimum?: number;
+    iridescenceThicknessMaximum?: number;
+    iridescenceThicknessTexture?: ITextureInfo;
+}
+/**
+ * Interfaces from the KHR_materials_volume extension
+ */
+export interface IKHRMaterialsVolume {
+    thicknessFactor?: number;
+    thicknessTexture?: ITextureInfo;
+    attenuationDistance?: number;
+    attenuationColor?: number[];
+}
+export type GLTFExtensionSchema = IKHRLightsPunctual_Light | IKHRMaterialsClearcoat | IKHRMaterialsIor | IKHRMaterialsUnlit | IKHRMaterialsSheen | IKHRMaterialsSpecular | IKHRMaterialsTransmission | IKHRMaterialsTranslucency | IKHRMaterialVariants_Mapping | IKHRMaterialVariants_Variants | IKHRMaterialsAnisotropy | IKHRTextureBasisU | IKHRTextureTransform | IKHRXmp | IKHRXmp_Node | IGalaceanAnimation | IKHRMaterialsIridescence | IKHRMaterialsVolume | Object;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { Material, Renderer } from "@galacean/engine-core";
+export type IGLTFExtensionVariants = Array<{
+    renderer: Renderer;
+    material: Material;
+    variants: string[];
+}>;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+import "./KHR_lights_punctual";
+import "./KHR_materials_clearcoat";
+import "./KHR_materials_ior";
+import "./KHR_materials_sheen";
+import "./KHR_materials_transmission";
+import "./KHR_materials_unlit";
+import "./KHR_materials_variants";
+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";
+import "./EXT_meshopt_compression";
+import "./KHR_materials_anisotropy";
+import "./KHR_materials_iridescence";
+import "./KHR_materials_specular";
+import "./EXT_texture_webp";
+export { GLTFExtensionParser, GLTFExtensionMode } from "./GLTFExtensionParser";
+export * from "./GLTFExtensionSchema";

package/types/gltf/index.d.ts

@@ -0,0 +1,6 @@
+export { GLTFResource } from "./GLTFResource";
+export { GLTFUtils } from "./GLTFUtils";
+export * from "./parser";
+export * from "./extensions/index";
+export { AccessorType } from "./GLTFSchema";
+export type { IMaterial, IMeshPrimitive, ITextureInfo, INode, GLTFExtensionOwnerSchema, IGLTF, IMesh } from "./GLTFSchema";

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

@@ -0,0 +1,12 @@
+import { AnimationClip, AssetPromise } from "@galacean/engine-core";
+import { IAnimation } from "../GLTFSchema";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFAnimationParser extends GLTFParser {
+    /**
+     * @internal
+     */
+    static _parseStandardProperty(context: GLTFParserContext, animationClip: AnimationClip, animationInfo: IAnimation): AssetPromise<AnimationClip>;
+    private static _addCurve;
+    parse(context: GLTFParserContext, index: number): AssetPromise<AnimationClip>;
+}

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

@@ -0,0 +1,7 @@
+import { AnimatorController, AssetPromise } from "@galacean/engine-core";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFAnimatorControllerParser extends GLTFParser {
+    parse(context: GLTFParserContext): AssetPromise<AnimatorController>;
+    private _createAnimatorController;
+}

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

@@ -0,0 +1,7 @@
+import { AssetPromise } from "@galacean/engine-core";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFBufferParser extends GLTFParser {
+    parse(context: GLTFParserContext, index: number): AssetPromise<ArrayBuffer>;
+    private _parseSingleBuffer;
+}

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

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

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

@@ -0,0 +1,6 @@
+import { Entity } from "@galacean/engine-core";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFEntityParser extends GLTFParser {
+    parse(context: GLTFParserContext, index: number): Entity;
+}

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

@@ -0,0 +1,15 @@
+import { AssetPromise, Material, PBRMaterial, UnlitMaterial } from "@galacean/engine-core";
+import { IMaterial, ITextureInfo } from "../GLTFSchema";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFMaterialParser extends GLTFParser {
+    /**
+     * @internal
+     */
+    static _checkOtherTextureTransform(texture: ITextureInfo, textureName: string): void;
+    /**
+     * @internal
+     */
+    static _parseStandardProperty(context: GLTFParserContext, material: UnlitMaterial | PBRMaterial, materialInfo: IMaterial): void;
+    parse(context: GLTFParserContext, index: number): AssetPromise<Material>;
+}

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

@@ -0,0 +1,20 @@
+import { AssetPromise, ModelMesh } from "@galacean/engine-core";
+import { ModelMeshRestoreInfo } from "../../GLTFContentRestorer";
+import type { IGLTF, IMesh, IMeshPrimitive } from "../GLTFSchema";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFMeshParser extends GLTFParser {
+    private static _tempVector3;
+    /**
+     * @internal
+     */
+    static _parseMeshFromGLTFPrimitive(context: GLTFParserContext, mesh: ModelMesh, meshRestoreInfo: ModelMeshRestoreInfo, gltfMesh: IMesh, gltfPrimitive: IMeshPrimitive, gltf: IGLTF, keepMeshData: boolean): AssetPromise<ModelMesh>;
+    private static _getBlendShapeData;
+    /**
+     * @internal
+     */
+    static _createBlendShape(context: GLTFParserContext, mesh: ModelMesh, meshRestoreInfo: ModelMeshRestoreInfo, glTFMesh: IMesh, gltfPrimitive: IMeshPrimitive, glTFTargets: {
+        [name: string]: number;
+    }[]): AssetPromise<void>;
+    parse(context: GLTFParserContext, index: number): AssetPromise<ModelMesh[]>;
+}

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

@@ -0,0 +1,57 @@
+import { AssetPromise, EngineObject } from "@galacean/engine-core";
+import type { GLTFExtensionOwnerSchema } from "../GLTFSchema";
+import { GLTFExtensionMode, GLTFExtensionParser } from "../extensions/GLTFExtensionParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+/**
+ * Base class of glTF parser.
+ */
+export declare abstract class GLTFParser {
+    private static readonly _extensionParsers;
+    /**
+     * Execute all parses of extension to create resource.
+     * @param extensions - Related extensions field
+     * @param context - The parser context
+     * @param ownerSchema - The extension owner schema
+     * @param extra - Extra params
+     * @returns
+     */
+    static executeExtensionsCreateAndParse(extensions: {
+        [key: string]: any;
+    }, context: GLTFParserContext, ownerSchema: GLTFExtensionOwnerSchema, ...extra: any[]): EngineObject | void | AssetPromise<EngineObject | Uint8Array | void>;
+    /**
+     * Execute all parses of extension to parse resource.
+     * @param extensions - Related extensions field
+     * @param context - The parser context
+     * @param parseResource -  The parsed resource
+     * @param ownerSchema - The extension owner schema
+     * @param extra - Extra params
+     */
+    static executeExtensionsAdditiveAndParse(extensions: {
+        [key: string]: any;
+    }, context: GLTFParserContext, parseResource: EngineObject, ownerSchema: GLTFExtensionOwnerSchema, ...extra: any[]): void;
+    /**
+     * Whether the plugin is registered.
+     * @param extensionName - Extension name
+     * @returns Boolean
+     */
+    static hasExtensionParser(extensionName: string): boolean;
+    /**
+     * Get the last plugin by glTF extension mode.
+     * @param extensionName - Extension name
+     * @param mode - GLTF extension mode
+     * @returns GLTF extension parser
+     */
+    static getExtensionParser(extensionName: string, mode: GLTFExtensionMode): GLTFExtensionParser | undefined;
+    /**
+     * @internal
+     */
+    static _addExtensionParser(extensionName: string, extensionParser: GLTFExtensionParser): void;
+    private static _createAndParse;
+    private static _additiveParse;
+    abstract parse(context: GLTFParserContext, index?: number): any;
+}
+/**
+ * Declare ExtensionParser's decorator.
+ * @param extensionName - Extension name
+ */
+export declare function registerGLTFExtension(extensionName: string, mode: GLTFExtensionMode): (parser: new () => GLTFExtensionParser) => void;

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

@@ -0,0 +1,74 @@
+import { AssetPromise, 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";
+/**
+ * @internal
+ */
+export declare class GLTFParserContext {
+    glTFResource: GLTFResource;
+    resourceManager: ResourceManager;
+    params: GLTFParams;
+    private static readonly _parsers;
+    static addParser(parserType: GLTFParserType, parser: GLTFParser): void;
+    glTF: IGLTF;
+    accessorBufferCache: Record<string, BufferInfo>;
+    contentRestorer: GLTFContentRestorer;
+    buffers?: ArrayBuffer[];
+    needAnimatorController: boolean;
+    /** @internal */
+    _getPromises: AssetPromise<unknown>[];
+    private _resourceCache;
+    private _progress;
+    /** @internal */
+    _setTaskCompleteProgress: (loaded: number, total: number) => void;
+    /** @internal */
+    _setTaskDetailProgress: (url: string, loaded: number, total: number) => void;
+    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): AssetPromise<T>;
+    get<T>(type: GLTFParserType.Validator): AssetPromise<T>;
+    get<T>(type: GLTFParserType.AnimatorController): AssetPromise<T>;
+    get<T>(type: GLTFParserType, index: number): AssetPromise<T>;
+    get<T>(type: GLTFParserType): AssetPromise<T[]>;
+    parse(): AssetPromise<GLTFResource>;
+    /**
+     * @internal
+     */
+    _onTaskDetail: (url: string, loaded: number, total: number) => void;
+    /**
+     * @internal
+     */
+    _addTaskCompletePromise(taskPromise: AssetPromise<any>): void;
+    private _handleSubAsset;
+}
+/**
+ * @internal
+ */
+export declare class BufferInfo {
+    data: TypedArray;
+    interleaved: boolean;
+    stride: number;
+    vertexBuffer: Buffer;
+    vertexBindingInfos: Record<number, number>;
+    restoreInfo: BufferDataRestoreInfo;
+    constructor(data: TypedArray, interleaved: boolean, stride: number);
+}
+export declare enum GLTFParserType {
+    Schema = 0,
+    Validator = 1,
+    Scene = 2,
+    Buffer = 3,
+    BufferView = 4,
+    Texture = 5,
+    Material = 6,
+    Mesh = 7,
+    Entity = 8,
+    Skin = 9,
+    Animation = 10,
+    AnimatorController = 11
+}
+export declare function registerGLTFParser(pipeline: GLTFParserType): (Parser: new () => GLTFParser) => void;

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

@@ -0,0 +1,11 @@
+import { AssetPromise, Entity } from "@galacean/engine-core";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFSceneParser extends GLTFParser {
+    parse(context: GLTFParserContext, index: number): AssetPromise<Entity>;
+    private _parseEntityComponent;
+    private _createCamera;
+    private _createRenderer;
+    private _computeLocalBounds;
+    private _computeApproximateBindMatrix;
+}

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

@@ -0,0 +1,6 @@
+import { IGLTF } from "../GLTFSchema";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFSchemaParser extends GLTFParser {
+    parse(context: GLTFParserContext): Promise<IGLTF>;
+}

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

@@ -0,0 +1,7 @@
+import { AssetPromise, Skin } from "@galacean/engine-core";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFSkinParser extends GLTFParser {
+    parse(context: GLTFParserContext, index: number): AssetPromise<Skin>;
+    private _findSkeletonRootBone;
+}

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

@@ -0,0 +1,15 @@
+import { AssetPromise, Texture, Texture2D, TextureWrapMode } from "@galacean/engine-core";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFTextureParser extends GLTFParser {
+    /** @internal */
+    static _wrapMap: {
+        33071: TextureWrapMode;
+        33648: TextureWrapMode;
+        10497: TextureWrapMode;
+    };
+    /** @internal */
+    static _parseTexture(context: GLTFParserContext, imageIndex: number, textureIndex: number, sampler?: number, textureName?: string, isSRGBColorSpace?: boolean): AssetPromise<Texture2D>;
+    parse(context: GLTFParserContext, textureIndex: number): AssetPromise<Texture>;
+    private _isSRGBColorSpace;
+}