@galacean/engine-loader 0.0.0-experimental-animator-additive.1

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

@@ -0,0 +1,6 @@
+import { AssetPromise } from "@oasis-engine/core";
+import { GLTFParser } from "./GLTFParser";
+import { GLTFParserContext } from "./GLTFParserContext";
+export declare class GLTFValidator extends GLTFParser {
+    parse(context: GLTFParserContext): AssetPromise<void>;
+}

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

@@ -0,0 +1,11 @@
+export { GLTFAnimationParser } from "./GLTFAnimationParser";
+export { GLTFBufferParser } from "./GLTFBufferParser";
+export { GLTFEntityParser } from "./GLTFEntityParser";
+export { GLTFMaterialParser } from "./GLTFMaterialParser";
+export { GLTFMeshParser } from "./GLTFMeshParser";
+export { GLTFParser, registerGLTFExtension } from "./GLTFParser";
+export { GLTFSceneParser } from "./GLTFSceneParser";
+export { GLTFSkinParser } from "./GLTFSkinParser";
+export { GLTFTextureParser } from "./GLTFTextureParser";
+export { GLTFValidator } from "./GLTFValidator";
+export { GLTFParserContext } from "./GLTFParserContext";

package/types/index.d.ts

@@ -0,0 +1,23 @@
+import "./AnimatorControllerLoader";
+import "./BufferLoader";
+import "./EnvLoader";
+import "./FontLoader";
+import "./gltf/extensions/index";
+import "./GLTFLoader";
+import "./HDRLoader";
+import "./JSONLoader";
+import "./KTXCubeLoader";
+import "./KTXLoader";
+import "./MaterialLoader";
+import "./MeshLoader";
+import "./SourceFontLoader";
+import "./SpriteAtlasLoader";
+import "./SpriteLoader";
+import "./Texture2DLoader";
+import "./TextureCubeLoader";
+export { parseSingleKTX } from "./compressed-texture";
+export { GLTFResource } from "./gltf/GLTFResource";
+export type { GLTFParams } from "./GLTFLoader";
+export * from "./resource-deserialize";
+export * from "./SceneLoader";
+export type { Texture2DParams } from "./Texture2DLoader";

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

@@ -0,0 +1,18 @@
+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 * from "./resources/animationClip/AnimationClipDecoder";
+export type { IModelMesh } from "./resources/mesh/IModelMesh";
+/**
+ * Decode engine binary resource.
+ * @param arrayBuffer - array buffer of decode binary file
+ * @param engine - engine
+ * @returns
+ */
+export declare function decode<T>(arrayBuffer: ArrayBuffer, engine: Engine): Promise<T>;
+export * from "./resources/prefab/PrefabDesign";
+export * from "./resources/scene/SceneParser";
+export * from "./resources/scene/MeshLoader";
+export * from "./resources/scene/EditorTextureLoader";

package/types/resource-deserialize/resources/animationClip/AnimationClipDecoder.d.ts

@@ -0,0 +1,17 @@
+import { AnimationClip, Engine } from "@galacean/engine-core";
+import type { BufferReader } from "../../utils/BufferReader";
+export { ComponentMap } from "./ComponentMap";
+export declare enum InterpolableValueType {
+    Float = 0,
+    FloatArray = 1,
+    Vector2 = 2,
+    Vector3 = 3,
+    Vector4 = 4,
+    Quaternion = 5,
+    Color = 6,
+    Array = 7,
+    Boolean = 8
+}
+export declare class AnimationClipDecoder {
+    static decode(engine: Engine, bufferReader: BufferReader): Promise<AnimationClip>;
+}

package/types/resource-deserialize/resources/animationClip/ComponentMap.d.ts

@@ -0,0 +1,2 @@
+import { Component, Entity } from "@galacean/engine-core";
+export declare const ComponentMap: Record<string, new (entity: Entity) => Component>;

package/types/resource-deserialize/resources/animationClip/type.d.ts

@@ -0,0 +1,30 @@
+import { AnimationProperty, InterpolableValueType } from "@oasis-engine/core";
+export declare enum ComponentClass {
+    Transform = 0,
+    SkinnedMeshRenderer = 1,
+    Other = 2
+}
+export declare const PropertyNameMap: string[];
+export interface IAnimationClipAsset {
+    objectId: string;
+    name: string;
+    events: Array<{
+        time: number;
+        functionName: string;
+        parameter: string;
+    }>;
+    curveBindings: Array<{
+        relativePath: string;
+        property: AnimationProperty;
+        curve: {
+            interpolation: number;
+            keys: Array<{
+                time: number;
+                value: any;
+                inTangent: any;
+                outTangent: any;
+            }>;
+            valueType: InterpolableValueType;
+        };
+    }>;
+}

package/types/resource-deserialize/resources/animatorController/AnimatorControllerDecoder.d.ts

