@galacean/effects-plugin-model 2.0.0-alpha.20 → 2.0.0-alpha.21

package/dist/gltf/index.d.ts

@@ -1,5 +1,4 @@
 export * from './loader-helper';
-export * from './loader-impl';
 export * from './protocol';
 export * from './json-converter';
-export * from './loader-ecs';
+export * from './loader-impl';

package/dist/gltf/loader-ext.d.ts

@@ -1,49 +1,18 @@
-import type { GLTFResources } from '@vvfx/resource-detection';
-import type { Player, spec } from '@galacean/effects';
+import type { Player } from '@galacean/effects';
 import type { LoadSceneOptions, LoadSceneResult } from './protocol';
+import { spec } from '@galacean/effects';
 import { LoaderImpl } from './loader-impl';
 export declare class LoaderImplEx extends LoaderImpl {
     loadScene(options: LoadSceneOptions): Promise<LoadSceneResult>;
-    /**
-     * 检查序列化和反序列逻辑，排查渲染场景中渲染正常和编辑器中渲染错误的问题。
-     * 针对Image、Texture、Material、Mesh、Scene、Animation和IBL的检查。
-     *
-     * @param res 加载的GLTF场景资源
-     */
-    checkSerializer(res: GLTFResources): Promise<void>;
 }
