@galacean/effects-core 1.1.2 → 1.1.4

package/dist/libs/earcut.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Earcut.js from: https://github.com/mapbox/earcut/tree/v2.2.2
+ */
+export function earcut(data: any, holeIndices: any, dim: any): any[];
+export namespace earcut {
+    function deviation(data: any, holeIndices: any, dim: any, triangles: any): number;
+    function flatten(data: any): {
+        vertices: never[];
+        holes: never[];
+        dimensions: any;
+    };
+}
+export function linkedList(data: any, start: any, end: any, dim: any, clockwise: any): any;
+export function filterPoints(start: any, end: any): any;
+export function isEar(ear: any): boolean;
+export function isEarHashed(ear: any, minX: any, minY: any, invSize: any): boolean;
+export function eliminateHoles(data: any, holeIndices: any, outerNode: any, dim: any): any;
+export function indexCurve(start: any, minX: any, minY: any, invSize: any): void;
+export function isValidDiagonal(a: any, b: any): number | boolean;
+export function equals(p1: any, p2: any): boolean;
+export function intersects(p1: any, q1: any, p2: any, q2: any): boolean;
+export function locallyInside(a: any, b: any): boolean;
+export function splitPolygon(a: any, b: any): Node;
+export function removeNode(p: any): void;
+export function Node(i: any, x: any, y: any): void;
+export class Node {
+    constructor(i: any, x: any, y: any);
+    i: any;
+    x: any;
+    y: any;
+    prev: any;
+    next: any;
+    z: any;
+    prevZ: any;
+    nextZ: any;
+    steiner: boolean;
+}

package/dist/material/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './utils';
+export * from './material-data-block';
+export * from './material';

package/dist/material/material-data-block.d.ts

@@ -0,0 +1,27 @@
+import type { MaterialDataBlockDestroyOptions, UniformValue } from './types';
+import type { Disposable } from '../utils';
+export interface MaterialDataBlockProps {
+    uniformValues?: Record<string, UniformValue>;
+    name?: string;
+    keepUboData?: boolean;
+}
+/**
+ * 引擎接入暂时不需要实现
+ */
+export declare abstract class MaterialDataBlock implements Disposable {
+    readonly name: string;
+    protected destroyed: boolean;
+    protected constructor(props: MaterialDataBlockProps);
+    setUniformValues(uniformValue: Record<string, UniformValue>): void;
+    invalidAllFlags(): void;
+    updateUniformSubData(name: string, start: number, count: number): void;
+    abstract hasUniformValue(name: string): boolean;
+    abstract getUniformValue(name: string): UniformValue | undefined;
+    abstract getUniformValues(): Record<string, UniformValue>;
+    abstract setUniformValue(name: string, value: UniformValue): void;
+    abstract removeUniformValue(name: string): void;
+    abstract dispose(options?: MaterialDataBlockDestroyOptions): void;
+    static create: (props: MaterialDataBlockProps) => MaterialDataBlock;
+}
+export declare function isUniformStruct(value: UniformValue): boolean;
+export declare function isUniformStructArray(value: UniformValue): boolean | 0;

package/dist/material/material.d.ts