@@ -0,0 +1,6 @@
+import { Engine, AnimatorController, AnimationClip } from "@oasis-engine/core";
+import type { BufferReader } from "../../utils/BufferReader";
+export declare class AnimatorControllerDecoder {
+    static decode(engine: Engine, bufferReader: BufferReader): Promise<AnimatorController>;
+    static loadAndSetClip(engine: Engine, path: string, objectId: string): Promise<AnimationClip>;
+}

package/types/resource-deserialize/resources/mesh/MeshDecoder.d.ts

@@ -0,0 +1,9 @@
+import { ModelMesh } from "@galacean/engine-core";
+import type { Engine } from "@galacean/engine-core";
+import type { BufferReader } from "../../utils/BufferReader";
+/**
+ * @todo refactor
+ */
+export declare class MeshDecoder {
+    static decode(engine: Engine, bufferReader: BufferReader): Promise<ModelMesh>;
+}

package/types/resource-deserialize/resources/mesh/type.d.ts

@@ -0,0 +1,31 @@
+type uint8 = number;
+type uint16 = number;
+type uint32 = number;
+export interface IMeshData {
+    objectId: string;
+    name: string;
+    vertexElements: Array<{
+        semantic: string;
+        offset: uint32;
+        format: uint8;
+        bindingIndex: uint8;
+        instanceStepRate: uint8;
+    }>;
+    subMeshes: Array<{
+        start: uint32;
+        count: uint32;
+        topology: uint8;
+    }>;
+    vertexBuffer: {
+        bufferUsage: uint8;
+        buffer: ArrayBuffer;
+        stride: uint16;
+    };
+    hasIndexBuffer: boolean;
+    indexBuffer?: {
+        bufferUsage: uint8;
+        buffer: ArrayBuffer;
+        format: uint8;
+    };
+}
+export {};

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

@@ -0,0 +1,70 @@
+import type { BackgroundMode } from "@galacean/engine-core";
+import { IRefObject } from "@galacean/engine-core/types/asset/IRefObject";
+import { IColor } from "../mesh/IModelMesh";
+export interface IPrefabFile {
+    entities: Array<IEntity>;
+}
+export interface IScene extends IPrefabFile {
+    scene: {
+        background: {
+            mode: BackgroundMode;
+            color: IColor;
+            texture?: IRefObject;
+            sky?: IRefObject;
+        };
+        ambient: {
+            ambientLight: IRefObject;
+            diffuseSolidColor: IColor;
+            diffuseIntensity: number;
+            specularIntensity: number;
+        };
+    };
+    files: Array<{
+        id: string;
+        type: string;
+        virtualPath: string;
+        path: string;
+    }>;
+}
+export interface IVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface IBasicEntity {
+    name?: string;
+    id?: string;
+    components?: Array<IComponent>;
+    isActive?: boolean;
+    position?: IVector3;
+    rotation?: IVector3;
+    scale?: IVector3;
+    children?: Array<string>;
+    parent?: string;
+}
+export type IEntity = IBasicEntity | IRefEntity;
+export interface IRefEntity extends IBasicEntity {
+    assetRefId: string;
+    key?: string;
+    isClone?: boolean;
+}
+export type IComponent = {
+    id: string;
+    refId?: string;
+} & IClassObject;
+export type IMethodParams = Array<IBasicType>;
+export type IClassObject = {
+    class: string;
+    constructParams?: IMethodParams;
+    methods?: {
+        [methodName: string]: Array<IMethodParams>;
+    };
+    props?: {
+        [key: string]: IBasicType | IMethodParams;
+    };
+};
+export type IBasicType = string | number | boolean | null | undefined | IAssetRef | IClassObject | IMethodParams;
+export type IAssetRef = {
+    key?: string;
+    refId: string;
+};

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

@@ -0,0 +1,5 @@
+import { Entity } from "@galacean/engine-core";
+import type { IEntity } from "./PrefabDesign";
+export declare class PrefabParser {
+    static parseChildren(entitiesConfig: Map<string, IEntity>, entities: Map<string, Entity>, parentId: string): void;
+}

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

@@ -0,0 +1,14 @@
+import { Engine, Entity } from "@galacean/engine-core";
+import { IBasicType, IClassObject, IEntity } from "./PrefabDesign";
+export declare class ReflectionParser {
+    static customParseComponentHandles: Map<string, Function>;
+    static registerCustomParseComponent(componentType: string, handle: Function): void;
+    static parseEntity(entityConfig: IEntity, engine: Engine): Promise<Entity>;
+    private static getEntityByConfig;
+    static parseClassObject(item: IClassObject, engine: Engine, resourceManager?: any): Promise<any>;
+    static parseBasicType(value: IBasicType, engine: Engine, resourceManager?: any): Promise<any>;
+    static parsePropsAndMethods(instance: any, item: Omit<IClassObject, "class">, engine: Engine, resourceManager?: any): Promise<any>;
+    static parseMethod(instance: any, methodName: string, methodParams: Array<IBasicType>, engine: Engine, resourceManager?: any): Promise<any>;
+    private static _isClass;
+    private static _isRef;
+}

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

