@galacean/effects-plugin-model 0.0.1-alpha.0

package/dist/math/vector2.d.ts

@@ -0,0 +1,394 @@
+import type { Vec2DataType } from './type';
+/**
+ * 表示二维向量/二维点，内部使用 Float32Array 保存数据。
+ */
+declare class Vector2 {
+    private _data;
+    constructor(x?: number, y?: number);
+    get x(): number;
+    set x(value: number);
+    getX(): number;
+    setX(value: number): void;
+    get y(): number;
+    set y(value: number);
+    getY(): number;
+    setY(value: number): void;
+    set(x: number, y: number): void;
+    get xy(): [number, number];
+    set xy(data: [number, number]);
+    /**
+     *
+     * @param x
+     * @param y
+     * @returns
+     */
+    static fromElements(x: number, y: number): Vector2;
+    /**
+     *
+     * @param cartesian
+     * @returns
+     */
+    static clone(cartesian: Vector2 | Readonly<Vector2>): Vector2;
+    /**
+     * 将二维向量打包到数组对象中。
+     * @param value - 待打包的二维向量。
+     * @param array - 保存打包向量数据。
+     * @param startingIndex - 保存数据数组元素起始索引，默认在数组起始位置保存数据。
+     * @returns 返回打包好的二维数据。
+     */
+    static pack(value: Vector2 | Readonly<Vector2>, array: Vec2DataType, startingIndex?: number): Vec2DataType;
+    /**
+     * 从数组中解包二维向量
+     * @param array - 待解包的数组
+     * @param startingIndex - 从数组第几个位置开始解包二维向量
+     * @param result - 保存解包后的二维向量
+     * @returns 返回解包后的二维向量
+     */
+    static unpack(array: Vec2DataType, startingIndex: number, result: Vector2): Vector2;
+    /**
+     * 将二维向量数组打包到数组中
+     * @param array - 需要打包的二维向量数组
+     * @param result - 保存打包后的数组
+     * @returns
+     */
+    static packArray(array: Vector2[] | Readonly<Vector2>[], result: Vec2DataType): Vec2DataType;
+    /**
+     * 将数组解包成二维向量数组
+     * @param array
+     * @param result
+     * @returns
+     */
+    static unpackArray(array: Vec2DataType, result: Vector2[]): Vector2[];
+    /**
+     *
+     * @param array
+     * @returns
+     */
+    static fromArray(array: Vec2DataType): Vector2;
+    /**
+     * 返回二维向量 x 和 y 的最大值
+     * @param cartesian
+     * @returns
+     */
+    static maximumComponent(cartesian: Vector2 | Readonly<Vector2>): number;
+    /**
+     * 返回二维向量 x 和 y 的最小值
+     * @param cartesian
+     * @returns
+     */
+    static minimumComponent(cartesian: Vector2 | Readonly<Vector2>): number;
+    /**
+     * 返回一个新的二维向量，保存输入两个向量各分量的最小值
+     * @param first
+     * @param second
+     * @param result
+     * @returns
+     */
+    static minimumByComponent(first: Vector2 | Readonly<Vector2>, second: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 返回一个新的二维向量，保存输入两个向量各分量的最大值
+     * @param first
+     * @param second
+     * @param result
+     * @returns
+     */
+    static maximumByComponent(first: Vector2 | Readonly<Vector2>, second: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 返回二维向量模的平方
+     * @param cartesian
+     * @returns
+     */
+    static magnitudeSquared(cartesian: Vector2 | Readonly<Vector2>): number;
+    /**
+     * 返回二维向量的模
+     * @param cartesian
+     * @returns
+     */
+    static magnitude(cartesian: Vector2 | Readonly<Vector2>): number;
+    /**
+     * 返回两个二维向量的距离
+     * @param left
+     * @param right
+     * @returns
+     */
+    static distance(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>): number;
+    /**
+     * 返回两个二维向量距离的平方
+     * @param left
+     * @param right
+     * @returns
+     */
+    static distanceSquared(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>): number;
+    /**
+     * 单位化二维向量
+     * @param cartesian
+     * @param result
+     * @returns
+     */
+    static normalize(cartesian: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 计算两个二维向量的点积
+     * @param left
+     * @param right
+     * @returns
+     */
+    static dot(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>): number;
+    /**
+     * 计算两个二维向量的叉积
+     * @param left
+     * @param right
+     * @returns
+     */
+    static cross(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>): number;
+    /**
+     * 两个二维向量对应元素相乘
+     * @param left
+     * @param right
+     * @param result
+     * @returns
+     */
+    static multiplyComponents(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 两个二维向量对应元素相除（内部不会检查除数为 0 情况）
+     * @param left
+     * @param right
+     * @param result
+     * @returns
+     */
+    static divideComponents(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 两个二维向量对应元素相加
+     * @param left
+     * @param right
+     * @param result
+     * @returns
+     */
+    static add(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 两个二维向量对应元素相减
+     * @param left
+     * @param right
+     * @param result
+     * @returns
+     */
+    static subtract(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 二维向量元素乘一个标量
+     * @param cartesian
+     * @param scalar
+     * @param result
+     * @returns
+     */
+    static multiplyByScalar(cartesian: Vector2 | Readonly<Vector2>, scalar: number, result: Vector2): Vector2;
+    /**
+     * 二维向量元素除一个标量
+     * @param cartesian
+     * @param scalar
+     * @param result
+     * @returns
+     */
+    static divideByScalar(cartesian: Vector2 | Readonly<Vector2>, scalar: number, result: Vector2): Vector2;
+    /**
+     * 二维向量各元素相反数
+     * @param cartesian
+     * @param result
+     * @returns
+     */
+    static negate(cartesian: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 二维向量各元素取绝对值
+     * @param cartesian
+     * @param result
+     * @returns
+     */
+    static abs(cartesian: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 计算两个向量的线性插值结果
+     * @param start
+     * @param end
+     * @param t
+     * @param result
+     * @returns
+     */
+    static lerp(start: Vector2 | Readonly<Vector2>, end: Vector2 | Readonly<Vector2>, t: number, result: Vector2): Vector2;
+    /**
+     * 计算两个二维向量的夹角角度
+     * @param left
+     * @param right
+     * @returns
+     */
+    static angleBetween(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>): number;
+    static mostOrthogonalAxis(cartesian: Vector2 | Readonly<Vector2>, result: Vector2): Vector2;
+    /**
+     * 比较两个二维向量对应元素是否相等
+     * @param left
+     * @param right
+     * @returns
+     */
+    static equals(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>): boolean;
+    /**
+     *
+     * @param cartesian
+     * @param array
+     * @param offset
+     * @returns
+     */
+    static equalsArray(cartesian: Vector2 | Readonly<Vector2>, array: Vec2DataType, offset?: number): boolean;
+    /**
+     * 二维向量对应元素是否相等
+     * @param left
+     * @param right
+     * @param relativeEpsilon
+     * @param absoluteEpsilon
+     * @returns
+     */
+    static equalsEpsilon(left: Vector2 | Readonly<Vector2>, right: Vector2 | Readonly<Vector2>, relativeEpsilon: number, absoluteEpsilon: number): boolean;
+    static max(a: Vector2, b: Vector2, result: Vector2): Vector2;
+    static min(a: Vector2, b: Vector2, result: Vector2): Vector2;
+    static mix(a: Vector2, b: Vector2, t: number, result: Vector2): Vector2;
+    static floor(a: Vector2, result: Vector2): Vector2;
+    static ceil(a: Vector2, result: Vector2): Vector2;
+    static round(a: Vector2, result: Vector2): Vector2;
+    /**
+     * 将向量导出 number[] 对象
+     * @returns
+     */
+    toArray(): number[];
+    /**
+     * 克隆出一个新的二维向量
+     * @returns
+     */
+    clone(): Vector2;
+    /**
+     * 将二维向量数据拷贝给 result
+     * @param result
+     * @returns
+     */
+    copyTo(result: Vector2): Vector2;
+    /**
+     * 与标量相加
+     * @param value
+     * @returns
+     */
+    addScalar(value: number): this;
+    /**
+     * 与二维向量相加
+     * @param vector
+     * @returns
+     */
+    addVector(vector: Vector2): Vector2;
+    /**
+     * 与标量相减
+     * @param value
+     * @returns
+     */
+    subScalar(value: number): this;
+    /**
+     * 与向量相减
+     * @param vector
+     * @returns
+     */
+    subVector(vector: Vector2): Vector2;
+    /**
+     * 与标量相乘
+     * @param value
+     * @returns
+     */
+    multiplyScalar(value: number): Vector2;
+    /**
+     * 与向量相乘
+     * @param vector
+     * @returns
+     */
+    multiplyVector(vector: Vector2): Vector2;
+    /**
+     * 与向量相除
+     * @param vector
+     * @returns
+     */
+    divideVector(vector: Vector2): Vector2;
+    /**
+     * 与标量相除
+     * @param value
+     * @returns
+     */
+    divideScalar(value: number): Vector2;
+    /**
+     * 分量中最小值
+     * @returns
+     */
+    min(): number;
+    /**
+     * 分量中最大值
+     * @returns
+     */
+    max(): number;
+    /**
+     * 分别使用 min 和 max 对应的分量对向量进行 clamp 运算
+     * @param min
+     * @param max
+     * @returns
+     */
+    clamp(min: Vector2, max: Vector2): Vector2;
+    /**
+     * 各分量分别进行 floor 运算
+     * @returns
+     */
+    floor(): Vector2;
+    /**
+     * 各分量分别进行 ceil 运算
+     * @returns
+     */
+    ceil(): Vector2;
+    /**
+     * 各分量分别进行 round 运算
+     * @returns
+     */
+    round(): Vector2;
+    /**
+     * 各分量分别执行相反数运算
+     * @returns
+     */
+    negate(): Vector2;
+    /**
+     * 与另一个向量点积运算
+     * @param v
+     * @returns
+     */
+    dot(v: Vector2): number;
+    /**
+     * 与另一个向量叉积运算
+     * @param v
+     * @returns
+     */
+    cross(v: Vector2): number;
+    /**
+     * 计算向量长度
+     * @returns
+     */
+    length(): number;
+    /**
+     * 计算向量长度平方
+     * @returns
+     */
+    lengthSquared(): number;
+    /**
+     * 单位化向量
+     * @returns
+     */
+    normalize(): Vector2;
+    /**
+     * 计算向量与量一个向量夹角角度，弧度
+     * @param v
+     * @returns
+     */
+    angleTo(v: Vector2): number;
+    distanceTo(v: Vector2): number;
+    distanceSquaredTo(v: Vector2): number;
+    getData(): Float32Array;
+    static ZERO: Readonly<Vector2>;
+    static ONE: Readonly<Vector2>;
+    static UNIT_X: Readonly<Vector2>;
+    static UNIT_Y: Readonly<Vector2>;
+}
+export { Vector2 };

package/dist/math/vector3.d.ts

@@ -0,0 +1,164 @@
+import type { Quaternion } from './quaternion';
+import type { Vec3DataType } from './type';
+declare class Vector3 {
+    private _data;
+    constructor(x?: number, y?: number, z?: number);
+    get x(): number;
+    set x(value: number);
+    getX(): number;
+    setX(value: number): void;
+    get y(): number;
+    set y(value: number);
+    getY(): number;
+    setY(value: number): void;
+    get z(): number;
+    set z(value: number);
+    getZ(): number;
+    setZ(value: number): void;
+    set(x: number, y: number, z: number): void;
+    get xyz(): [number, number, number];
+    set xyz(data: [number, number, number]);
+    static fromElements(x: number, y: number, z: number): Vector3;
+    static clone(cartesian: Vector3 | Readonly<Vector3>): Vector3;
+    static pack(value: Vector3, array: Vec3DataType, startingIndex?: number): Vec3DataType;
+    static unpack(array: Vec3DataType, startingIndex: number, result: Vector3): Vector3;
+    static packArray(array: Vector3[], result: Vec3DataType): Vec3DataType;
+    static unpackArray(array: Vec3DataType, result: Vector3[]): Vector3[];
+    /**
+     *
+     * @param array
+     * @returns
+     */
+    static fromArray(array: Vec3DataType): Vector3;
+    static maximumComponent(cartesian: Vector3): number;
+    static minimumComponent(cartesian: Vector3): number;
+    static minComponentIndex(cartesian: Vector3): 0 | 1 | 2;
+    static tryZUpVector(lookatDir: Vector3, result: Vector3): Vector3;
+    static computeUpVector(lookatDir: Vector3, result: Vector3): Vector3;
+    static minimumByComponent(first: Vector3, second: Vector3, result: Vector3): Vector3;
+    static maximumByComponent(first: Vector3, second: Vector3, result: Vector3): Vector3;
+    static magnitudeSquared(cartesian: Vector3 | Readonly<Vector3>): number;
+    static magnitude(cartesian: Vector3 | Readonly<Vector3>): number;
+    static distance(left: Vector3, right: Vector3): number;
+    static distanceSquared(left: Vector3, right: Vector3): number;
+    static normalize(cartesian: Vector3 | Readonly<Vector3>, result: Vector3): Vector3;
+    static dot(left: Vector3, right: Vector3): number;
+    static multiplyComponents(left: Vector3, right: Vector3, result: Vector3): Vector3;
+    static divideComponents(left: Vector3, right: Vector3, result: Vector3): Vector3;
+    static add(left: Vector3, right: Vector3, result: Vector3): Vector3;
+    static subtract(left: Vector3, right: Vector3, result: Vector3): Vector3;
+    static multiplyByScalar(cartesian: Vector3, scalar: number, result: Vector3): Vector3;
+    static divideByScalar(cartesian: Vector3, scalar: number, result: Vector3): Vector3;
+    static negate(cartesian: Vector3, result: Vector3): Vector3;
+    static abs(cartesian: Vector3, result: Vector3): Vector3;
+    static clamp(target: Vector3, min: Vector3, max: Vector3): Vector3;
+    static lerp(start: Vector3, end: Vector3, t: number, result: Vector3): Vector3;
+    static angleBetween(left: Vector3, right: Vector3): number;
+    static mostOrthogonalAxis(cartesian: Vector3, result: Vector3): Vector3;
+    static projectVector(a: Vector3, b: Vector3, result: Vector3): Vector3;
+    static equals(left: Vector3, right: Vector3): boolean;
+    static equalsArray(cartesian: Vector3, array: Vec3DataType, offset?: number): boolean;
+    static equalsEpsilon(left: Vector3, right: Vector3, relativeEpsilon: number, absoluteEpsilon: number): boolean;
+    static cross(left: Vector3, right: Vector3, result?: Vector3): Vector3;
+    static midpoint(left: Vector3, right: Vector3, result: Vector3): Vector3;
+    /**
+     * 计算两个向量各分量最小值
+     * @param a
+     * @param b
+     * @returns
+     */
+    static min(a: Vector3, b: Vector3, result: Vector3): Vector3;
+    /**
+     * 计算两个向量各分量最大值
+     * @param a
+     * @param b
+     * @returns
+     */
+    static max(a: Vector3, b: Vector3, result: Vector3): Vector3;
+    /**
+     * 混合两个向量
+     * @param a
+     * @param b
+     * @param t
+     * @returns
+     */
+    static mix(a: Vector3, b: Vector3, t: number, result: Vector3): Vector3;
+    static floor(a: Vector3, result: Vector3): Vector3;
+    static ceil(a: Vector3, result: Vector3): Vector3;
+    static round(a: Vector3, result: Vector3): Vector3;
+    /**
+     * 将三维向量数据拷贝给 result
+     * @param result
+     */
+    copyTo(result: Vector3): Vector3;
+    /**
+     * 将三维向量数据从 source 拷贝回来
+     * @param source
+     */
+    copyFrom(source: Vector3): this;
+    /**
+     * 三维向量数据取 min
+     * @param vec
+     */
+    min(vec: Vector3): this;
+    /**
+     * 三维向量数据取 max
+     * @param vec
+     */
+    max(vec: Vector3): this;
+    /**
+     * 将三维向量数据从 clamp
+     * @param min
+     * @param max
+     */
+    clamp(min: Vector3, max: Vector3): this;
+    /**
+     * 将三维向量导出为 number[] 对象
+     */
+    toArray(): number[];
+    /**
+     * 使用向量数据克隆一个新的三维向量
+     * @returns
+     */
+    clone(): Vector3;
+    /**
+     * 单位化三维向量，会直接修改原向量数据
+     */
+    normalize(): Vector3;
+    /**
+     * 返回三维向量长度
+     * @returns
+     */
+    length(): number;
+    sum(): number;
+    /**
+     * 返回向量长度的平方
+     * @returns
+     */
+    lengthSquared(): number;
+    floor(): Vector3;
+    ceil(): Vector3;
+    round(): Vector3;
+    negate(): Vector3;
+    addScalar(value: number): this;
+    addVector(vector: Vector3): this;
+    subScalar(value: number): this;
+    subVector(vector: Vector3): Vector3;
+    multiplyScalar(value: number): Vector3;
+    multiplyVector(vector: Vector3): Vector3;
+    divideScalar(value: number): Vector3;
+    divideVector(vector: Vector3): Vector3;
+    dot(vector: Vector3): number;
+    cross(vector: Vector3): Vector3;
+    distanceTo(v: Vector3): number;
+    distanceSquaredTo(v: Vector3): number;
+    angleTo(v: Vector3): number;
+    getData(): Float32Array;
+    applyQuaternion(q: Quaternion, center?: Vector3): this;
+    static ZERO: Readonly<Vector3>;
+    static ONE: Readonly<Vector3>;
+    static UNIT_X: Readonly<Vector3>;
+    static UNIT_Y: Readonly<Vector3>;
+    static UNIT_Z: Readonly<Vector3>;
+}
+export { Vector3 };

package/dist/math/vector4.d.ts

@@ -0,0 +1,132 @@
+import type { Vec4DataType } from './type';
+/**
+ * 四维向量
+ */
+declare class Vector4 {
+    private _data;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    get x(): number;
+    set x(value: number);
+    getX(): number;
+    setX(value: number): void;
+    get y(): number;
+    set y(value: number);
+    getY(): number;
+    setY(value: number): void;
+    get z(): number;
+    set z(value: number);
+    getZ(): number;
+    setZ(value: number): void;
+    get w(): number;
+    set w(value: number);
+    getW(): number;
+    setW(value: number): void;
+    set(x: number, y: number, z: number, w: number): void;
+    static fromElements(x: number, y: number, z: number, w: number, result?: Vector4): Vector4;
+    static clone(cartesian: Vector4 | Readonly<Vector4>): Vector4;
+    static pack(value: Vector4, array: Vec4DataType, startingIndex?: number): Vec4DataType;
+    static unpack(array: Vec4DataType, startingIndex: number, result: Vector4): Vector4;
+    static packArray(array: Vector4[], result: Vec4DataType): Vec4DataType;
+    static unpackArray(array: Vec4DataType, result: Vector4[]): Vector4[];
+    static fromArray(array: Vec4DataType): Vector4;
+    static maximumComponent(cartesian: Vector4): number;
+    static minimumComponent(cartesian: Vector4): number;
+    static minimumByComponent(first: Vector4, second: Vector4, result: Vector4): Vector4;
+    static maximumByComponent(first: Vector4, second: Vector4, result: Vector4): Vector4;
+    static magnitudeSquared(cartesian: Vector4): number;
+    static magnitude(cartesian: Vector4): number;
+    static distance(left: Vector4, right: Vector4): number;
+    static distanceSquared(left: Vector4, right: Vector4): number;
+    static normalize(cartesian: Vector4, result: Vector4): Vector4;
+    static dot(left: Vector4, right: Vector4): number;
+    static multiplyComponents(left: Vector4, right: Vector4, result: Vector4): Vector4;
+    static divideComponents(left: Vector4, right: Vector4, result: Vector4): Vector4;
+    static add(left: Vector4, right: Vector4, result: Vector4): Vector4;
+    static subtract(left: Vector4, right: Vector4, result: Vector4): Vector4;
+    static multiplyByScalar(cartesian: Vector4, scalar: number, result: Vector4): Vector4;
+    static divideByScalar(cartesian: Vector4, scalar: number, result: Vector4): Vector4;
+    static negate(cartesian: Vector4, result: Vector4): Vector4;
+    static abs(cartesian: Vector4, result: Vector4): Vector4;
+    static lerp(start: Vector4, end: Vector4, t: number, result: Vector4): Vector4;
+    static mostOrthogonalAxis(cartesian: Vector4, result: Vector4): Vector4;
+    static equals(left: Vector4, right: Vector4): boolean;
+    static equalsArray(cartesian: Vector4, array: Vec4DataType, offset?: number): boolean;
+    static equalsEpsilon(left: Vector4, right: Vector4, relativeEpsilon: number, absoluteEpsilon: number): boolean;
+    /**
+     * 将四维向量导出为 number[] 对象
+     * @returns
+     */
+    toArray(): number[];
+    /**
+     * 计算两个向量各分量最小值
+     * @param a
+     * @param b
+     * @returns
+     */
+    static min(a: Vector4, b: Vector4, result: Vector4): Vector4;
+    /**
+     * 计算两个向量各分量最大值
+     * @param a
+     * @param b
+     * @returns
+     */
+    static max(a: Vector4, b: Vector4, result: Vector4): Vector4;
+    /**
+     * 混合两个向量
+     * @param a
+     * @param b
+     * @param t
+     * @returns
+     */
+    static mix(a: Vector4, b: Vector4, t: number, result: Vector4): Vector4;
+    static floor(a: Vector4, result: Vector4): Vector4;
+    static ceil(a: Vector4, result: Vector4): Vector4;
+    static round(a: Vector4, result: Vector4): Vector4;
+    /**
+     * 将三维向量数据拷贝给 result
+     * @param result
+     */
+    copyTo(result: Vector4): Vector4;
+    /**
+     * 使用向量数据克隆一个新的四维向量
+     * @returns
+     */
+    clone(): Vector4;
+    /**
+     * 单位化三维向量，会直接修改原向量数据
+     */
+    normalize(): Vector4;
+    /**
+     * 返回三维向量长度
+     * @returns
+     */
+    length(): number;
+    /**
+     * 返回向量长度的平方
+     * @returns
+     */
+    lengthSquared(): number;
+    floor(): Vector4;
+    ceil(): Vector4;
+    round(): Vector4;
+    negate(): Vector4;
+    addScalar(value: number): this;
+    addVector(vector: Vector4): Vector4;
+    subScalar(value: number): this;
+    subVector(vector: Vector4): Vector4;
+    multiplyScalar(value: number): Vector4;
+    multiplyVector(vector: Vector4): Vector4;
+    divideScalar(value: number): Vector4;
+    divideVector(vector: Vector4): Vector4;
+    dot(vector: Vector4): number;
+    distanceTo(v: Vector4): number;
+    distanceSquaredTo(v: Vector4): number;
+    getData(): Float32Array;
+    static ZERO: Readonly<Vector4>;
+    static ONE: Readonly<Vector4>;
+    static UNIT_X: Readonly<Vector4>;
+    static UNIT_Y: Readonly<Vector4>;
+    static UNIT_Z: Readonly<Vector4>;
+    static UNIT_W: Readonly<Vector4>;
+}
+export { Vector4 };

package/dist/plugin/const.d.ts

@@ -0,0 +1,2 @@
+import type { spec } from '@galacean/effects';
+export declare const VFX_ITEM_TYPE_3D: spec.ItemType;

package/dist/plugin/index.d.ts

@@ -0,0 +1,6 @@
+export * from './const';
+export * from './model-plugin';
+export * from './model-vfx-item';
+export * from './model-tree-item';
+export * from './model-tree-plugin';
+export * from './model-tree-vfx-item';