@galacean/effects-core 2.0.0-alpha.1 → 2.0.0-alpha.10

package/dist/material/material.d.ts

@@ -1,5 +1,5 @@
-import type { Matrix3, Matrix4, Quaternion, Vector2, Vector3, Vector4 } from '@galacean/effects-math/es/core/index';
-import type { GlobalUniforms, Renderer, ShaderWithSource } from '../render';
+import type { Matrix3, Matrix4, Quaternion, Vector2, Vector3, Vector4, Color } from '@galacean/effects-math/es/core/index';
+import type { GlobalUniforms, Renderer, Shader, ShaderWithSource } from '../render';
 import type { Texture } from '../texture';
 import type { DestroyOptions, Disposable } from '../utils';
 import type { UniformSemantic, UniformValue } from './types';
@@ -55,7 +55,9 @@ export interface MaterialProps {
  * Material 抽象类
  */
 export declare abstract class Material extends EffectsObject implements Disposable {
+    shader: Shader;
     shaderSource: ShaderWithSource;
+    stringTags: Record<string, string>;
     readonly uniformSemantics: Record<string, UniformSemantic>;
     readonly renderType: MaterialRenderType;
     readonly name: string;
@@ -247,6 +249,17 @@ export declare abstract class Material extends EffectsObject implements Disposab
      * @param value - 要设置的 uniform 数据
      */
     abstract setVector4(name: string, value: Vector4): void;
+    /**
+     * 获取 Material 的 Color 类型的 uniform 数据
+     * @param name
+     */
+    abstract getColor(name: string): Color | null;
+    /**
+     * 设置 Color 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setColor(name: string, value: Color): void;
     /**
      * 获取 Material 的 Quaternion 类型的 uniform 数据
      * @param name
@@ -320,9 +333,9 @@ export declare abstract class Material extends EffectsObject implements Disposab
      */
     abstract hasUniform(name: string): boolean;
     /******** 预留接口，暂时不用实现 ***********************/
-    abstract enableKeyword(keyword: string): void;
-    abstract disableKeyword(keyword: string): void;
-    abstract isKeywordEnabled(keyword: string): boolean;
+    abstract enableMacro(keyword: string, value?: boolean | number): void;
+    abstract disableMacro(keyword: string): void;
+    abstract isMacroEnabled(keyword: string): boolean;
     /***************************************************/
     /**
      * Material 的克隆方法（不接入滤镜，本方法可以不做实现）

package/dist/material/types.d.ts

@@ -33,11 +33,6 @@ export interface MaterialStates extends MaterialBlendingStates, MaterialStencilS
     polygonOffset?: [factor: number, units: number];
     polygonOffsetFill?: boolean;
 }
-export interface FilterMaterialStates extends MaterialStates {
-    blendMode?: spec.BlendingMode;
-    side?: spec.SideMode;
-    maskMode?: spec.MaskMode;
-}
 export interface MaterialDataBlockDestroyOptions {
     textures?: DestroyOptions;
 }

package/dist/material/utils.d.ts

@@ -14,4 +14,4 @@ export declare function getPreMultiAlpha(blending?: number): number;
 export declare function createShaderWithMarcos(marcos: ShaderMarcos, shader: string, shaderType: ShaderType, level: number): string;
 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;
+export declare function setMaskMode(material: Material, maskMode: spec.MaskMode): void;

package/dist/math/bezier.d.ts

@@ -0,0 +1,84 @@
+import type * as spec from '@galacean/effects-specification';
+import { Vector2 } from '@galacean/effects-math/es/core/vector2';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+export declare class BezierLengthData {
+    points: Array<{
+        partialLength: number;
+        point: Vector3;
+    }>;
+    totalLength: number;
+    constructor(points: Array<{
+        partialLength: number;
+        point: Vector3;
+    }>, totalLength: number);
+}
+export declare const BezierMap: Record<string, BezierEasing>;
+export declare const BezierDataMap: Record<string, BezierLengthData>;
+/**
+ * @param p1 起始点
+ * @param p2 终点
+ * @param p3 起始控制点
+ * @param p4 终止控制点
+ * @returns
+ */
+export declare function buildBezierData(p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3): {
+    data: BezierLengthData;
+    interval: Vector3;
+};
+export declare class BezierPath {
+    p1: Vector3;
+    p2: Vector3;
+    p3: Vector3;
+    p4: Vector3;
+    readonly lengthData: BezierLengthData;
+    readonly interval: Vector3;
+    readonly totalLength: number;
+    private catching;
+    constructor(p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3);
+    /**
+     * 获取路径在指定比例长度上点的坐标
+     * @param percent 路径长度的比例
+     */
+    getPointInPercent(percent: number): Vector3;
+}
+export declare class BezierEasing {
+    mX1: number;
+    mY1: number;
+    mX2: number;
+    mY2: number;
+    private precomputed;
+    private mSampleValues;
+    constructor(mX1: number, mY1: number, mX2: number, mY2: number);
+    precompute(): void;
+    getValue(x: number): number;
+    calcSampleValues(): void;
+    getTForX(aX: number): number;
+}
+export declare function buildEasingCurve(leftKeyframe: spec.BezierKeyframeValue, rightKeyframe: spec.BezierKeyframeValue): {
+    points: Vector2[];
+    timeInterval: number;
+    valueInterval: number;
+    curve: BezierEasing;
+};
+/**
+ * 根据关键帧类型获取贝塞尔曲线上的关键点
+ */
+export declare function getControlPoints(leftKeyframe: spec.BezierKeyframeValue, rightKeyframe: spec.BezierKeyframeValue, lineToBezier: boolean): ({
+    type: 'ease';
+    p0: Vector2;
+    p1: Vector2;
+    p2: Vector2;
+    p3: Vector2;
+    isHold?: boolean;
+    leftHoldLine?: boolean;
+    rightHoldLine?: boolean;
+} | {
+    type: 'line';
+    p0: Vector2;
+    p1: Vector2;
+    p2?: Vector2;
+    p3?: Vector2;
+    isHold?: boolean;
+    leftHoldLine?: boolean;
+    rightHoldLine?: boolean;
+});

package/dist/math/keyframe-info.d.ts

@@ -0,0 +1,39 @@
+import { Vector2 } from '@galacean/effects-math/es/core/vector2';
+import * as spec from '@galacean/effects-specification';
+export declare const keyframeInfo: {
+    /**
+     * 根据不同关键帧类型，获取位于曲线上的点
+     */
+    getPointInCurve(keyframe: spec.BezierKeyframeValue): Vector2;
+    /**
+     * 根据不同关键帧类型，获取位于曲线上的点的索引
+     */
+    getPointIndexInCurve(keyframe: spec.BezierKeyframeValue): {
+        xIndex: number;
+        yIndex: number;
+    };
+    /**
+     * 关键帧左侧是否为缓动类型（否则为线段）
+     */
+    isLeftSideEase(keyframe: spec.BezierKeyframeValue): keyframe is spec.EaseKeyframeValue | spec.EaseInKeyframeValue | spec.EaseHoldOutKeyframeValue;
+    /**
+     * 关键帧右侧是否为缓动类型（否则为线段）
+     */
+    isRightSideEase(keyframe: spec.BezierKeyframeValue): keyframe is spec.EaseKeyframeValue | spec.EaseOutKeyframeValue | spec.EaseHoldInKeyframeValue;
+    /**
+     * 关键帧左侧是否为缓动类型（否则为线段）
+     */
+    isKeyframeTypeLeftSideEase(keyframeType: spec.BezierKeyframeType): boolean;
+    /**
+     * 关键帧右侧是否为缓动类型（否则为线段）
+     */
+    isKeyframeTypeRightSideEase(keyframeType: spec.BezierKeyframeType): boolean;
+    /**
+     * 是否为定格进关键帧
+     */
+    isHoldInKeyframe(keyframe: spec.BezierKeyframeValue): boolean;
+    /**
+     * 是否为定格出关键帧
+     */
+    isHoldOutKeyframe(keyframe: spec.BezierKeyframeValue): boolean;
+};

package/dist/math/utils.d.ts

@@ -1,6 +1,7 @@
 import type { vec2, vec3, vec4 } from '@galacean/effects-specification';
-import type { TriangleLike } from '@galacean/effects-math/es/core/index';
-import { Vector3, Ray } from '@galacean/effects-math/es/core/index';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+import { Ray } from '@galacean/effects-math/es/core/ray';
+import type { TriangleLike } from '@galacean/effects-math/es/core/type';
 import type { Camera } from '../camera';
 export type vec = number[];
 export declare function ensureVec3(num?: any): vec3;
@@ -12,3 +13,6 @@ export declare const particleOriginTranslateMap: Record<number, vec2>;
 export declare function nearestPowerOfTwo(value: number): number;
 export declare function setRayFromCamera(x: number, y: number, camera: Camera): Ray;
 export declare function trianglesFromRect(position: Vector3, halfWidth: number, halfHeight: number): TriangleLike[];
+export declare function decimalEqual(a: number, b: number, epsilon?: number): boolean;
+export declare function numberToFix(a: number, fixed?: number): number;
+export declare function pointOnLine(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): boolean;

package/dist/math/value-getter.d.ts

@@ -1,5 +1,9 @@
+import type { Vector2 } from '@galacean/effects-math/es/core/vector2';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
 import * as spec from '@galacean/effects-specification';
 import type { ColorStop } from '../utils';
+import type { BezierEasing } from './bezier';
+import { BezierPath } from './bezier';
 interface KeyFrameMeta {
     curves: ValueGetter<any>[];
     index: number;
@@ -8,6 +12,7 @@ interface KeyFrameMeta {
     curveCount: number;
 }
 export declare class ValueGetter<T> {
+    static getAllData(meta: KeyFrameMeta, halfFloat?: boolean): Uint16Array | Float32Array;
     constructor(arg: any);
     onCreate(props: any): void;
     getIntegrateValue(t0: number, t1: number, timeScale?: number): T;
@@ -16,6 +21,7 @@ export declare class ValueGetter<T> {
     toUniform(meta: KeyFrameMeta): Float32Array;
     map(func: (n: T) => T): void;
     scaleXCoord(scale: number): ValueGetter<T>;
+    toData(): ArrayLike<number>;
 }
 export declare class StaticValue extends ValueGetter<number> {
     private value;
@@ -65,28 +71,6 @@ export declare class GradientValue extends ValueGetter<number[]> {
     getStops(): ColorStop[];
     getValue(time: number): number[];
 }
-export type KeyFrame = {
-    inTangent: number;
-    outTangent: number;
-    time: number;
-    value: number;
-};
-export declare class CurveValue extends ValueGetter<number> {
-    keys: KeyFrame[] | number[][];
-    min: number;
-    dist: number;
-    isCurveValue: boolean;
-    static getAllData(meta: KeyFrameMeta, halfFloat?: boolean): Uint16Array | Float32Array;
-    onCreate(props: number[] & number[][]): void;
-    getValue(time: number): number;
-    getIntegrateByTime(t0: number, t1: number): number;
-    getIntegrateValue(t0: number, t1: number, ts: number): number;
-    integrate(time: number, byTime: boolean): number;
-    toData(): Float32Array;
-    toUniform(meta: any): Float32Array;
-    map(func: (num: number) => number): this;
-    scaleXCoord(scale: number): this;
-}
 export declare class LineSegments extends ValueGetter<number> {
     isLineSeg: boolean;
     keys: number[][];
@@ -103,17 +87,34 @@ export declare class LineSegments extends ValueGetter<number> {
     map(func: (k: number) => number): this;
     scaleXCoord(scale: number): this;
 }
-export declare class PathSegments extends ValueGetter<number[]> {
+export declare class BezierCurve extends ValueGetter<number> {
+    curveMap: Record<string, {
+        points: Vector2[];
+        timeInterval: number;
+        valueInterval: number;
+        curve: BezierEasing;
+    }>;
     keys: number[][];
-    values: number[][];
-    onCreate(props: number[][][]): void;
-    getValue(time: number): number[];
-    calculateVec(i: number, dt: number): number[];
+    onCreate(props: spec.BezierKeyframeValue[]): void;
+    getValue(time: number): number;
+    getIntegrateValue(t0: number, t1: number, ts?: number): number;
+    getIntegrateByTime(t0: number, t1: number): number;
+    getCurveIntegrateValue(curveKey: string, time: number): number;
+    getCurveValue(curveKey: string, time: number): number;
+    toUniform(meta: KeyFrameMeta): Float32Array;
+    toData(): Float32Array;
 }
-export declare class BezierSegments extends PathSegments {
-    cps: number[][];
-    onCreate(props: number[][][]): void;
-    calculateVec(i: number, t: number): number[];
+export declare class BezierCurvePath extends ValueGetter<Vector3> {
+    curveSegments: Record<string, {
+        points: Vector2[];
+        easingCurve: BezierEasing;
+        timeInterval: number;
+        valueInterval: number;
+        pathCurve: BezierPath;
+    }>;
+    onCreate(props: spec.BezierCurvePathValue): void;
+    getValue(time: number): Vector3;
+    getPercValue(curveKey: string, time: number): number;
 }
 export declare function createValueGetter(args: any): ValueGetter<any>;
 export declare function getKeyFrameMetaByRawValue(meta: KeyFrameMeta, value?: [type: spec.ValueType, value: any]): void;

package/dist/plugin-system.d.ts

@@ -1,9 +1,8 @@
 import type * as spec from '@galacean/effects-specification';
-import type { SceneLoadOptions } from './asset-manager';
 import type { Composition } from './composition';
 import type { Plugin, PluginConstructor } from './plugins';
 import type { RenderFrame, Renderer } from './render';
-import type { Scene } from './scene';
+import type { Scene, SceneLoadOptions } from './scene';
 import type { VFXItemConstructor, VFXItemProps } from './vfx-item';
 import { VFXItem } from './vfx-item';
 export declare const pluginLoaderMap: Record<string, PluginConstructor>;

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

@@ -12,7 +12,7 @@ export type ItemBasicTransform = {
     position: Vector3;
     rotation: Euler;
     scale: Vector3;
-    path?: ValueGetter<spec.vec3>;
+    path?: ValueGetter<Vector3>;
 };
 export type ItemLinearVelOverLifetime = {
     asMovement?: boolean;

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

@@ -3,12 +3,12 @@ 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';
+import { Playable, PlayableAsset } from './playable-graph';
 /**
  * @since 2.0.0
  * @internal
  */
-export declare class AnimationClipPlayable extends AnimationPlayable {
+export declare class TransformAnimationPlayable extends AnimationPlayable {
     originalTransform: ItemBasicTransform;
     protected sizeSeparateAxes: boolean;
     protected sizeXOverLifetime: ValueGetter<number>;
@@ -45,6 +45,11 @@ export declare class AnimationClipPlayable extends AnimationPlayable {
     private sampleAnimation;
     fromData(data: TransformAnimationData): void;
 }
+export declare class TransformAnimationPlayableAsset extends PlayableAsset {
+    transformAnimationData: TransformAnimationData;
+    createPlayable(): Playable;
+    fromData(data: TransformAnimationData): void;
+}
 export interface TransformAnimationData {
     /**
      * 元素大小变化属性
@@ -63,7 +68,7 @@ export interface TransformAnimationData {
  * @since 2.0.0
  * @internal
  */
-export declare class ActivationClipPlayable extends Playable {
+export declare class ActivationPlayable extends Playable {
     onGraphStart(): void;
     onPlayablePlay(): void;
     onPlayableDestroy(): void;

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

@@ -60,3 +60,7 @@ export declare class PlayableOutput {
     onGraphStart(): void;
     processFrame(dt: number): void;
 }
+export declare abstract class PlayableAsset {
+    abstract createPlayable(): Playable;
+    fromData(data: any): void;
+}

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

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

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

@@ -1,5 +1,5 @@
 import { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
-import type * as spec from '@galacean/effects-specification';
+import * as spec from '@galacean/effects-specification';
 import { ItemBehaviour } from '../../components';
 import type { Engine } from '../../engine';
 export declare class CameraController extends ItemBehaviour {

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

@@ -1,8 +1,8 @@
 import type * as spec from '@galacean/effects-specification';
+import type { Engine } from '../../engine';
 import type { MeshRendererOptions } from '../../render';
 import { Mesh } from '../../render';
 import type { Transform } from '../../transform';
-import type { Engine } from '../../engine';
 export declare class InteractMesh {
     private readonly transform;
     private readonly engine;

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

@@ -1,4 +1,4 @@
-import * as spec from '@galacean/effects-specification';
+import type * as spec from '@galacean/effects-specification';
 import type { Engine } from '../../engine';
 import type { Renderer } from '../../render';
 import { AbstractPlugin } from '../index';

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

@@ -1,12 +1,13 @@
 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 { ValueGetter } from '../../math';
-import type { SharedShaderWithSource, GPUCapability } from '../../render';
+import type { Matrix4 } from '@galacean/effects-math/es/core/matrix4';
+import { Vector2 } from '@galacean/effects-math/es/core/vector2';
+import { Vector3 } from '@galacean/effects-math/es/core/vector3';
+import type { Engine } from '../../engine';
+import { ValueGetter } from '../../math';
+import type { GPUCapability, SharedShaderWithSource } 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;
@@ -66,7 +67,6 @@ export interface ParticleMeshProps extends ParticleMeshData {
     mask: number;
     maskMode: number;
     side: number;
-    filter?: spec.FilterParams;
     transparentOcclusion?: boolean;
     matrix?: Matrix4;
     sprite?: {

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

@@ -9,3 +9,4 @@ export declare class ParticleBehaviourPlayable extends Playable {
     onPlayablePlay(): void;
     processFrame(dt: number): void;
 }
+export declare const particleUniformTypeMap: Record<string, string>;

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

@@ -1,12 +1,12 @@
-import type * as spec from '@galacean/effects-specification';
-import type { vec4, GradientStop } from '@galacean/effects-specification';
-import { Vector3 } from '@galacean/effects-math/es/core/index';
 import type { Matrix4 } from '@galacean/effects-math/es/core/index';
-import type { ShaderWithSource, GPUCapability } from '../../render';
+import { Vector3 } from '@galacean/effects-math/es/core/index';
+import type * as spec from '@galacean/effects-specification';
+import type { GradientStop, vec4 } from '@galacean/effects-specification';
+import type { Engine } from '../../engine';
+import { ValueGetter } from '../../math';
+import type { GPUCapability, ShaderWithSource } from '../../render';
 import { Geometry, Mesh } from '../../render';
 import { Texture } from '../../texture';
-import type { Engine } from '../../engine';
-import type { ValueGetter } from '../../math';
 export type TrailMeshProps = {
     maxTrailCount: number;
     pointCountPerTrail: number;

package/dist/plugins/plugin.d.ts

@@ -1,6 +1,5 @@
 import type * as spec from '@galacean/effects-specification';
-import type { SceneLoadOptions } from '../asset-manager';
-import type { Scene } from '../scene';
+import type { Scene, SceneLoadOptions } from '../scene';
 import type { VFXItem } from '../vfx-item';
 import type { RenderFrame, Renderer } from '../render';
 import type { Composition } from '../composition';

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

@@ -23,9 +23,6 @@ export interface SpriteItemProps extends Omit<spec.SpriteContent, 'renderer'> {
         shape: GeometryFromShape;
         texture: Texture;
     } & Omit<spec.RendererOptions, 'texture'>;
-    filter?: {
-        feather: number | spec.FunctionExpression;
-    } & Omit<spec.FilterParams, 'feather'>;
 }
 /**
  * 图层元素基础属性, 经过处理后的 spec.SpriteContent.options
@@ -112,6 +109,19 @@ export declare class SpriteComponent extends RendererComponent {
      * 获取当前 Mesh 的可见性。
      */
     getVisible(): boolean;
+    /**
+     * 设置当前图层的颜色
+     * > Tips: 透明度也属于颜色的一部分，当有透明度/颜色 K 帧变化时，该 API 会失效
+     * @since 2.0.0
+     * @param color - 颜色值
+     */
+    setColor(color: vec4): void;
+    /**
+     * 设置当前 Mesh 的纹理
+     * @since 2.0.0
+     * @param texture - 纹理对象
+     */
+    setTexture(texture: Texture): void;
     render(renderer: Renderer): void;
     start(): void;
     update(dt: number): void;

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

@@ -4,6 +4,7 @@ import type { SpriteItemProps } from '../sprite/sprite-item';
 import { SpriteComponent } from '../sprite/sprite-item';
 import { TextLayout } from './text-layout';
 import { TextStyle } from './text-style';
+export declare const DEFAULT_FONTS: string[];
 /**
  * @since 2.0.0
  * @internal

package/dist/render/create-copy-shader.d.ts

@@ -2,5 +2,5 @@ import type { SharedShaderWithSource } from './shader';
 export declare const EFFECTS_COPY_MESH_NAME = "effects-internal-copy";
 export declare const COPY_MESH_SHADER_ID = "effects-internal-copy-mesh";
 export declare const COPY_VERTEX_SHADER = "\n#ifdef WEBGL2\n#define vsIn in\n#define vsOut out\n#else\n#define vsIn attribute\n#define vsOut varying\n#endif\nprecision highp float;\nvsIn vec2 aPos;\nvsOut vec2 vTex;\nvoid main(){\n    gl_Position = vec4(aPos,0.,1.0);\n    vTex = (aPos + vec2(1.0))/2.;\n}";
-export declare const COPY_FRAGMENT_SHADER: string;
+export declare const COPY_FRAGMENT_SHADER = "precision mediump float;\n#ifdef WEBGL2\n#define fsIn in\n#define fsOut out\n#define texture2D texture\n#else\n#define fsIn varying\n#endif\nfsIn vec2 vTex;\n#ifdef WEBGL2\nlayout (location = 0) out vec4 fragColor;\n#else\n#define fragColor gl_FragColor\n#endif\n\n#ifdef DEPTH_TEXTURE\nuniform sampler2D uDepth;\n#ifndef WEBGL2\n#extension GL_EXT_frag_depth : enable\n#define gl_FragDepth gl_FragDepthEXT\n#endif\n#endif\nvoid main(){\n    #ifdef DEPTH_TEXTURE\n    gl_FragDepth = texture2D(uDepth,vTex).r;\n    #endif\n}\n";
 export declare function createCopyShader(level: number, writeDepth?: boolean): SharedShaderWithSource;

package/dist/render/global-volume.d.ts

@@ -10,6 +10,9 @@ export interface GlobalVolume {
     brightness: number;
     saturation: number;
     contrast: number;
+    vignetteIntensity: number;
+    vignetteSmoothness: number;
+    vignetteRoundness: number;
     useToneMapping: number;
 }
 export declare const defaultGlobalVolume: GlobalVolume;

package/dist/render/index.d.ts

@@ -10,3 +10,4 @@ export * from './geometry';
 export * from './frame-buffer';
 export * from './renderer';
 export * from './global-volume';
+export * from './semantic-map';

package/dist/render/render-frame.d.ts

@@ -4,8 +4,8 @@ import { Vector2, Vector4 } from '@galacean/effects-math/es/core/index';
 import type { Camera } from '../camera';
 import type { UniformValue } from '../material';
 import { PassTextureCache } from '../paas-texture-cache';
-import type { SemanticFunc } from '../semantic-map';
-import { SemanticMap } from '../semantic-map';
+import type { SemanticFunc } from './semantic-map';
+import { SemanticMap } from './semantic-map';
 import { Texture } from '../texture';
 import type { Disposable } from '../utils';
 import { DestroyOptions } from '../utils';

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

@@ -5,8 +5,8 @@ import type { RendererComponent } from '../components';
 import type { Engine } from '../engine';
 import type { MeshDestroyOptions, Renderer } from '../render';
 import { FrameBuffer } from '../render';
-import type { SemanticGetter } from '../semantic-map';
-import { SemanticMap } from '../semantic-map';
+import type { SemanticGetter } from './semantic-map';
+import { SemanticMap } from './semantic-map';
 import type { TextureConfigOptions, TextureLoadAction } from '../texture';
 import { Texture } from '../texture';
 import type { Disposable, Sortable } from '../utils';

package/dist/{semantic-map.d.ts → render/semantic-map.d.ts}

@@ -1,6 +1,6 @@
-import type { UniformValue } from './material';
-import type { RenderingData } from './render';
-import type { Disposable } from './utils';
+import type { UniformValue } from '../material';
+import type { RenderingData } from '.';
+import type { Disposable } from '../utils';
 export type SemanticFunc = (state: RenderingData) => UniformValue | undefined;
 export type SemanticGetter = UniformValue | SemanticFunc;
 export declare class SemanticMap implements Disposable {
@@ -8,7 +8,7 @@ export declare class SemanticMap implements Disposable {
     constructor(semantics?: Record<string, SemanticGetter>);
     toObject(): Record<string, SemanticGetter>;
     setSemantic(name: string, value?: SemanticGetter): void;
-    getSemanticValue(name: string, state: RenderingData): number | Float32Array | Int32Array | Float64Array | Uint8Array | Uint32Array | Uint16Array | Int8Array | Int16Array | number[] | number[][] | import("@galacean/effects-math/es/core").Vector3 | import("./texture").Texture | import("@galacean/effects-math/es/core").Vector2 | import("@galacean/effects-math/es/core").Vector4 | import("@galacean/effects-math/es/core").Matrix3 | import("@galacean/effects-math/es/core").Matrix4 | import("./texture").Texture[] | import("./material").UniformStruct | import("./material").UniformStruct[] | SemanticFunc | undefined;
+    getSemanticValue(name: string, state: RenderingData): number | Float32Array | Int32Array | Float64Array | Uint8Array | Uint32Array | Uint16Array | Int8Array | Int16Array | number[] | number[][] | import("@galacean/effects-core").Texture | import("@galacean/effects-math/es/core").Vector2 | import("@galacean/effects-math/es/core").Vector3 | import("@galacean/effects-math/es/core").Vector4 | import("@galacean/effects-math/es/core").Matrix3 | import("@galacean/effects-math/es/core").Matrix4 | import("@galacean/effects-core").Texture[] | import("packages/effects-core/src/material/types").UniformStruct | import("packages/effects-core/src/material/types").UniformStruct[] | SemanticFunc | undefined;
     hasSemanticValue(name: string): boolean;
     dispose(): void;
 }

package/dist/render/shader.d.ts

@@ -1,3 +1,4 @@
+import type * as spec from '@galacean/effects-specification';
 import { EffectsObject } from '../effects-object';
 import type { Engine } from '../engine';
 export type ShaderMarcos = [key: string, value: string | number | boolean][];
@@ -78,16 +79,22 @@ export interface SharedShaderWithSource {
     cacheId?: string;
 }
 export type ShaderWithSource = InstancedShaderWithSource | SharedShaderWithSource;
-export declare abstract class Shader extends EffectsObject {
+export declare abstract class ShaderVariant extends EffectsObject {
     readonly source: ShaderWithSource;
+    shader: Shader;
     constructor(engine: Engine, source: ShaderWithSource);
 }
+export declare class Shader extends EffectsObject {
+    shaderData: spec.ShaderData;
+    createVariant(macros?: Record<string, number | boolean>): ShaderVariant;
+    fromData(data: spec.ShaderData): void;
+}
 export interface ShaderLibrary {
     readonly shaderResults: {
         [cacheId: string]: ShaderCompileResult;
     };
     addShader(shader: ShaderWithSource): void;
-    createShader(shaderSource: ShaderWithSource): Shader;
+    createShader(shaderSource: ShaderWithSource, macros?: ShaderMarcos): ShaderVariant;
     /**
      * @param cacheId
      */