@@ -0,0 +1,347 @@
+import type { Matrix3, Matrix4, Quaternion, Vector2, Vector3, Vector4 } from '@galacean/effects-math/es/core/index';
+import type { GlobalUniforms, Renderer, ShaderWithSource } from '../render';
+import type { Texture } from '../texture';
+import type { DestroyOptions, Disposable } from '../utils';
+import type { UniformSemantic, UniformValue } from './types';
+import type { Engine } from '../engine';
+/**
+ * 材质销毁设置
+ */
+export interface MaterialDestroyOptions {
+    /**
+     * 纹理的销毁设置
+     */
+    textures?: DestroyOptions;
+}
+/**
+ * 材质渲染类型
+ */
+export declare enum MaterialRenderType {
+    normal = 0,
+    transformFeedback = 1
+}
+export type UndefinedAble<U> = U | undefined;
+/**
+ * 材质属性
+ */
+export interface MaterialProps {
+    /**
+     * shader 文本和属性
+     */
+    shader: ShaderWithSource;
+    /**
+     * 材质的名称，未传入会自动设置为 `Material[seed]`
+     */
+    name?: string;
+    /**
+     * 传递的变换矩阵
+     */
+    uniformSemantics?: Record<string, UniformSemantic>;
+    /**
+     * 渲染类型
+     */
+    renderType?: MaterialRenderType;
+    /**
+     * uniform 数据
+     */
+    uniformValues?: Record<string, UniformValue>;
+    transformFeedbackOutput?: {
+        mode: WebGL2RenderingContext['INTERLEAVED_ATTRIBS'] | WebGL2RenderingContext['SEPARATE_ATTRIBS'];
+        varyings: string[];
+    };
+}
+/**
+ * Material 抽象类
+ */
+export declare abstract class Material implements Disposable {
+    readonly props: MaterialProps;
+    shaderSource: ShaderWithSource;
+    readonly uniformSemantics: Record<string, UniformSemantic>;
+    readonly renderType: MaterialRenderType;
+    readonly name: string;
+    protected destroyed: boolean;
+    protected initialized: boolean;
+    /**
+     *
+     * @param props - 材质属性
+     */
+    constructor(props: MaterialProps);
+    /******** effects-core 中会调用 引擎必须实现 ***********************/
+    /**
+     * 设置 Material 的颜色融合开关
+     * @param blending - 是否开启混合效果
+     */
+    set blending(blending: UndefinedAble<boolean>);
+    /**
+     * 分别指定 Material 的颜色混合函数乘数
+     * @param func - 混合函数参数
+     */
+    set blendFunction(func: UndefinedAble<[blendSrc: number, blendDst: number, blendSrcAlpha: number, blendDstAlpha: number]>);
+    /**
+     * 分别指定 Material 的颜色混合方式
+     * @param equation - 混合方程参数
+     */
+    set blendEquation(equation: UndefinedAble<[rgb: number, alpha: number]>);
+    /**
+     * 设置 Material 的深度测试开关
+     * @param value - 是否开启深度测试
+     */
+    set depthTest(value: UndefinedAble<boolean>);
+    /**
+     * 设置 Material 的写入深度缓冲开关
+     * @param value - 是否开启深度写入
+     */
+    set depthMask(value: UndefinedAble<boolean>);
+    /**
+     * 设置 Material 的模板测试开关
+     * @param value - 是否开启模板测试
+     */
+    set stencilTest(value: UndefinedAble<boolean>);
+    /**
+     * 分别指定 Material 的模板测试参考值
+     * @param value  - 模板测试参考值参数
+     */
+    set stencilRef(value: UndefinedAble<[front: number, back: number]>);
+    /**
+     * 分别指定 Material 的模板测试函数
+     * @param value - 模板测试函数参数
+     */
+    set stencilFunc(value: UndefinedAble<[front: number, back: number]>);
+    /**
+     * 分别指定 Material 的模板测试和深度测试都通过时使用的函数
+     * @param value - 模板测试深度测试通过时的操作参数
+     */
+    set stencilOpZPass(value: UndefinedAble<[front: number, back: number]>);
+    /**
+     * 设置 Material 的正反面剔除开关
+     * @param value - 是否开启剔除
+     */
+    set culling(value: UndefinedAble<boolean>);
+    /**
+     * 设置 Material 的正反面计算方向
+     * @param value
+     */
+    set frontFace(value: UndefinedAble<number>);
+    /**
+     * 设置 Material 要剔除的面
+     * @param value - 剔除面参数
+     */
+    set cullFace(value: UndefinedAble<number>);
+    /***************************************************/
+    /******** effects-core 中暂无调用 引擎可以先不实现 ***********************/
+    /**
+     * 设置 Material 的源和目标混合因子
+     * @param color
+     */
+    set blendColor(color: UndefinedAble<[r: number, g: number, b: number, a: number]>);
+    /**
+     * 设置 Material 的深度映射范围
+     * @param value
+     */
+    set depthRange(value: UndefinedAble<[zNear: number, zFar: number]>);
+    /**
+     * 设置 Material 的深度比较函数
+     * @param value - 深度测试函数参数
+     */
+    set depthFunc(value: UndefinedAble<number>);
+    /**
+     * 设置 Material 的多边形偏移（实现类似深度偏移的效果）
+     * @param value - 多边形偏移参数
+     */
+    set polygonOffsetFill(value: UndefinedAble<boolean>);
+    /**
+     * 指定 Material 计算深度值的比例因子 factor 和单位 units
+     * @param value
+     */
+    set polygonOffset(value: UndefinedAble<[factor: number, units: number]>);
+    /**
+     * 设置 Material 的通过 alpha 值决定临时覆盖值计算的开关
+     * @param value - 是否开启 alpha 抖动
+     */
+    set sampleAlphaToCoverage(value: UndefinedAble<boolean>);
+    /**
+     * 设置 Material 颜色缓冲区的写入开关
+     * @param value
+     */
+    set colorMask(value: UndefinedAble<[r: boolean, g: boolean, b: boolean, a: boolean]>);
+    /**
+     * 分别指定 Material 的模板测试掩码
+     * @param value - 模板测试写入掩码参数
+     */
+    set stencilMask(value: UndefinedAble<[front: number, back: number]>);
+    /**
+     * 分别指定 Material 模板测试失败时要使用的函数
+     * @param value - 模板测试失败时的操作参数
+     */
+    set stencilOpFail(value: UndefinedAble<[front: number, back: number]>);
+    /**
+     * 分别指定 Material 模板测试通过但深度测试失败时要使用的函数
+     * @param value - 模板测试深度测试失败时的操作参数
+     */
+    set stencilOpZFail(value: UndefinedAble<[front: number, back: number]>);
+    /***************************************************/
+    /**
+     * 获取 Material 的 float 类型的 uniform 数据
+     * @param name
+     */
+    abstract getFloat(name: string): number | null;
+    /**
+     * 设置 float 类型的 uniform 数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setFloat(name: string, value: number): void;
+    /**
+     * 获取 Material 的 float 类型的 uniform 数据
+     * @param name
+     */
+    abstract getInt(name: string): number | null;
+    /**
+     * 设置 int 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setInt(name: string, value: number): void;
+    /**
+     * 获取 Material 的 float 数组类型的 uniform 数据
+     * @param name
+     */
+    abstract getFloats(name: string): number[] | null;
+    /**
+     * 设置 float 数组类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setFloats(name: string, value: number[]): void;
+    /**
+     * 获取 Material 的 vec2 类型的 uniform 数据
+     * @param name
+     */
+    abstract getVector2(name: string): Vector2 | null;
+    /**
+     * 设置 vec2 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setVector2(name: string, value: Vector2): void;
+    /**
+     * 获取 Material 的 vec3 类型的 uniform 数据
+     * @param name
+     */
+    abstract getVector3(name: string): Vector3 | null;
+    /**
+     * 设置 vec3 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setVector3(name: string, value: Vector3): void;
+    /**
+     * 获取 Material 的 vec4 类型的 uniform 数据
+     * @param name
+     */
+    abstract getVector4(name: string): Vector4 | null;
+    /**
+     * 设置 vec4 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setVector4(name: string, value: Vector4): void;
+    /**
+     * 获取 Material 的 Quaternion 类型的 uniform 数据
+     * @param name
+     */
+    abstract getQuaternion(name: string): Quaternion | null;
+    /**
+     * 设置 Quaternion 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setQuaternion(name: string, value: Quaternion): void;
+    /**
+     * 获取 Material 的 vec4 数组类型的 uniform 数据
+     * @param name
+     */
+    abstract getVector4Array(name: string): number[];
+    /**
+     * 设置 vec4 数组类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setVector4Array(name: string, value: Vector4[]): void;
+    /**
+     * 获取 Material 的 mat4 类型的 uniform 数据
+     * @param name
+     */
+    abstract getMatrix(name: string): Matrix4 | null;
+    /**
+     * 设置 mat4 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setMatrix(name: string, value: Matrix4): void;
+    /**
+     * 设置 mat3 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param value - 要设置的 uniform 数据
+     */
+    abstract setMatrix3(name: string, value: Matrix3): void;
+    /**
+     * 获取 Material 的 mat4 数组类型的 uniform 数据
+     * @param name
+     */
+    abstract getMatrixArray(name: string): number[] | null;
+    /**
+     * 设置 mat 数组类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param array - 要设置的 uniform 数据
+     */
+    abstract setMatrixArray(name: string, array: Matrix4[]): void;
+    /**
+     * 设置 mat 数组类型的 uniform 的数据，传入 number 数组
+     * @param name - uniform 名称
+     * @param array - 要设置的 uniform 数据，number 类型数组
+     */
+    abstract setMatrixNumberArray(name: string, array: number[]): void;
+    /**
+     * 获取 Material 的 sampler2D 类型的 uniform 数据
+     * @param name
+     */
+    abstract getTexture(name: string): Texture | null;
+    /**
+     * 设置 sampler2D 类型的 uniform 的数据
+     * @param name - uniform 名称
+     * @param texture - 要设置的 uniform 数据
+     */
+    abstract setTexture(name: string, texture: Texture): void;
+    /**
+     * 获取 Material 的 float 类型的 uniform 数据
+     * @param name
+     */
+    abstract hasUniform(name: string): boolean;
+    /******** 预留接口，暂时不用实现 ***********************/
+    abstract enableKeyword(keyword: string): void;
+    abstract disableKeyword(keyword: string): void;
+    abstract isKeywordEnabled(keyword: string): boolean;
+    /***************************************************/
+    /**
+     * Material 的克隆方法（不接入滤镜，本方法可以不做实现）
+     * @param props 新的材质属性
+     */
+    abstract clone(props?: MaterialProps): Material;
+    abstract cloneUniforms(sourceMaterial: Material): void;
+    /**
+     * 销毁当前 Material
+     * @param destroy - 包含纹理的销毁选项
+     */
+    abstract dispose(destroy?: MaterialDestroyOptions): void;
+    /**
+     * 创建 Material
+     */
+    static create: (engine: Engine, props: MaterialProps) => Material;
+    /**
+     * 初始化 GPU 资源
+     * @override
+     */
+    initialize(): void;
+    use(render: Renderer, globalUniforms: GlobalUniforms): void;
+}

