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

package/dist/gesture/index.d.ts

@@ -1,4 +1,4 @@
-import type { Composition, CameraOptionsEx, spec, VFXItem, VFXItemContent } from '@galacean/effects';
+import type { Composition, CameraOptionsEx, spec, VFXItem } from '@galacean/effects';
 import { Transform } from '@galacean/effects';
 import type { CameraGestureHandler, CameraKeyEvent } from './protocol';
 import { CameraGestureType } from './protocol';
@@ -8,7 +8,7 @@ export declare class CameraGestureHandlerImp implements CameraGestureHandler {
     private cameraCoordiante;
     private startParams;
     constructor(composition: Composition);
-    getItem(): VFXItem<VFXItemContent> | undefined;
+    getItem(): VFXItem | undefined;
     getCurrentTarget(): string;
     getCurrentType(): CameraGestureType;
     onKeyEvent(event: CameraKeyEvent): CameraOptionsEx;

package/dist/gltf/index.d.ts

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

package/dist/gltf/json-converter.d.ts

@@ -0,0 +1,53 @@
+import { spec, Downloader } from '@galacean/effects';
+import type { Engine, Player, Renderer, GeometryProps } from '@galacean/effects';
+export declare class JSONConverter {
+    newScene: spec.JSONScene;
+    engine: Engine;
+    renderer: Renderer;
+    downloader: Downloader;
+    treeInfo: TreeInfo;
+    constructor(player: Player);
+    processScene(sceneData: string | Record<string | symbol, unknown>): Promise<spec.JSONScene>;
+    setImage(newScene: spec.JSONScene, oldScene: spec.JSONScene): void;
+    setTexture(newScene: spec.JSONScene, oldScene: spec.JSONScene): Promise<void>;
+    setComponent(newScene: spec.JSONScene, oldScene: spec.JSONScene): void;
+    setItem(newScene: spec.JSONScene, oldScene: spec.JSONScene): void;
+    setComposition(newScene: spec.JSONScene, oldScene: spec.JSONScene): void;
+    private loadJSON;
+    private loadBins;
+    private loadMipmapImage;
+    private createSkyboxComponent;
+    private createMeshComponent;
+    private createItemsFromTreeComponent;
+    private createLightComponent;
+    private createAnimationComponent;
+    private getMaterialData;
+    private setupMaterial;
+    private getTextureData;
+    private getTransformData;
+    private setupBoneData;
+}
+declare class TreeInfo {
+    tree2NodeList: Record<string, spec.VFXItemData[]>;
+    nodeList2Tree: Record<string, spec.VFXItemData>;
+    nodeId2Node: Record<string, spec.VFXItemData>;
+    node2Path: Record<string, string>;
+    add(treeItem: spec.VFXItemData, treeNodeList: spec.VFXItemData[]): void;
+    setNodePath(node: spec.VFXItemData): void;
+    getTreeNodeListByTreeId(id: string): spec.VFXItemData[];
+    getTreeNodeListByNodeId(id: string): spec.VFXItemData[];
+    getTreeItemByNodeId(id: string): spec.VFXItemData;
+    getTreeNode(treeId: string, nodeIndex: number): spec.VFXItemData;
+    getAllTreeNodeList(): spec.VFXItemData[];
+    getNodePath(id: string): string;
+}
+export interface ModelData {
+    vertices: spec.TypedArray;
+    uvs: spec.TypedArray;
+    normals: spec.TypedArray;
+    indices: spec.TypedArray;
+    name: string;
+}
+export declare function getGeometryDataFromOptions(geomOptions: GeometryProps): spec.GeometryData;
+export declare function getGeometryDataFromPropsList(geomPropsList: GeometryProps[]): spec.GeometryData | undefined;
+export {};

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 | string;
+    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,8 +1,6 @@
-import type { GLTFMaterial, GLTFPrimitive, GLTFLight, GLTFScene, GLTFImage, GLTFTexture, GLTFCamera, GLTFAnimation, GLTFImageBasedLight } from '@vvfx/resource-detection';
-import type { CubeImage } from '@vvfx/resource-detection/dist/src/gltf-tools/gltf-image-based-light';
-import type { GLTFResources } from '@vvfx/resource-detection/dist/src/gltf-tools';
-import type { spec, Renderer, Texture, Geometry } from '@galacean/effects';
-import type { ModelAnimationOptions, ModelMaterialOptions, ModelSkyboxOptions, ModelTreeOptions, ModelBaseItem } 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 测试或外部测试调用
  */
@@ -17,9 +15,9 @@ export interface LoadSceneOptions {
          */
         resource: string | Uint8Array | GLTFResources;
         /**
-         * 兼容模式，目前只支持tiny3d
+         * 兼容模式，目前支持 gltf 和 tiny3d
          */
-        compatibleMode?: 'gltf' | 'tiny3d' | 'oasis';
+        compatibleMode?: 'gltf' | 'tiny3d';
         /**
          * 检查ResourceDetection序列化和反序列逻辑
          */
@@ -38,10 +36,6 @@ export interface LoadSceneOptions {
         ignoreSkybox?: boolean;
     };
     effects: {
-        /**
-         * Renderer
-         */
-        renderer?: Renderer;
         /**
          * 播放时间，单位秒
          */
@@ -53,7 +47,7 @@ export interface LoadSceneOptions {
         /**
          * 播放动画索引或名称
          */
-        playAnimation?: number | string;
+        playAnimation?: number;
         /**
          * 是否播放全部动画
          */
@@ -62,29 +56,57 @@ export interface LoadSceneOptions {
 }
 export interface LoadSceneResult {
     source: string;
-    items: ModelBaseItem[];
+    jsonScene: spec.JSONScene;
     sceneAABB: {
         min: spec.vec3;
         max: spec.vec3;
     };
 }
-export interface LoaderOptions {
-    compatibleMode?: 'gltf' | 'tiny3d' | 'oasis';
-}
 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[];
+    processGLTFResource(resource: GLTFResources, imageElements: ModelImageLike[]): void;
+    processComponentData(components: 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;
 }

package/dist/index.d.ts

@@ -34,6 +34,15 @@ export type ModelTreeOptions = spec.ModelTreeOptions<'studio'>;
 export type ModelTreeContent = spec.ModelTreeContent<'studio'>;
 export type ModelAnimTrackOptions = spec.ModelAnimTrackOptions<'studio'>;
 export type ModelAnimationOptions = spec.ModelAnimationOptions<'studio'>;
+export type ModelMeshSkinData = spec.SkinData;
+export type ModelMeshMorphData = spec.MorphData;
+export type ModelMeshPrimitiveData = spec.PrimitiveData;
+export type ModelMeshComponentData = spec.ModelMeshComponentData;
+export type ModelLightType = spec.LightType;
+export type ModelLightComponentData = spec.ModelLightComponentData;
+export type ModelCameraComponentData = spec.ModelCameraComponentData;
+export type ModelSkyboxComponentData = spec.SkyboxComponentData;
+export type AnimationComponentData = spec.AnimationComponentData;
 export * from './gesture';
 export * from './gltf';
 export * from './plugin';