@galacean/effects-core 1.2.0 → 2.0.0-alpha.0

package/dist/asset-loader.d.ts

@@ -0,0 +1,103 @@
+import type * as spec from '@galacean/effects-specification';
+import type { EffectsObject } from './effects-object';
+import type { Engine } from './engine';
+import type { VFXItemProps } from './vfx-item';
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class AssetLoader {
+    private engine;
+    constructor(engine: Engine);
+    loadGUID<T>(guid: string): T;
+    loadGUIDAsync<T>(guid: string): Promise<T>;
+    private findData;
+    private static getClass;
+}
+export declare class Database {
+    loadGUID(guid: string): Promise<EffectsObject | undefined>;
+}
+export declare enum DataType {
+    VFXItemData = 0,
+    EffectComponent = 1,
+    Material = 2,
+    Shader = 3,
+    SpriteComponent = 4,
+    ParticleSystem = 5,
+    InteractComponent = 6,
+    CameraController = 7,
+    Geometry = 8,
+    Texture = 9,
+    TextComponent = 10,
+    MeshComponent = 10000,
+    SkyboxComponent = 10001,
+    LightComponent = 10002,
+    CameraComponent = 10003,
+    ModelPluginComponent = 10004,
+    TreeComponent = 10005
+}
+export interface DataPath {
+    id: string;
+}
+export interface EffectsObjectData {
+    id: string;
+    name?: string;
+    dataType: number;
+}
+export interface MaterialData extends EffectsObjectData {
+    shader: DataPath;
+    blending?: boolean;
+    zWrite?: boolean;
+    zTest?: boolean;
+    floats: Record<string, number>;
+    ints: Record<string, number>;
+    vector2s?: Record<string, spec.vec2>;
+    vector3s?: Record<string, spec.vec3>;
+    vector4s: Record<string, {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }>;
+    colors: Record<string, {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }>;
+    matrices?: Record<string, spec.mat4>;
+    matrice3s?: Record<string, spec.mat3>;
+    textures?: Record<string, DataPath>;
+    floatArrays?: Record<string, number[]>;
+    vector4Arrays?: Record<string, number[]>;
+    matrixArrays?: Record<string, number[]>;
+}
+export interface GeometryData extends EffectsObjectData {
+    vertices?: number[];
+    uvs?: number[];
+    normals?: number[];
+    indices?: number[];
+}
+export interface ShaderData extends EffectsObjectData {
+    vertex: string;
+    fragment: string;
+    properties?: string;
+}
+export interface EffectComponentData extends EffectsObjectData {
+    _priority: number;
+    item: DataPath;
+    materials: DataPath[];
+    geometry: DataPath;
+}
+export type VFXItemData = VFXItemProps & {
+    dataType: DataType;
+    components: DataPath[];
+};
+export type SceneData = Record<string, EffectsObjectData>;
+export interface EffectsPackageData {
+    fileSummary: {
+        guid: string;
+        assetType: string;
+    };
+    exportObjects: EffectsObjectData[];
+}

package/dist/asset-manager.d.ts

@@ -1,8 +1,8 @@
 import type * as spec from '@galacean/effects-specification';
 import type { JSONValue } from './downloader';
 import { Downloader } from './downloader';
-import type { Disposable } from './utils';
 import type { Scene } from './scene';
+import type { Disposable } from './utils';
 import type { Renderer } from './render';
 /**
  * 场景加载参数
@@ -73,6 +73,15 @@ export interface SceneLoadOptions {
      */
     speed?: number;
 }
+/**
+ * 场景类型
+ */
+export type SceneType = string | JSONValue | Scene;
+export type SceneWithOptionsType = {
+    scene: SceneType;
+    options: SceneLoadOptions;
+};
+export type SceneLoadType = SceneType | SceneWithOptionsType;
 /**
  * 资源管理器
  * 用于加载和动效中所有的资源文件，包括图片、插件、图层粒子数据等
@@ -98,6 +107,10 @@ export declare class AssetManager implements Disposable {
      * @default 10
      */
     private timeout;
+    /**
+     * 场景加载的超时定时器
+     */
+    private timers;
     /**
      * 构造函数
      * @param options - 场景加载参数
@@ -123,6 +136,7 @@ export declare class AssetManager implements Disposable {
     private processTextures;
     private loadJSON;
     private loadBins;
+    private removeTimer;
     /**
      * 销毁方法
      */

package/dist/asset-migrations.d.ts

@@ -0,0 +1,2 @@
+import type { Scene } from './scene';
+export declare function version3Migration(scene: Record<string, any>): Scene;

package/dist/comp-vfx-item.d.ts