package/dist/material/types.d.ts

@@ -0,0 +1,66 @@
+import type * as spec from '@galacean/effects-specification';
+import type { Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '@galacean/effects-math/es/core/index';
+import type { Texture } from '../texture';
+import type { DestroyOptions } from '../utils';
+export type UniformSemantic = 'VIEW' | 'MODEL' | 'MODELVIEW' | 'PROJECTION' | 'VIEWPROJECTION' | 'VIEWINVERSE' | 'EDITOR_TRANSFORM' | 'MODELVIEWPROJECTION';
+export interface MaterialBlendingStates {
+    blending?: boolean;
+    blendFunction?: [blendSrc: GLenum, blendDst: GLenum, blendSrcAlpha: GLenum, blendDstAlpha: GLenum];
+    blendEquation?: [blendEquationRGB: GLenum, blendEquationAlpha: GLenum];
+    blendColor?: [r: number, g: number, b: number, a: number];
+}
+export interface MaterialStencilStates {
+    stencilTest?: boolean;
+    stencilMask?: [front: GLenum, back: GLenum];
+    stencilRef?: [front: GLenum, back: GLenum];
+    stencilFunc?: [front: GLenum, back: GLenum];
+    stencilOpFail?: [front: GLenum, back: GLenum];
+    stencilOpZFail?: [front: GLenum, back: GLenum];
+    stencilOZPass?: [front: GLenum, back: GLenum];
+}
+export interface MaterialSideStates {
+    culling?: boolean;
+    cullFace?: GLenum;
+    frontFace?: GLenum;
+}
+export interface MaterialStates extends MaterialBlendingStates, MaterialStencilStates, MaterialSideStates {
+    sampleAlphaToCoverage?: boolean;
+    colorMask?: [r: boolean, g: boolean, b: boolean, a: boolean];
+    depthTest?: boolean;
+    depthMask?: boolean;
+    depthFunc?: number;
+    depthRange?: [zNear: number, zFar: number];
+    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;
+}
+/**
+ * @example
+ * const mtl0 = new Material({
+ *  shader:{
+ *   fragment:'...',
+ *   vertex:'...',
+ *   cacheId:'mtl_01'
+ * }});
+ *
+ * const mtl2 = new Material({
+ *   shader:{
+ *     cacheId:'mtl_01'
+ *   }
+ * });
+ * mtl2 use the same program with mtl0
+ */
+export type UniformValueDataType = spec.TypedArray | number | number[] | Texture | Texture[] | number[][] | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4;
+export type UniformStruct = Record<string, UniformValueDataType>;
+export type UniformValue = UniformValueDataType | UniformStruct | UniformStruct[];
+export declare enum ShaderType {
+    vertex = 0,
+    fragment = 1
+}

package/dist/material/utils.d.ts

@@ -0,0 +1,17 @@
+import * as spec from '@galacean/effects-specification';
+import type { ShaderMarcos } from '../render';
+import type { Material } from './material';
+import { ShaderType } from './types';
+export declare function valIfUndefined<T>(val: any, def: T): T;
+export declare function getPreMultiAlpha(blending?: number): number;
+/**
+ * 生成 shader，检测到 WebGL1 上下文会降级
+ * @param marcos - 宏定义数组
+ * @param shader - 原始 shader 文本
+ * @param shaderType - shader 类型
+ * @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 setSideMode(material: Material, side: spec.SideMode): void;
+export declare function setMaskMode(material: Material, maskMode: number): void;

package/dist/math/float16array-wrapper.d.ts

@@ -0,0 +1,5 @@
+export declare class Float16ArrayWrapper {
+    data: Uint16Array;
+    constructor(num: number | ArrayLike<number>);
+    set(number: ArrayLike<number>, startIndex: number): void;
+}

package/dist/math/index.d.ts

@@ -0,0 +1,4 @@
+export * from './float16array-wrapper';
+export * from './translate';
+export * from './utils';
+export * from './value-getter';

package/dist/math/translate.d.ts

@@ -0,0 +1,10 @@
+import type { ValueGetter } from './value-getter';
+import { Vector3 } from '@galacean/effects-math/es/core/index';
+export declare function translatePoint(x: number, y: number): number[];
+export interface TranslateTarget {
+    speedOverLifetime?: ValueGetter<number>;
+    gravityModifier?: ValueGetter<number>;
+    linearVelOverLifetime?: any;
+    orbitalVelOverLifetime?: any;
+}
+export declare function calculateTranslation(out: Vector3, target: TranslateTarget, acc: Vector3, time: number, duration: number, posData: Vector3, velData: Vector3): Vector3;

package/dist/math/utils.d.ts

@@ -0,0 +1,19 @@
+import * as spec from '@galacean/effects-specification';
+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 type { Camera } from '../camera';
+export type vec = number[];
+export declare function ensureVec3(num?: any): vec3;
+export declare function vecFill<T extends vec | vec3 | vec4 | vec2>(out: T | number[], number: number): T;
+export declare function vecAssign<T extends vec | vec3 | vec4 | vec2>(out: T | number[] | Float32Array, a: T, count: number, start?: number): T;
+export declare function vecNormalize<T extends vec | vec2 | vec3 | vec4>(out: T | number[], a?: T | number[]): T;
+export declare function vecMulCombine<T extends vec | vec3 | vec4 | vec2>(out: T | number[] | Float32Array, a?: T, b?: T): T;
+export declare const particleOriginTranslateMap: Record<number, vec2>;
+/**
+ * 提取并转换 JSON 数据中的 anchor 值
+ */
+export declare function convertAnchor(anchor?: vec2, particleOrigin?: spec.ParticleOrigin): 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[];

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

@@ -0,0 +1,127 @@
+import * as spec from '@galacean/effects-specification';
+import type { ColorStop } from '../utils';
+interface KeyFrameMeta {
+    curves: ValueGetter<any>[];
+    index: number;
+    max: number;
+    lineSegCount: number;
+    curveCount: number;
+}
+export declare class ValueGetter<T> {
+    constructor(arg: any);
+    onCreate(props: any): void;
+    getIntegrateValue(t0: number, t1: number, timeScale?: number): T;
+    getIntegrateByTime(t0: number, time: number): T;
+    getValue(time?: number): T;
+    toUniform(meta: KeyFrameMeta): Float32Array;
+    map(func: (n: T) => T): void;
+    scaleXCoord(scale: number): ValueGetter<T>;
+}
+export declare class StaticValue extends ValueGetter<number> {
+    private value;
+    onCreate(arg: number): void;
+    getIntegrateValue(t0: number, t1: number, ts: number): number;
+    getIntegrateByTime(t0: number, t1: number): number;
+    getValue(time?: number): number;
+    toUniform(): Float32Array;
+    map(func: (n: number) => number): this;
+}
+export declare class RandomSetValue<T> extends ValueGetter<T> {
+    private items;
+    onCreate(arg: T[]): void;
+    getValue(t: number): T;
+    map(func: (v: T) => T): this;
+}
+export declare class RandomValue extends ValueGetter<number> {
+    private min;
+    private max;
+    onCreate(props: [min: number, max: number]): void;
+    getValue(time?: number): number;
+    toUniform(): Float32Array;
+    map(func: any): this;
+}
+export declare class RandomVectorValue extends ValueGetter<number[]> {
+    private min;
+    private max;
+    onCreate(props: [min: number[], max: number[]]): void;
+    getValue(time: number): number[];
+    map(func: any): this;
+}
+export declare class LinearValue extends ValueGetter<number> {
+    private min;
+    private max;
+    private xCoord;
+    onCreate(props: [min: number, max: number]): void;
+    getValue(t: number): number;
+    toUniform(): Float32Array;
+    getIntegrateValue(t0: number, t1: number, timeScale?: number): number;
+    getIntegrateByTime(t0: number, t1: number): number;
+    map(func: (num: number) => number): this;
+    scaleXCoord(scale: number): LinearValue;
+}
+export declare class GradientValue extends ValueGetter<number[]> {
+    stops: ColorStop[];
+    onCreate(props: number[][] | Record<string, string>): void;
+    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[][];
+    onCreate(props: ({
+        time: number;
+        value: number;
+    } & number[])[]): void;
+    getValue(time: number): number;
+    getIntegrateValue(t0: number, t1: number, ts?: number): number;
+    getIntegrateByTime(t0: number, t1: number): number;
+    private integrate;
+    toData(): Float32Array;
+    toUniform(meta: any): Float32Array;
+    map(func: (k: number) => number): this;
+    scaleXCoord(scale: number): this;
+}
+export declare class PathSegments extends ValueGetter<number[]> {
+    keys: number[][];
+    values: number[][];
+    onCreate(props: number[][][]): void;
+    getValue(time: number): number[];
+    calculateVec(i: number, dt: number): number[];
+}
+export declare class BezierSegments extends PathSegments {
+    cps: number[][];
+    onCreate(props: number[][][]): void;
+    calculateVec(i: number, t: number): number[];
+}
+export declare function createValueGetter(args: any): ValueGetter<any>;
+export declare function getKeyFrameMetaByRawValue(meta: KeyFrameMeta, value?: [type: spec.ValueType, value: any]): void;
+export declare function createKeyFrameMeta(): {
+    curves: never[];
+    index: number;
+    max: number;
+    lineSegCount: number;
+    curveCount: number;
+};
+export {};