-export interface LoadGLTFSceneOptions {
+export interface LoadGLTFOptions {
     url: string;
     player: Player;
     playAnimation?: number;
+    playAllAnimation?: boolean;
     camera?: {
         position?: spec.vec3;
         rotation?: spec.vec3;
     };
 }
-export declare function loadGLTFScene(options: LoadGLTFSceneOptions): Promise<{
-    compositionId: number;
-    requires: never[];
-    compositions: {
-        name: string;
-        id: number;
-        duration: number;
-        endBehavior: number;
-        camera: {
-            fov: number;
-            far: number;
-            near: number;
-            position: number[];
-            clipMode: number;
-        };
-        items: spec.BaseItem[];
-        meta: {
-            previewSize: number[];
-        };
-    }[];
-    gltf: never[];
-    images: never[];
-    shapes: never[];
-    plugins: string[];
-    version: string;
-}>;
+export declare function loadGLTF(options: LoadGLTFOptions): Promise<spec.JSONScene>;

package/dist/gltf/loader-impl.d.ts

@@ -1,56 +1,62 @@
-import type { Texture, Engine } from '@galacean/effects';
-import { spec, Geometry } from '@galacean/effects';
-import type { Loader, LoaderOptions, SkyboxType, LoadSceneOptions, LoadSceneResult } from './protocol';
-import type { ModelAnimationOptions, ModelCameraOptions, ModelMaterialOptions, ModelLightOptions, ModelSkyboxOptions, ModelTreeOptions } from '../index';
-import type { GLTFImage, GLTFMaterial, GLTFTexture, GLTFScene, GLTFPrimitive, GLTFTextureInfo, GLTFLight, GLTFCamera, GLTFAnimation, GLTFImageBasedLight } from '@vvfx/resource-detection';
-import { PSkyboxType } from '../runtime/skybox';
-import type { CubeImage } from '@vvfx/resource-detection/dist/src/gltf-tools/gltf-image-based-light';
-export declare function getDefaultEffectsGLTFLoader(engine: Engine, options?: LoaderOptions): Loader;
+import { spec } from '@galacean/effects';
+import type { TextureSourceOptions, math } from '@galacean/effects';
+import type { SkyboxType, LoadSceneOptions, LoadSceneResult, Loader, ModelCamera, ModelLight, ModelSkybox, ModelImageLike } from './protocol';
+import type { ModelMeshComponentData, ModelSkyboxComponentData, ModelTreeOptions, ModelLightComponentData, ModelCameraComponentData } from '../index';
+import { PSkyboxType } from '../runtime';
+import type { GLTFResources } from '@vvfx/resource-detection';
+export interface LoaderOptions {
+    compatibleMode?: 'gltf' | 'tiny3d';
+}
+export declare function getDefaultEffectsGLTFLoader(options?: LoaderOptions): Loader;
 export declare function setDefaultEffectsGLTFLoader(loader: Loader): void;
 export declare class LoaderImpl implements Loader {
-    private _sceneOptions;
-    private _loaderOptions;
-    private _gltfScene;
-    private _gltfSkins;
-    private _gltfMeshs;
-    private _gltfLights;
-    private _gltfCameras;
-    private _gltfImages;
-    private _gltfTextures;
-    private _gltfMaterials;
-    private _gltfAnimations;
-    private _gltfImageBasedLights;
-    private _textureManager?;
-    private _skyboxOptions?;
-    engine: Engine;
-    initial(engine: Engine, options?: LoaderOptions): void;
-    processLight(lights: GLTFLight[], fromGLTF: boolean): void;
-    processCamera(cameras: GLTFCamera[], fromGLTF: boolean): void;
-    processMaterial(materials: GLTFMaterial[], fromGLTF: boolean): void;
-    createTreeOptions(scene: GLTFScene): ModelTreeOptions;
-    createAnimations(animations: GLTFAnimation[]): ModelAnimationOptions[];
-    createGeometry(primitive: GLTFPrimitive, hasSkinAnim: boolean): Geometry;
-    createMaterial(material: GLTFMaterial): ModelMaterialOptions;
-    createTexture2D(image: GLTFImage, texture: GLTFTexture, isBaseColor: boolean): Promise<Texture>;
-    createTextureCube(cubeImages: CubeImage[], level0Size?: number): Promise<Texture>;
-    createSkybox(ibl: GLTFImageBasedLight): Promise<ModelSkyboxOptions>;
-    createDefaultSkybox(typeName: SkyboxType): Promise<ModelSkyboxOptions>;
-    scaleColorVal(val: number, fromGLTF: boolean): number;
-    scaleColorVec(vec: number[], fromGLTF: boolean): number[];
+    private sceneOptions;
+    private loaderOptions;
+    private gltfScene;
+    private gltfSkins;
+    private gltfMeshs;
+    private gltfLights;
+    private gltfCameras;
+    private gltfImages;
+    private gltfTextures;
+    private gltfMaterials;
+    private gltfAnimations;
+    private gltfImageBasedLights;
+    composition: spec.CompositionData;
+    timelineAssetId: string;
+    images: spec.Image[];
+    imageElements: ModelImageLike[];
+    textures: spec.TextureDefine[];
+    items: spec.VFXItemData[];
+    components: spec.ComponentData[];
+    materials: spec.MaterialData[];
+    shaders: spec.ShaderData[];
+    geometries: spec.GeometryData[];
+    animations: spec.AnimationClipData[];
+    sceneAABB: math.Box3;
+    constructor(composition?: spec.CompositionData);
     loadScene(options: LoadSceneOptions): Promise<LoadSceneResult>;
-    private _preprocess;
-    tryAddTexture2D(matIndex: number, texInfo: GLTFTextureInfo | undefined, isBaseColor: boolean): Promise<void> | undefined;
-    getTexture2D(matIndex: number, texInfo: GLTFTextureInfo | undefined, isBaseColor: boolean, noWarning?: boolean): Texture | undefined;
-    private _gltfData2PlayerData;
-    private _createItemTree;
-    private _createItemMesh;
-    private _createItemLight;
-    private _createItemCamera;
-    private _createItemSkybox;
-    private _computeSceneAABB;
-    createLightOptions(light: GLTFLight): ModelLightOptions;
-    createCameraOptions(camera: GLTFCamera): ModelCameraOptions | undefined;
-    private _clear;
+    processGLTFResource(resource: GLTFResources, imageElements: ModelImageLike[]): void;
+    processComponentData(components: spec.EffectComponentData[]): void;
+    processLightComponentData(light: ModelLightComponentData): void;
+    processCameraComponentData(camera: ModelCameraComponentData): void;
+    processSkyboxComponentData(skybox: ModelSkyboxComponentData): void;
+    processMaterialData(material: spec.MaterialData): void;
+    processTextureOptions(options: TextureSourceOptions, isBaseColor: boolean, image?: ModelImageLike): void;
+    initial(options?: LoaderOptions): void;
+    checkMeshComponentData(mesh: ModelMeshComponentData, resource: GLTFResources): void;
+    processMaterialTexture(material: spec.MaterialData, textureName: string, isBaseColor: boolean, textureDataMap: Record<string, TextureSourceOptions>, imageElements: ModelImageLike[]): void;
+    getLoadResult(): LoadSceneResult;
+    addLight(data: ModelLight): void;
+    addCamera(camera: ModelCamera): void;
+    tryAddSkybox(skybox: ModelSkybox): Promise<void>;
+    createSkyboxComponentData(typeName: SkyboxType): {
+        imageList: spec.Image[];
+        textureOptionsList: TextureSourceOptions[];
+        component: spec.SkyboxComponentData;
+    };
+    private clear;
+    private computeSceneAABB;
     /**
      * 按照传入的动画播放参数，计算需要播放的动画索引
      *
@@ -61,8 +67,8 @@ export declare class LoaderImpl implements Loader {
     isPlayAnimation(): boolean;
     isPlayAllAnimation(): boolean;
     getRemarkString(): string;
+    getCompositionDuration(): number;
     isTiny3dMode(): boolean;
-    getTextureManager(): TextureManager;
     getItemDuration(): number;
     getItemEndBehavior(): spec.ItemEndBehavior;
     getSkyboxType(): PSkyboxType | undefined;
@@ -70,15 +76,7 @@ export declare class LoaderImpl implements Loader {
     ignoreSkybox(): boolean;
     isEnvironmentTest(): boolean;
 }
-declare class TextureManager {
-    private _owner;
-    private _gltfImages;
-    private _gltfTextures;
-    private _textureMap;
-    constructor(owner: LoaderImpl);
-    initial(gltfImages: GLTFImage[], gltfTextures: GLTFTexture[]): void;
-    dispose(): void;
-    addTexture(matIndex: number, texIndex: number, tex: Texture, isBaseColor: boolean): void;
-    getTexture(matIndex: number, texIndex: number, isBaseColor: boolean): Texture | undefined;
-}
-export {};
+export declare function getPBRShaderProperties(): string;
+export declare function getUnlitShaderProperties(): string;
+export declare function getDefaultPBRMaterialData(): spec.MaterialData;
+export declare function getDefaultUnlitMaterialData(): spec.MaterialData;

package/dist/gltf/protocol.d.ts

@@ -1,7 +1,6 @@
-import type { GLTFMaterial, GLTFPrimitive, GLTFLight, GLTFScene, GLTFImage, GLTFTexture, GLTFCamera, GLTFAnimation, GLTFImageBasedLight, GLTFResources } from '@vvfx/resource-detection';
-import type { CubeImage } from '@vvfx/resource-detection/dist/src/gltf-tools/gltf-image-based-light';
-import type { spec, Renderer, Texture, Geometry, TextureSourceOptions, EffectComponentData } from '@galacean/effects';
-import type { ModelAnimationOptions, ModelMaterialOptions, ModelSkyboxOptions, ModelTreeOptions, ModelBaseItem, ModelLightComponentData, ModelCameraComponentData, ModelMeshComponentData, ModelSkyboxComponentData } from '../index';
+import type { GLTFResources } from '@vvfx/resource-detection';
+import type { spec, TextureSourceOptions, EffectComponentData } from '@galacean/effects';
+import type { ModelLightComponentData, ModelCameraComponentData, ModelSkyboxComponentData } from '../index';
 /**
  * glTF 场景文件加载选项，主要用于 Demo 测试或外部测试调用
  */
@@ -37,10 +36,6 @@ export interface LoadSceneOptions {
         ignoreSkybox?: boolean;
     };
     effects: {
-        /**
-         * Renderer
-         */
-        renderer?: Renderer;
         /**
          * 播放时间，单位秒
          */
@@ -60,14 +55,6 @@ export interface LoadSceneOptions {
     };
 }
 export interface LoadSceneResult {
-    source: string;
-    items: ModelBaseItem[];
-    sceneAABB: {
-        min: spec.vec3;
-        max: spec.vec3;
-    };
-}
-export interface LoadSceneECSResult {
     source: string;
     jsonScene: spec.JSONScene;
     sceneAABB: {
@@ -75,34 +62,51 @@ export interface LoadSceneECSResult {
         max: spec.vec3;
     };
 }
-export interface LoaderOptions {
-    compatibleMode?: 'gltf' | 'tiny3d';
-}
 export type SkyboxType = 'NFT' | 'FARM';
+export interface ModelCamera {
+    fov: number;
+    near: number;
+    far: number;
+    clipMode: spec.CameraClipMode;
+    name: string;
+    position: spec.vec3;
+    rotation: spec.vec3;
+    duration: number;
+    endBehavior: spec.ItemEndBehavior;
+}
+export interface ModelLight {
+    lightType: spec.LightType;
+    color: spec.ColorData;
+    intensity: number;
+    range?: number;
+    innerConeAngle?: number;
+    outerConeAngle?: number;
+    name: string;
+    position: spec.vec3;
+    rotation: spec.vec3;
+    scale: spec.vec3;
+    duration: number;
+    endBehavior: spec.ItemEndBehavior;
+}
+export interface ModelSkybox {
+    skyboxType?: string;
+    renderable?: boolean;
+    intensity?: number;
+    reflectionsIntensity?: number;
+    duration?: number;
+}
+export interface ModelImageLike {
+    name?: string;
+    width: number;
+    height: number;
+}
 export interface Loader {
     loadScene(options: LoadSceneOptions): Promise<LoadSceneResult>;
-    processLight(lights: GLTFLight[], fromGLTF: boolean): void;
-    processCamera(cameras: GLTFCamera[], fromGLTF: boolean): void;
-    processMaterial(materials: GLTFMaterial[], fromGLTF: boolean): void;
-    createTreeOptions(scene: GLTFScene): ModelTreeOptions;
-    createAnimations(animations: GLTFAnimation[]): ModelAnimationOptions[];
-    createGeometry(primitive: GLTFPrimitive, hasSkinAnim: boolean): Geometry;
-    createMaterial(material: GLTFMaterial): ModelMaterialOptions;
-    createTexture2D(images: GLTFImage, textures: GLTFTexture, isBaseColor: boolean): Promise<Texture>;
-    createTextureCube(cubeImages: CubeImage[], level0Size?: number): Promise<Texture>;
-    createSkybox(ibl: GLTFImageBasedLight): Promise<ModelSkyboxOptions>;
-    createDefaultSkybox(typeName: SkyboxType): Promise<ModelSkyboxOptions>;
-    scaleColorVal(val: number, fromGLTF: boolean): number;
-    scaleColorVec(vec: number[], fromGLTF: boolean): number[];
-}
-export interface LoaderECS {
-    loadScene(options: LoadSceneOptions): Promise<LoadSceneECSResult>;
-    processGLTFResource(resource: GLTFResources): void;
+    processGLTFResource(resource: GLTFResources, imageElements: ModelImageLike[]): void;
     processComponentData(components: EffectComponentData[]): void;
     processLightComponentData(light: ModelLightComponentData): void;
     processCameraComponentData(camera: ModelCameraComponentData): void;
-    processMeshComponentData(mesh: ModelMeshComponentData): void;
     processSkyboxComponentData(skybox: ModelSkyboxComponentData): void;
     processMaterialData(material: spec.MaterialData): void;
-    processTextureOptions(options: TextureSourceOptions, isBaseColor: boolean): void;
+    processTextureOptions(options: TextureSourceOptions, isBaseColor: boolean, image?: ModelImageLike): void;
 }

package/dist/helper/index.d.ts

@@ -1,3 +1,2 @@
 export * from '../gltf/loader-ext';
-export * from '../gltf/loader-ecs-ext';
 export * from '../gesture/controller';