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

package/dist/material/material.d.ts

@@ -4,6 +4,7 @@ import type { Texture } from '../texture';
 import type { DestroyOptions, Disposable } from '../utils';
 import type { UniformSemantic, UniformValue } from './types';
 import type { Engine } from '../engine';
+import { EffectsObject } from '../effects-object';
 /**
  * 材质销毁设置
  */
@@ -53,19 +54,19 @@ export interface MaterialProps {
 /**
  * Material 抽象类
  */
-export declare abstract class Material implements Disposable {
-    readonly props: MaterialProps;
+export declare abstract class Material extends EffectsObject implements Disposable {
     shaderSource: ShaderWithSource;
     readonly uniformSemantics: Record<string, UniformSemantic>;
     readonly renderType: MaterialRenderType;
     readonly name: string;
+    readonly props: MaterialProps;
     protected destroyed: boolean;
     protected initialized: boolean;
     /**
      *
      * @param props - 材质属性
      */
-    constructor(props: MaterialProps);
+    constructor(engine: Engine, props?: MaterialProps);
     /******** effects-core 中会调用 引擎必须实现 ***********************/
     /**
      * 设置 Material 的颜色融合开关
@@ -337,7 +338,7 @@ export declare abstract class Material implements Disposable {
     /**
      * 创建 Material
      */
-    static create: (engine: Engine, props: MaterialProps) => Material;
+    static create: (engine: Engine, props?: MaterialProps) => Material;
     /**
      * 初始化 GPU 资源
      * @override

package/dist/material/utils.d.ts

@@ -12,6 +12,6 @@ export declare function getPreMultiAlpha(blending?: number): number;
  * @return 去除版本号的 shader 文本
  */
 export declare function createShaderWithMarcos(marcos: ShaderMarcos, shader: string, shaderType: ShaderType, level: number): string;
-export declare function setBlendMode(material: Material, blendMode: number | undefined): void;
+export declare function setBlendMode(material: Material, blendMode?: number): void;
 export declare function setSideMode(material: Material, side: spec.SideMode): void;
 export declare function setMaskMode(material: Material, maskMode: number): void;

package/dist/pass-render-level.d.ts

@@ -1 +1 @@
-export declare function passRenderLevel(l: string | undefined, renderLevel?: string): boolean;
+export declare function passRenderLevel(l?: string, renderLevel?: string): boolean;

package/dist/plugins/cal/animation-mixer-playable.d.ts

@@ -0,0 +1,4 @@
+import { AnimationPlayable } from './animation-playable';
+export declare class AnimationMixerPlayable extends AnimationPlayable {
+    processFrame(dt: number): void;
+}

package/dist/plugins/cal/animation-playable-output.d.ts

@@ -0,0 +1,4 @@
+import { PlayableOutput } from './playable-graph';
+export declare class AnimationPlayableOutput extends PlayableOutput {
+    processFrame(dt: number): void;
+}

package/dist/plugins/cal/animation-playable.d.ts

@@ -0,0 +1,6 @@
+import { AnimationStream } from './animation-stream';
+import { Playable } from './playable-graph';
+export declare class AnimationPlayable extends Playable {
+    animationStream: AnimationStream;
+    constructor();
+}

package/dist/plugins/cal/animation-stream.d.ts

@@ -0,0 +1,14 @@
+import { AnimationPlayable } from './animation-playable';
+export declare class AnimationStream {
+    private playable;
+    private curveValues;
+    constructor(playable: AnimationPlayable);
+    setCurveValue(componentType: string, propertyName: string, value: number): AnimationCurveValue;
+    findCurveValue(componentType: string, propertyName: string): AnimationCurveValue;
+    getInputStream(index: number): AnimationStream | undefined;
+}
+export interface AnimationCurveValue {
+    componentType: string;
+    propertyName: string;
+    value: number;
+}

package/dist/plugins/cal/calculate-item.d.ts

@@ -1,9 +1,10 @@
 import * as spec from '@galacean/effects-specification';
-import { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
+import type { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
+import { ItemBehaviour } from '../../components';
+import type { Engine } from '../../engine';
 import type { ValueGetter } from '../../math';
-import type { Transform } from '../../transform';
-import type { VFXItem, VFXItemContent } from '../../vfx-item';
-import type { SpriteRenderData } from '../sprite/sprite-mesh';
+import { PlayableGraph } from './playable-graph';
+import type { Track } from './track';
 /**
  * 基础位移属性数据
  */
@@ -21,64 +22,40 @@ export type ItemLinearVelOverLifetime = {
     enabled?: boolean;
 };
 export interface CalculateItemOptions {
-    delay: number;
-    startSpeed: number;
-    direction: Vector3;
-    startSize: number;
-    sizeAspect: number;
+    start: number;
     duration: number;
     looping: boolean;
     endBehavior: number;
-    reusable?: boolean;
-    gravity: Vector3;
-    gravityModifier: ValueGetter<number>;
     startRotation?: number;
     start3DRotation?: number;
 }
-export declare class CalculateItem {
-    protected vfxItem: VFXItem<VFXItemContent>;
-    renderData: SpriteRenderData;
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class TimelineComponent extends ItemBehaviour {
     id: string;
-    active: boolean;
-    name: string;
-    visible: boolean;
-    time: number;
-    protected options: CalculateItemOptions;
-    protected basicTransform: ItemBasicTransform;
-    protected transform: Transform;
-    protected sizeSeparateAxes: boolean;
-    protected sizeXOverLifetime: ValueGetter<number>;
-    protected sizeYOverLifetime: ValueGetter<number>;
-    protected sizeZOverLifetime: ValueGetter<number>;
-    protected rotationOverLifetime: {
-        asRotation?: boolean;
-        separateAxes?: boolean;
-        enabled?: boolean;
-        x?: ValueGetter<number>;
-        y?: ValueGetter<number>;
-        z?: ValueGetter<number>;
-    };
-    gravityModifier: ValueGetter<number>;
-    orbitalVelOverLifetime: {
-        x?: ValueGetter<number>;
-        y?: ValueGetter<number>;
-        z?: ValueGetter<number>;
-        center: [x: number, y: number, z: number];
-        asRotation?: boolean;
-        enabled?: boolean;
-    };
-    speedOverLifetime?: ValueGetter<number>;
-    positionOverLifetime: ValueGetter<number>;
-    linearVelOverLifetime: ItemLinearVelOverLifetime;
-    /*****************/
-    private _velocity;
-    constructor(props: spec.NullContent, vfxItem: VFXItem<VFXItemContent>);
-    get ended(): boolean;
-    get startSize(): Vector3;
-    set startSize(scale: Vector3);
-    get velocity(): Vector3;
-    getWillTranslate(): boolean;
-    updateTime(globalTime: number): void;
-    getRenderData(_time: number, init?: boolean): SpriteRenderData;
-    protected calculateScaling(sizeChanged: boolean, sizeInc: Vector3, init?: boolean): void;
+    reusable: boolean;
+    timelineStarted: boolean;
+    playableGraph: PlayableGraph;
+    options: CalculateItemOptions;
+    /**
+     * 元素动画已经播放的时间
+     */
+    private time;
+    private tracks;
+    private trackSeed;
+    constructor(engine: Engine);
+    start(): void;
+    update(dt: number): void;
+    setTime(time: number): void;
+    getTime(): number;
+    toLocalTime(time: number): number;
+    createTrack<T extends Track>(classConstructor: new () => T, name?: string): T;
+    getTracks(): Track[];
+    findTrack(name: string): Track | undefined;
+    rebuildGraph(): void;
+    compileTracks(graph: PlayableGraph): void;
+    fromData(data: spec.NullContent): void;
+    toData(): void;
 }

package/dist/plugins/cal/calculate-vfx-item.d.ts

@@ -1,26 +1,72 @@
-import * as spec from '@galacean/effects-specification';
-import type { VFXItemProps } from '../../vfx-item';
-import { VFXItem } from '../../vfx-item';
-import type { Composition } from '../../composition';
-import type { SpriteRenderData } from '../sprite/sprite-mesh';
-import { CalculateItem } from './calculate-item';
-export declare class CalculateVFXItem extends VFXItem<CalculateItem> {
-    relative?: boolean;
-    cal: any;
-    _v_priority: number;
-    childrenVisible: boolean;
-    renderData: SpriteRenderData;
-    get type(): spec.ItemType;
-    onConstructed(props: VFXItemProps): void;
-    onLifetimeBegin(composition: Composition, content: CalculateItem): void;
-    onItemRemoved(composition: Composition, content: CalculateItem): void;
-    onItemUpdate(dt: number, lifetime: number): void;
-    setScale(x: number, y: number, z: number): void;
-    scale(x: number, y: number, z: number): void;
-    getHitTestParams(force?: boolean): void;
-    getRenderData(): SpriteRenderData;
-    getChildrenVisible(): boolean;
-    setChildrenVisible(visible: boolean): void;
-    protected doCreateContent(composition: Composition): CalculateItem;
-    protected handleVisibleChanged(visible: boolean): void;
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+import type * as spec from '@galacean/effects-specification';
+import type { ValueGetter } from '../../math';
+import { AnimationPlayable } from './animation-playable';
+import type { ItemBasicTransform, ItemLinearVelOverLifetime } from './calculate-item';
+import { Playable } from './playable-graph';
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class AnimationClipPlayable extends AnimationPlayable {
+    originalTransform: ItemBasicTransform;
+    protected sizeSeparateAxes: boolean;
+    protected sizeXOverLifetime: ValueGetter<number>;
+    protected sizeYOverLifetime: ValueGetter<number>;
+    protected sizeZOverLifetime: ValueGetter<number>;
+    protected rotationOverLifetime: {
+        asRotation?: boolean;
+        separateAxes?: boolean;
+        enabled?: boolean;
+        x?: ValueGetter<number>;
+        y?: ValueGetter<number>;
+        z?: ValueGetter<number>;
+    };
+    gravityModifier: ValueGetter<number>;
+    orbitalVelOverLifetime: {
+        x?: ValueGetter<number>;
+        y?: ValueGetter<number>;
+        z?: ValueGetter<number>;
+        center: [x: number, y: number, z: number];
+        asRotation?: boolean;
+        enabled?: boolean;
+    };
+    speedOverLifetime?: ValueGetter<number>;
+    linearVelOverLifetime: ItemLinearVelOverLifetime;
+    positionOverLifetime: spec.PositionOverLifetime;
+    gravity: Vector3;
+    direction: Vector3;
+    startSpeed: number;
+    private velocity;
+    processFrame(dt: number): void;
+    /**
+     * 应用时间轴K帧数据到对象
+     */
+    private sampleAnimation;
+    fromData(data: TransformAnimationData): void;
+}
+export interface TransformAnimationData {
+    /**
+     * 元素大小变化属性
+     */
+    sizeOverLifetime?: spec.SizeOverLifetime;
+    /**
+     * 元素旋转变化属性
+     */
+    rotationOverLifetime?: spec.RotationOverLifetime;
+    /**
+     * 元素位置变化属性
+     */
+    positionOverLifetime?: spec.PositionOverLifetime;
+}
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class ActivationClipPlayable extends Playable {
+    onGraphStart(): void;
+    onPlayablePlay(): void;
+    onPlayableDestroy(): void;
+    private hideRendererComponents;
+    private showRendererComponents;
 }

package/dist/plugins/cal/playable-graph.d.ts

@@ -0,0 +1,62 @@
+import type { VFXItem, VFXItemContent } from '../../vfx-item';
+/**
+ * 动画图，负责更新所有的动画节点
+ * @since 2.0.0
+ * @internal
+ */
+export declare class PlayableGraph {
+    private playableOutputs;
+    constructor();
+    evaluate(dt: number): void;
+    connect(source: Playable, destination: Playable): void;
+    addOutput(output: PlayableOutput): void;
+    private callProcessFrame;
+}
+/**
+ * 动画图可播放节点对象
+ * @since 2.0.0
+ * @internal
+ */
+export declare class Playable {
+    bindingItem: VFXItem<VFXItemContent>;
+    private inputs;
+    /**
+     * 当前本地播放的时间
+     */
+    protected time: number;
+    constructor();
+    connect(playable: Playable): void;
+    getInputs(): Playable[];
+    getInput(index: number): Playable | undefined;
+    setTime(time: number): void;
+    getTime(): number;
+    onGraphStart(): void;
+    onGraphStop(): void;
+    onPlayablePlay(): void;
+    processFrame(dt: number): void;
+    onPlayableDestroy(): void;
+    fromData(data: any): void;
+}
+/**
+ * 动画图输出节点对象，将动画数据采样到绑定的元素属性上
+ * @since 2.0.0
+ * @internal
+ */
+export declare class PlayableOutput {
+    /**
+     * 绑定到的动画 item
+     */
+    bindingItem: VFXItem<VFXItemContent>;
+    /**
+     * 源 playable 对象
+     */
+    sourcePlayable: Playable;
+    /**
+     * 当前本地播放的时间
+     */
+    protected time: number;
+    constructor();
+    setSourcePlayeble(playable: Playable): void;
+    onGraphStart(): void;
+    processFrame(dt: number): void;
+}

package/dist/plugins/cal/track.d.ts

@@ -0,0 +1,35 @@
+import type { VFXItem, VFXItemContent } from '../../vfx-item';
+import { Playable, PlayableOutput } from './playable-graph';
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class Track {
+    id: string;
+    name: string;
+    bindingItem: VFXItem<VFXItemContent>;
+    private clips;
+    private clipSeed;
+    constructor();
+    createOutput(): PlayableOutput;
+    /**
+     * 重写该方法以创建自定义混合器
+     */
+    createMixerPlayable(): Playable;
+    createPlayebleTree(): Playable;
+    createClip<T extends Playable>(classConstructor: new () => T, name?: string): TimelineClip;
+    getClips(): TimelineClip[];
+    findClip(name: string): TimelineClip | undefined;
+    private addClip;
+}
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class TimelineClip {
+    id: string;
+    name: string;
+    start: number;
+    duration: number;
+    playable: Playable;
+}

package/dist/plugins/camera/camera-controller-node.d.ts

@@ -1,8 +1,8 @@
-import type * as spec from '@galacean/effects-specification';
 import { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
-import { Transform } from '../../transform';
-export declare class CameraController {
-    private readonly transform;
+import type * as spec from '@galacean/effects-specification';
+import { ItemBehaviour } from '../../components';
+import type { Engine } from '../../engine';
+export declare class CameraController extends ItemBehaviour {
     near: number;
     far: number;
     fov: number;
@@ -10,8 +10,11 @@ export declare class CameraController {
     position: Vector3;
     rotation: Euler;
     private options;
-    private readonly translateOverLifetime?;
-    private readonly rotationOverLifetime?;
-    constructor(transform: Transform, model: spec.CameraContent);
-    update(lifetime: number): void;
+    private translateOverLifetime?;
+    private rotationOverLifetime?;
+    constructor(engine: Engine, props?: spec.CameraContent);
+    start(): void;
+    update(): void;
+    fromData(data: spec.CameraContent): void;
+    private updateCamera;
 }

package/dist/plugins/index.d.ts

@@ -1,7 +1,6 @@
 export * from './plugin';
 export * from './camera/camera-controller-node';
 export * from './camera/camera-vfx-item-loader';
-export * from './camera/camera-vfx-item';
 export * from './interact/click-handler';
 export * from './interact/event-system';
 export * from './interact/interact-loader';
@@ -9,18 +8,16 @@ export * from './interact/interact-mesh';
 export * from './interact/interact-vfx-item';
 export * from './interact/interact-item';
 export * from './sprite/sprite-loader';
-export * from './sprite/sprite-vfx-item';
 export * from './sprite/sprite-item';
 export * from './sprite/sprite-mesh';
-export * from './sprite/filter-sprite-vfx-item';
 export * from './particle/particle-loader';
 export * from './particle/particle-mesh';
 export * from './particle/particle-vfx-item';
 export * from './particle/particle-system';
+export * from './particle/particle-system-renderer';
 export * from './cal/calculate-loader';
 export * from './cal/calculate-vfx-item';
 export * from './cal/calculate-item';
 export * from './text/text-item';
 export * from './text/text-loader';
-export * from './text/text-mesh';
-export * from './text/text-vfx-item';
+export * from './cal/track';

package/dist/plugins/interact/click-handler.d.ts

@@ -1,6 +1,6 @@
-import type * as spec from '@galacean/effects-specification';
 import type { Matrix4, Ray, TriangleLike, Vector2, Vector3 } from '@galacean/effects-math/es/core/index';
-import type { CompVFXItem } from '../../comp-vfx-item';
+import type * as spec from '@galacean/effects-specification';
+import type { VFXItem, VFXItemContent } from '../../vfx-item';
 export declare enum HitTestType {
     triangle = 1,
     box = 2,
@@ -46,7 +46,7 @@ export interface HitTestCustomParams {
     behavior?: spec.InteractBehavior;
 }
 export type Region = {
-    compContent: CompVFXItem;
+    compContent: VFXItem<VFXItemContent>;
     name: string;
     id: string;
     position: Vector3;

package/dist/plugins/interact/interact-item.d.ts

@@ -1,2 +1,28 @@
-export declare class InteractItem {
+import * as spec from '@galacean/effects-specification';
+import type { BoundingBoxTriangle, HitTestTriangleParams } from './click-handler';
+import type { EventSystem, TouchEventType } from './event-system';
+import { InteractMesh } from './interact-mesh';
+import { RendererComponent } from '../../components';
+import type { DragEventType } from './interact-vfx-item';
+import type { Renderer } from '../../render';
+/**
+ * @since 2.0.0
+ * @internal
+ */
+export declare class InteractComponent extends RendererComponent {
+    clickable: boolean;
+    dragEvent: DragEventType | null;
+    bouncingArg: TouchEventType | null;
+    previewContent: InteractMesh | null;
+    interactData: spec.InteractContent;
+    start(): void;
+    update(dt: number): void;
+    render(renderer: Renderer): void;
+    onDestroy(): void;
+    endDragTarget(): void;
+    handleDragMove(evt: Partial<DragEventType>, event: TouchEventType): void;
+    beginDragTarget(options: spec.DragInteractOption, eventSystem: EventSystem): void;
+    getHitTestParams: (force?: boolean) => HitTestTriangleParams | void;
+    getBoundingBox(): BoundingBoxTriangle | void;
+    fromData(data: any): void;
 }

package/dist/plugins/interact/interact-loader.d.ts

@@ -1,13 +1,3 @@
 import { AbstractPlugin } from '../index';
-import type { RenderFrame } from '../../render';
-import type { Composition } from '../../composition';
-import type { VFXItem } from '../../vfx-item';
-import type { InteractItem } from './interact-item';
 export declare class InteractLoader extends AbstractPlugin {
-    private mesh;
-    onCompositionItemLifeBegin(composition: Composition, item: VFXItem<InteractItem>): void;
-    onCompositionItemRemoved(composition: Composition, item: VFXItem<InteractItem>): void;
-    prepareRenderFrame(composition: Composition, renderFrame: RenderFrame): boolean;
-    private addMesh;
-    private removeMesh;
 }

package/dist/plugins/interact/interact-vfx-item.d.ts

@@ -1,28 +1,8 @@
-import * as spec from '@galacean/effects-specification';
-import type { VFXItemProps } from '../../vfx-item';
-import { VFXItem } from '../../vfx-item';
-import type { HitTestTriangleParams, BoundingBoxTriangle } from './click-handler';
-import type { Composition } from '../../composition';
-import { InteractMesh } from './interact-mesh';
-import type { InteractItem } from './interact-item';
-import type { Engine } from '../../engine';
-export declare class InteractVFXItem extends VFXItem<InteractItem> {
-    previewContent: InteractMesh | null;
-    private ui;
-    private clickable;
-    private dragEvent;
-    private bouncingArg;
-    engine?: Engine;
-    constructor(props: VFXItemProps, composition: Composition);
-    get type(): spec.ItemType;
-    onConstructed(options: spec.InteractItem): void;
-    onLifetimeBegin(composition: Composition): void;
-    onItemUpdate(): void;
-    onItemRemoved(composition: Composition): void;
-    getBoundingBox(): BoundingBoxTriangle | void;
-    getHitTestParams(): HitTestTriangleParams | void;
-    protected doCreateContent(composition: Composition): InteractItem;
-    private beginDragTarget;
-    private endDragTarget;
-    private handleDragMove;
+import type { vec3 } from '@galacean/effects-specification';
+import type { TouchEventType } from './event-system';
+export interface DragEventType extends TouchEventType {
+    cameraParam?: {
+        position: vec3;
+        fov: number;
+    };
 }

package/dist/plugins/particle/particle-loader.d.ts

@@ -1,18 +1,9 @@
 import * as spec from '@galacean/effects-specification';
-import type { Composition } from '../../composition';
-import type { Renderer, RenderFrame } from '../../render';
-import { type VFXItem } from '../../vfx-item';
+import type { Engine } from '../../engine';
+import type { Renderer } from '../../render';
 import { AbstractPlugin } from '../index';
-import type { ParticleSystem } from './particle-system';
 import type { PrecompileOptions } from '../../plugin-system';
-import type { Engine } from '../../engine';
 export declare class ParticleLoader extends AbstractPlugin {
-    private meshes;
     engine: Engine;
     static precompile(compositions: spec.Composition[], renderer: Renderer, options?: PrecompileOptions): Promise<any>;
-    onCompositionItemLifeBegin(composition: Composition, item: VFXItem<ParticleSystem>): void;
-    onCompositionItemRemoved(composition: Composition, item: VFXItem<ParticleSystem>): void;
-    prepareRenderFrame(composition: Composition, pipeline: RenderFrame): boolean;
-    private add;
-    private remove;
 }

package/dist/plugins/particle/particle-mesh.d.ts

@@ -1,12 +1,12 @@
 import type * as spec from '@galacean/effects-specification';
 import type { Matrix4 } from '@galacean/effects-math/es/core/index';
 import { Vector2, Vector3 } from '@galacean/effects-math/es/core/index';
-import type { Composition } from '../../composition';
 import type { ValueGetter } from '../../math';
 import type { SharedShaderWithSource, GPUCapability } from '../../render';
 import { Geometry, Mesh } from '../../render';
 import { Texture } from '../../texture';
 import { Transform } from '../../transform';
+import type { Engine } from '../../engine';
 export type Point = {
     vel: Vector3;
     lifetime: number;
@@ -85,8 +85,6 @@ export interface ParticleMeshProps extends ParticleMeshData {
         curve: ValueGetter<number>;
         target: spec.vec3;
     };
-    listIndex: number;
-    duration: number;
     maxCount: number;
     shaderCachePrefix: string;
     name: string;
@@ -135,15 +133,12 @@ export declare class ParticleMesh implements ParticleMeshData {
         z?: ValueGetter<number>;
     };
     speedOverLifetime?: ValueGetter<number>;
+    time: number;
     readonly useSprite?: boolean;
     readonly textureOffsets: number[];
     readonly maxCount: number;
     readonly anchor: Vector2;
-    constructor(props: ParticleMeshProps, rendererOptions: {
-        composition: Composition;
-    });
-    get time(): number;
-    set time(v: number);
+    constructor(engine: Engine, props: ParticleMeshProps);
     getPointColor(index: number): number[];
     /**
      * 待废弃
@@ -154,7 +149,7 @@ export declare class ParticleMesh implements ParticleMeshData {
     resetGeometryData(geometry: Geometry): void;
     minusTime(time: number): void;
     removePoint(index: number): void;
-    setPoint(point: Point, index: number): void;
+    setPoint(index: number, point: Point): void;
 }
 export declare function getParticleMeshShader(item: spec.ParticleItem, env: string | undefined, gpuCapability: GPUCapability): {
     shader: SharedShaderWithSource;