@@ -0,0 +1,4 @@
+import { AssetPromise, Loader, LoadItem, ResourceManager, Texture2D } from "@galacean/engine-core";
+export declare class EditorTextureLoader extends Loader<Texture2D> {
+    load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Texture2D>;
+}

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

@@ -0,0 +1,4 @@
+import { AssetPromise, Loader, LoadItem, ModelMesh, ResourceManager } from "@galacean/engine-core";
+export declare class MeshLoader extends Loader<ModelMesh> {
+    load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<ModelMesh>;
+}

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

@@ -0,0 +1,28 @@
+import { Engine, Scene } from "@galacean/engine-core";
+import { IScene } from "../prefab/PrefabDesign";
+import { SceneParserContext } from "./SceneParserContext";
+/** @Internal */
+export declare class SceneParser {
+    readonly context: SceneParserContext;
+    /**
+     * Parse scene data.
+     * @param engine - the engine of the parser context
+     * @param sceneData - scene data which is exported by editor
+     * @returns a promise of scene
+     */
+    static parse(engine: Engine, sceneData: IScene): Promise<Scene>;
+    /**
+     * The promise of parsed scene.
+     */
+    readonly promise: Promise<Scene>;
+    private _resolve;
+    private _reject;
+    private _engine;
+    constructor(context: SceneParserContext);
+    /** start parse the scene */
+    start(): void;
+    private _parseEntities;
+    private _organizeEntities;
+    private _parseComponents;
+    private _clearAndResolveScene;
+}

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

@@ -0,0 +1,13 @@
+import { Component, Entity, Scene } from "@galacean/engine-core";
+import { IEntity, IScene } from "../prefab/PrefabDesign";
+export declare class SceneParserContext {
+    readonly originalData: IScene;
+    readonly scene: Scene;
+    entityMap: Map<string, Entity>;
+    components: Map<string, Component>;
+    assets: Map<string, any>;
+    entityConfigMap: Map<string, IEntity>;
+    rootIds: string[];
+    constructor(originalData: IScene, scene: Scene);
+    destroy(): void;
+}

package/types/resource-deserialize/resources/texture2D/TextureDecoder.d.ts

@@ -0,0 +1,5 @@
+import { Engine, Texture2D } from "@galacean/engine-core";
+import { BufferReader } from "../../utils/BufferReader";
+export declare class Texture2DDecoder {
+    static decode(engine: Engine, bufferReader: BufferReader): Promise<Texture2D>;
+}

package/types/resource-deserialize/utils/BufferReader.d.ts

@@ -0,0 +1,32 @@
+export declare class BufferReader {
+    buffer: ArrayBuffer;
+    private _dataView;
+    private _littleEndian;
+    private _offset;
+    static imageMapping: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+    };
+    constructor(buffer: ArrayBuffer, byteOffset?: number, byteLength?: number, littleEndian?: boolean);
+    get offset(): number;
+    nextUint8(): number;
+    nextUint16(): number;
+    nextUint32(): number;
+    nextInt32(): number;
+    nextInt32Array(len: number): Int32Array;
+    nextFloat32(): number;
+    nextFloat32Array(len: number): Float32Array;
+    nextUint32Array(len: number): Uint32Array;
+    nextUint8Array(len: number): Uint8Array;
+    nextUint64(): number;
+    nextStr(): string;
+    /**
+     * image data 放在最后
+     */
+    nextImageData(count?: number): ArrayBuffer;
+    nextImagesData(count: number): ArrayBuffer[];
+    skip(bytes: number): this;
+    scan(maxByteLength: number, term?: number): Uint8Array;
+}

package/types/resource-deserialize/utils/Decorator.d.ts

@@ -0,0 +1,11 @@
+import { Engine } from "@galacean/engine-core";
+import type { BufferReader } from "./BufferReader";
+export declare const decoderMap: Record<string, {
+    decode: (engine: Engine, bufferReader: BufferReader) => Promise<any>;
+}>;
+/**
+ * Decoder decorator generator.
+ * @param type - resource file type.
+ * @returns Decoder decorator
+ */
+export declare function decoder(type: string): ClassDecorator;

package/types/resource-deserialize/utils/FileHeader.d.ts

@@ -0,0 +1,9 @@
+export declare class FileHeader {
+    totalLength: number;
+    version: number;
+    type: string;
+    name: string;
+    headerLength: number;
+    static decode(arrayBuffer: ArrayBuffer): FileHeader;
+    get dataLength(): number;
+}

package/types/resource-deserialize/utils/Utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Array buffer to string.
+ * @param buf
+ */
+export declare function ab2str(buf: ArrayBuffer): any;