@@ -1,71 +1,27 @@
-import type { Ray } from '@galacean/effects-math/es';
-import * as spec from '@galacean/effects-specification';
-import { CalculateItem } from './plugins';
+import type { Ray } from '@galacean/effects-math/es/core/ray';
+import { ItemBehaviour } from './components';
+import type { CompositionHitTestOptions } from './composition';
 import type { Region } from './plugins';
-import type { VFXItemContent, VFXItemProps } from './vfx-item';
+import { TimelineComponent } from './plugins';
+import type { VFXItemContent } from './vfx-item';
 import { VFXItem } from './vfx-item';
-import type { Composition, CompositionHitTestOptions } from './composition';
-export interface ItemNode {
-    id: string;
-    item: VFXItem<VFXItemContent>;
-    children: ItemNode[];
-    parentId?: string;
-}
-export declare class CompVFXItem extends VFXItem<void | CalculateItem> {
-    /**
-     * 创建好的元素数组
-     */
-    items: VFXItem<VFXItemContent>[];
-    /**
-     * 根据父子关系构建的元素树
-     */
-    itemTree: ItemNode[];
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class CompositionComponent extends ItemBehaviour {
     startTime: number;
-    contentProps: any;
-    timeInms: number;
+    refId: string;
+    items: VFXItem<VFXItemContent>[];
+    timelineComponents: TimelineComponent[];
+    timelineComponent: TimelineComponent;
+    start(): void;
+    update(dt: number): void;
     /**
-     * id和元素的映射关系Map，方便查找
+     * 重置元素状态属性
      */
-    readonly itemCacheMap: Map<string, ItemNode>;
-    private itemProps;
-    private freezeOnEnd;
-    private startTimeInms;
-    private itemsToRemove;
-    private tempQueue;
-    private extraCamera;
-    private refId;
-    get type(): spec.ItemType;
-    onConstructed(props: VFXItemProps): void;
+    resetStatus(): void;
     createContent(): void;
-    protected doCreateContent(): CalculateItem;
-    onLifetimeBegin(): void;
-    doStop(): void;
-    onItemUpdate(dt: number, lifetime: number): void;
-    onItemRemoved(composition: Composition): void;
-    reset(): void;
-    handleVisibleChanged(visible: boolean): void;
-    getUpdateTime(t: number): number;
-    removeItem(item: VFXItem<VFXItemContent>): boolean;
-    /**
-     * 设置指定元素的父元素
-     * @param item
-     * @param parentItem - 为 undefined 时表示设置父变换为合成的变换
-     */
-    setItemParent(item: VFXItem<VFXItemContent>, parentItem?: VFXItem<VFXItemContent>): void;
-    /**
-     * 获取指定元素当前时刻真正起作用的父元素, 需要在元素生命周期内获取
-     * @internal
-     * @param item - 指定元素
-     * @return 当父元素生命周期结束时，返回空
-     */
-    getItemCurrentParent(item: VFXItem<VFXItemContent>): VFXItem<VFXItemContent> | void;
-    getItemByName(name: string): VFXItem<VFXItemContent>[];
+    onDestroy(): void;
     hitTest(ray: Ray, x: number, y: number, regions: Region[], force?: boolean, options?: CompositionHitTestOptions): Region[];
-    protected isEnded(now: number): boolean;
-    /**
-     * 构建父子树，同时保存到 itemCacheMap 中便于查找
-     */
-    private buildItemTree;
-    private getParentIdWithoutSuffix;
-    private restart;
 }

package/dist/components/component.d.ts

@@ -0,0 +1,63 @@
+import { EffectsObject } from '../effects-object';
+import type { VFXItem, VFXItemContent } from '../vfx-item';
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare abstract class Component extends EffectsObject {
+    name: string;
+    /**
+     * 附加到的 VFXItem 对象
+     */
+    item: VFXItem<VFXItemContent>;
+    /**
+     * 附加到的 VFXItem 对象 Transform 组件
+     */
+    get transform(): import("..").Transform;
+    onAttached(): void;
+    onDestroy(): void;
+    fromData(data: any): void;
+    dispose(): void;
+}
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare abstract class Behaviour extends Component {
+    _enabled: boolean;
+    /**
+     * 组件是否可以更新，true 更新，false 不更新
+     */
+    get isActiveAndEnabled(): boolean;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    protected onBehaviourEnable(): void;
+    fromData(data: any): void;
+    toData(): void;
+}
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare abstract class ItemBehaviour extends Behaviour {
+    started: boolean;
+    /**
+     * 在每次设置 enabled 为 true 时触发
+     */
+    onEnable(): void;
+    /**
+     * 生命周期函数，在第一次 update 前调用，生命周期内只调用一次
+     */
+    start(): void;
+    /**
+     * 生命周期函数，每帧调用一次
+     */
+    update(dt: number): void;
+    /**
+     * 生命周期函数，每帧调用一次，在 update 之后调用
+     */
+    lateUpdate(dt: number): void;
+    onAttached(): void;
+    dispose(): void;
+    protected onBehaviourEnable(): void;
+}

package/dist/components/effect-component.d.ts

@@ -0,0 +1,63 @@
+import { Matrix4 } from '@galacean/effects-math/es/core/matrix4';
+import type { TriangleLike } from '@galacean/effects-math/es/core/type';
+import type { Engine } from '../engine';
+import type { Material, MaterialDestroyOptions } from '../material';
+import type { BoundingBoxTriangle, HitTestTriangleParams } from '../plugins';
+import type { MeshDestroyOptions, Renderer } from '../render';
+import { Geometry } from '../render';
+import { DestroyOptions } from '../utils';
+import { RendererComponent } from './renderer-component';
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class EffectComponent extends RendererComponent {
+    /**
+     * Mesh 的全局唯一 id
+     */
+    readonly id: string;
+    /**
+     * Mesh 的世界矩阵
+     */
+    worldMatrix: Matrix4;
+    /**
+     * Mesh 的 Geometry
+     */
+    geometry: Geometry;
+    triangles: TriangleLike[];
+    protected destroyed: boolean;
+    private visible;
+    private hitTestGeometry;
+    constructor(engine: Engine);
+    get isDestroyed(): boolean;
+    /**
+     * 设置当前 Mesh 的可见性。
+     * @param visible - true：可见，false：不可见
+     */
+    setVisible(visible: boolean): void;
+    start(): void;
+    render(renderer: Renderer): void;
+    /**
+     * 获取当前 Mesh 的可见性。
+     */
+    getVisible(): boolean;
+    /**
+     * 获取当前 Mesh 的第一个 geometry。
+     */
+    firstGeometry(): Geometry;
+    /**
+     * 设置当前 Mesh 的材质
+     * @param material - 要设置的材质
+     * @param destroy - 可选的材质销毁选项
+     */
+    setMaterial(material: Material, destroy?: MaterialDestroyOptions | DestroyOptions.keep): void;
+    getHitTestParams: (force?: boolean) => HitTestTriangleParams | void;
+    getBoundingBox(): BoundingBoxTriangle | void;
+    fromData(data: any): void;
+    toData(): void;
+    /**
+     * 销毁当前资源
+     * @param options - 可选的销毁选项
+     */
+    dispose(options?: MeshDestroyOptions): void;
+}

package/dist/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from './renderer-component';
+export * from './component';
+export * from './effect-component';

package/dist/components/renderer-component.d.ts

@@ -0,0 +1,32 @@
+import type { Material } from '../material';
+import type { Renderer } from '../render';
+import { Component } from './component';
+/**
+ * 所有渲染组件的基类
+ * @since 2.0.0
+ */
+export declare class RendererComponent extends Component {
+    started: boolean;
+    materials: Material[];
+    protected _priority: number;
+    protected _enabled: boolean;
+    get priority(): number;
+    set priority(value: number);
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * 组件是否可以更新，true 更新，false 不更新
+     */
+    get isActiveAndEnabled(): boolean;
+    get material(): Material;
+    set material(material: Material);
+    onEnable(): void;
+    start(): void;
+    update(dt: number): void;
+    lateUpdate(dt: number): void;
+    render(renderer: Renderer): void;
+    onAttached(): void;
+    fromData(data: any): void;
+    toData(): void;
+    dispose(): void;
+}

package/dist/composition-source-manager.d.ts

@@ -1,17 +1,17 @@
 import * as spec from '@galacean/effects-specification';
-import { Texture } from './texture';
-import type { Disposable } from './utils';
-import type { Scene } from './scene';
-import type { PluginSystem } from './plugin-system';
 import type { Engine } from './engine';
+import type { PluginSystem } from './plugin-system';
 import type { GlobalVolume } from './render';
+import type { Scene } from './scene';
+import type { Texture } from './texture';
+import type { Disposable } from './utils';
 import type { VFXItemProps } from './vfx-item';
 export interface ContentOptions {
     id: string;
     duration: number;
     name: string;
     endBehavior: spec.CompositionEndBehavior;
-    items: any[];
+    items: VFXItemProps[];
     camera: spec.CameraOptions;
     startTime: number;
     globalVolume: GlobalVolume;
@@ -31,10 +31,11 @@ export declare class CompositionSourceManager implements Disposable {
     textures: Texture[];
     jsonScene?: spec.JSONScene;
     mask: number;
-    textureOptions: Record<string, any>[];
+    engine: Engine;
     constructor(scene: Scene, engine: Engine);
     private getContent;
     private assembleItems;
+    private preProcessItemContent;
     private changeTex;
     private addTextureUsage;
     /**

package/dist/composition.d.ts

@@ -1,19 +1,19 @@
-import * as spec from '@galacean/effects-specification';
 import type { Ray } from '@galacean/effects-math/es/core/index';
+import * as spec from '@galacean/effects-specification';
+import { Camera } from './camera';
+import { CompositionComponent } from './comp-vfx-item';
+import type { CompositionSourceManager } from './composition-source-manager';
 import type { JSONValue } from './downloader';
-import type { Scene } from './scene';
-import type { Disposable, LostHandler } from './utils';
-import { Transform } from './transform';
-import type { VFXItem, VFXItemContent, VFXItemProps } from './vfx-item';
-import { CompVFXItem } from './comp-vfx-item';
-import type { InteractVFXItem, EventSystem } from './plugins';
 import type { PluginSystem } from './plugin-system';
+import type { EventSystem, Region } from './plugins';
 import type { MeshRendererOptions, Renderer } from './render';
-import type { Texture } from './texture';
 import { RenderFrame } from './render';
-import { Camera } from './camera';
-import type { Region } from './plugins';
-import { CompositionSourceManager } from './composition-source-manager';
+import type { Scene } from './scene';
+import type { Texture } from './texture';
+import { Transform } from './transform';
+import type { Disposable, LostHandler } from './utils';
+import type { VFXItemContent, VFXItemProps } from './vfx-item';
+import { VFXItem } from './vfx-item';
 export interface CompositionStatistic {
     loadTime: number;
     loadStart: number;
@@ -51,6 +51,7 @@ export interface CompositionProps {
  * 也负责 Item 相关的动画播放控制，和持有渲染帧数据。
  */
 export declare class Composition implements Disposable, LostHandler {
+    compositionSourceManager: CompositionSourceManager;
     renderer: Renderer;
     /**
      * 当前帧的渲染数据对象
@@ -65,7 +66,6 @@ export declare class Composition implements Disposable, LostHandler {
      */
     textureOffloaded: boolean;
     videoState: (number | undefined)[];
-    compositionSourceManager: CompositionSourceManager;
     /**
      * 合成渲染顺序，默认按升序渲染
      */
@@ -82,6 +82,7 @@ export declare class Composition implements Disposable, LostHandler {
      * 是否播放完成后销毁 texture 对象
      */
     keepResource: boolean;
+    extraCamera: VFXItem<VFXItemContent>;
     /**
      * 合成结束行为是 spec.END_BEHAVIOR_PAUSE 或 spec.END_BEHAVIOR_PAUSE_AND_DESTROY 时执行的回调
      * @internal
@@ -140,13 +141,13 @@ export declare class Composition implements Disposable, LostHandler {
      */
     readonly url: string | JSONValue;
     /**
-     * 合成对象
+     * 合成根元素
      */
-    readonly content: CompVFXItem;
+    rootItem: VFXItem<VFXItemContent>;
     /**
      * 预合成数组
      */
-    readonly refContent: CompVFXItem[];
+    readonly refContent: VFXItem<VFXItemContent>[];
     /**
      * 预合成的合成属性，在 content 中会被其元素属性覆盖
      */
@@ -155,6 +156,10 @@ export declare class Composition implements Disposable, LostHandler {
      * 合成的相机对象
      */
     readonly camera: Camera;
+    /**
+     * 合成全局时间
+     */
+    globalTime: number;
     protected rendererOptions: MeshRendererOptions | null;
     protected assigned: boolean;
     /**
@@ -165,6 +170,7 @@ export declare class Composition implements Disposable, LostHandler {
      * 是否是否每次渲染时清除 RenderFrame 颜色缓存
      */
     protected readonly keepColorBuffer: boolean;
+    protected rootComposition: CompositionComponent;
     /**
      * 合成暂停/播放 标识
      */
@@ -176,11 +182,14 @@ export declare class Composition implements Disposable, LostHandler {
     private readonly globalVolume;
     private readonly texInfo;
     private readonly postLoaders;
+    private rootTimeline;
     /**
      * Composition 构造函数
      * @param props - composition 的创建参数
+     * @param scene
+     * @param compositionSourceManager
      */
-    constructor(props: CompositionProps, scene: Scene);
+    constructor(props: CompositionProps, scene: Scene, compositionSourceManager: CompositionSourceManager);
     /**
      * 合成结束回调
      * @param {(composition: Composition) => void} func
@@ -240,6 +249,7 @@ export declare class Composition implements Disposable, LostHandler {
      * 暂停合成的播放
      */
     pause(): void;
+    getPaused(): boolean;
     /**
      * 恢复合成的播放
      */
@@ -263,6 +273,7 @@ export declare class Composition implements Disposable, LostHandler {
      * @param time - 相对 startTime 的时间
      */
     setTime(time: number): void;
+    addItem(item: VFXItem<VFXItemContent>): void;
     /**
      * 前进合成到指定时间
      * @param time - 相对0时刻的时间
@@ -273,7 +284,7 @@ export declare class Composition implements Disposable, LostHandler {
      * 重置状态函数
      */
     protected reset(): void;
-    private prepareRender;
+    prepareRender(): void;
     /**
      * 是否合成需要重新播放
      * @returns 重新播放合成标志位
@@ -290,6 +301,15 @@ export declare class Composition implements Disposable, LostHandler {
      * @param skipRender - 是否需要渲染
      */
     update(deltaTime: number, skipRender?: boolean): void;
+    private getUpdateTime;
+    private callStart;
+    private callUpdate;
+    private callLateUpdate;
+    /**
+     * 构建父子树，同时保存到 itemCacheMap 中便于查找
+     */
+    private buildItemTree;
+    private getParentIdWithoutSuffix;
     /**
      * 更新视频数据到纹理
      * @override
@@ -308,30 +328,9 @@ export declare class Composition implements Disposable, LostHandler {
     /**
      * 通过名称获取元素
      * @param name - 元素名称
-     * @param type - 元素类型
      * @returns 元素对象
      */
-    getItemByName(name: string, type?: spec.ItemType): VFXItem<VFXItemContent> | undefined;
-    /**
-     * 通过 id 获取元素
-     * @param id - 元素 id
-     * @return
-     */
-    getItemByID(id: string): VFXItem<VFXItemContent> | null;
-    /**
-     * 获取指定元素当前时刻真正起作用的父元素, 需要在元素生命周期内获取
-     * @internal
-     * @param item - 指定元素
-     * @return 当父元素生命周期结束时，返回空
-     */
-    getItemCurrentParent(item: VFXItem<VFXItemContent>): VFXItem<VFXItemContent> | void;
-    /**
-     * Item 的起始和结束事件
-     * @internal
-     * @param item - 合成元素
-     * @param start - 是起始事件
-     */
-    itemLifetimeEvent(item: VFXItem<any>, start: boolean): void;
+    getItemByName(name: string): VFXItem<VFXItemContent> | undefined;
     /**
      * 获取指定位置和相机连成的射线
      * @param x
@@ -357,13 +356,13 @@ export declare class Composition implements Disposable, LostHandler {
      * @param item - 交互元素
      * @param type - 交互类型
      */
-    addInteractiveItem(item: InteractVFXItem, type: spec.InteractType): string | undefined;
+    addInteractiveItem(item: VFXItem<VFXItemContent>, type: spec.InteractType): string | undefined;
     /**
      * InteractItem 生命周期结束时的调用
      * @param item - 交互元素
      * @param type - 交互类型
      */
-    removeInteractiveItem(item: InteractVFXItem, type: spec.InteractType): void;
+    removeInteractiveItem(item: VFXItem<VFXItemContent>, type: spec.InteractType): void;
     /**
      * 销毁插件 Item 中保存的纹理数组
      * @internal

package/dist/decorators.d.ts

@@ -0,0 +1,4 @@
+export declare const effectsClassStore: Record<number, any>;
+export declare function getMergedStore(target: any): any;
+export declare function serialize(sourceName?: string): (target: any, propertyKey: any) => void;
+export declare function effectsClass(className: any): (target: any, context?: any) => void;

package/dist/effects-object.d.ts

@@ -0,0 +1,25 @@
+import type { EffectsObjectData } from './asset-loader';
+import type { Engine } from './engine';
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare abstract class EffectsObject {
+    engine: Engine;
+    protected guid: string;
+    /**
+     * 存储需要序列化的数据
+     */
+    readonly taggedProperties: Record<string, any>;
+    constructor(engine: Engine);
+    getInstanceId(): string;
+    setInstanceId(guid: string): void;
+    toData(): void;
+    /**
+     * 反序列化函数
+     *
+     * @param data - 对象的序列化的数据
+     */
+    fromData(data: EffectsObjectData): void;
+    dispose(): void;
+}