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

package/dist/math/matrix4.d.ts

@@ -0,0 +1,264 @@
+import { Vector3 } from './vector3';
+import { Vector4 } from './vector4';
+import { Matrix3 } from './matrix3';
+import { Quaternion } from './quaternion';
+import type { Mat4DataType } from './type';
+/**
+ * 表示一个 4x4 矩阵
+ */
+declare class Matrix4 {
+    private _data;
+    constructor(column0Row0?: number, column1Row0?: number, column2Row0?: number, column3Row0?: number, column0Row1?: number, column1Row1?: number, column2Row1?: number, column3Row1?: number, column0Row2?: number, column1Row2?: number, column2Row2?: number, column3Row2?: number, column0Row3?: number, column1Row3?: number, column2Row3?: number, column3Row3?: number);
+    /**
+     * 获取矩阵内部存储数据的Float32Array对象。
+     * @returns
+     */
+    getData(): Float32Array;
+    setData(data: Float32Array): void;
+    get data(): Float32Array;
+    lookAt(position: Vector3, target: Vector3, up: Vector3): Matrix4;
+    perspective(fovY: number, aspect: number, near: number, far: number, reverse: boolean): Matrix4;
+    orth2d(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
+    compose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4;
+    decompose(): {
+        translation: Vector3;
+        rotation: Quaternion;
+        scale: Vector3;
+    };
+    multiplyByPoint3(result: Vector3): Vector3;
+    setZero(): void;
+    setIdentity(): void;
+    /**
+     * 打包矩阵数据，将矩阵内部数据从数组指定索引位置打包到数组中。
+     * @param value
+     * @param array
+     * @param startingIndex
+     * @returns
+     */
+    static pack(value: Matrix4, array: Mat4DataType, startingIndex?: number): Mat4DataType;
+    /**
+     * 解包矩阵数据，从数组指定索引位置开始解包矩阵数据。
+     * @param array
+     * @param startingIndex
+     * @param result
+     * @returns
+     */
+    static unpack(array: Mat4DataType, startingIndex: number, result: Matrix4): Matrix4;
+    static packArray(array: Matrix4[], result: Mat4DataType): Mat4DataType;
+    static unpackArray(array: Mat4DataType, result: Matrix4[]): Matrix4[];
+    static clone(matrix: Matrix4 | Readonly<Matrix4>): Matrix4;
+    static copyTo(matrix: Matrix4, result: Matrix4): Matrix4;
+    static fromArray(array: Mat4DataType): Matrix4;
+    static fromColumnMajorArray(values: Mat4DataType, result: Matrix4): Matrix4;
+    static fromRowMajorArray(values: Mat4DataType, result: Matrix4): Matrix4;
+    static fromRotationTranslation(rotation: Matrix3 | Readonly<Matrix3>, translation: Vector3, result: Matrix4): Matrix4;
+    static fromTranslationQuaternionRotationScale(translation: Vector3, rotation: Quaternion, scale: Vector3, result: Matrix4): Matrix4;
+    static fromTranslationRotationScale(translationRotationScale: {
+        translation: Vector3;
+        rotation: Quaternion;
+        scale: Vector3;
+    }, result: Matrix4): Matrix4;
+    static fromTranslation(translation: Vector3, result: Matrix4): Matrix4;
+    static fromScale(scale: Vector3, result: Matrix4): Matrix4;
+    static fromUniformScale(scale: number, result: Matrix4): Matrix4;
+    static fromRotation(rotation: Matrix3, result: Matrix4): Matrix4;
+    static fromCamera(camera: {
+        position: Vector3;
+        direction: Vector3;
+        up: Vector3;
+    }, result: Matrix4): Matrix4;
+    static computePerspectiveFieldOfView(fov: number, aspectRatio: number, near: number, far: number, reverse: boolean, result: Matrix4): Matrix4;
+    static computeOrthographicOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
+    static computePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
+    static computeInfinitePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, result: Matrix4): Matrix4;
+    static computeViewportTransformation(viewport: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, nearDepthRange: number, farDepthRange: number, result: Matrix4): Matrix4;
+    static computeView(position: Vector3, direction: Vector3, up: Vector3, right: Vector3, result: Matrix4): Matrix4;
+    static toArray(matrix: Matrix4, result: Mat4DataType): Mat4DataType;
+    static getElement(matrix: Matrix4, column: number, row: number): number;
+    static getColumn(matrix: Matrix4, index: number, result: Vector4): Vector4;
+    static setColumn(matrix: Matrix4, index: number, cartesian: Vector4, result: Matrix4): Matrix4;
+    static getRow(matrix: Matrix4, index: number, result: Vector4): Vector4;
+    static setRow(matrix: Matrix4, index: number, cartesian: Vector4, result: Matrix4): Matrix4;
+    static setTranslation(matrix: Matrix4, translation: Vector3, result: Matrix4): Matrix4;
+    static scale(matrix: Matrix4, scale: Vector3, result: Matrix4): Matrix4;
+    static setUniformScale(matrix: Matrix4, scale: number, result: Matrix4): Matrix4;
+    static getScale(matrix: Matrix4, result: Vector3): Vector3;
+    static getMaximumScale(matrix: Matrix4): number;
+    static setRotation(matrix: Matrix4, rotation: Matrix4, result: Matrix4): Matrix4;
+    static getRotation(matrix: Matrix4, result: Matrix4): Matrix4;
+    static getRotationMatrix3(matrix: Matrix4, result: Matrix3): Matrix3;
+    static getRotationQuaternion(matrix: Matrix4, result: Quaternion): Quaternion;
+    static multiply(leftM: Matrix4, rightM: Matrix4, result: Matrix4): Matrix4;
+    static mulScalerAddMatrix(leftM: Matrix4, rightM: Matrix4, rightS: number, result: Matrix4): Matrix4;
+    static add(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
+    static subtract(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
+    static multiplyTransformation(leftM: Matrix4, rightM: Matrix4, result: Matrix4): Matrix4;
+    static multiplyByMatrix3(matrix: Matrix4, rotation: Matrix3, result: Matrix4): Matrix4;
+    static multiplyByTranslation(matrix: Matrix4, translation: Vector3, result: Matrix4): Matrix4;
+    static multiplyByScale(matrix: Matrix4, scale: Vector3, result: Matrix4): Matrix4;
+    static multiplyByUniformScale(matrix: Matrix4, scale: number, result: Matrix4): Matrix4;
+    static multiplyByVector(matrix: Matrix4, cartesian: Vector4, result: Vector4): Vector4;
+    static multiplyByPointAsVector(matrix: Matrix4, cartesian: Vector3, result: Vector3): Vector3;
+    /**
+     * 矩阵与三维点/向量相乘，三维点/向量第四个分量 W 为 1 处理
+     * @param matrix
+     * @param cartesian
+     * @param result
+     * @returns
+     */
+    static multiplyByPoint(matrix: Matrix4, cartesian: Vector3, result: Vector3): Vector3;
+    static multiplyByScalar(matrix: Matrix4, scalar: number, result: Matrix4): Matrix4;
+    static negate(matrix: Matrix4, result: Matrix4): Matrix4;
+    static transpose(matrix: Matrix4, result: Matrix4): Matrix4;
+    static abs(matrix: Matrix4, result: Matrix4): Matrix4;
+    static equals(left: Matrix4, right: Matrix4): boolean;
+    static equalsEpsilon(left: Matrix4, right: Matrix4, epsilon: number): boolean;
+    static getTranslation(matrix: Matrix4, result: Vector3): Vector3;
+    static getMatrix3(matrix: Matrix4, result: Matrix3): Matrix3;
+    static inverse(matrix: Matrix4, result: Matrix4): Matrix4;
+    static inverseTransformation(matrix: Matrix4, result: Matrix4): Matrix4;
+    static inverseTranspose(matrix: Matrix4, result: Matrix4): Matrix4;
+    static equalsArray(matrix: Matrix4, array: Mat4DataType, offset?: number): boolean;
+    determinant(): number;
+    /**
+     * 分解矩阵，将矩阵分解为平移、旋转、缩放三部分
+     * @param m - 待分解的矩阵
+     * @returns
+     */
+    static decompose(m: Matrix4): {
+        translation: Vector3;
+        rotation: Quaternion;
+        scale: Vector3;
+    };
+    /**
+     * 从平移、旋转、缩放合成一个新变换矩阵
+     * @param translation - 平移向量
+     * @param rotation - 旋转量，使用四元数表示
+     * @param scale - 缩放向量
+     * @returns
+     */
+    static compose(translation: Vector3, rotation: Quaternion, scale: Vector3, result: Matrix4): Matrix4;
+    /**
+     * 计算透视投影矩阵
+     * @param fovY
+     * @param aspect
+     * @param near
+     * @param far
+     * @returns
+     */
+    static computePerspective(fovY: number, aspect: number, near: number, far: number, reverse: boolean, result: Matrix4): Matrix4;
+    /**
+     * 计算正交投影矩阵
+     * @param left
+     * @param right
+     * @param bottom
+     * @param top
+     * @param near
+     * @param far
+     * @param result
+     * @returns
+     */
+    static computeOrthographic(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
+    /**
+     * 通过 LookAt 参数计算相机的视图矩阵
+     * @param position
+     * @param target
+     * @param up
+     * @param result
+     * @returns
+     */
+    static computeLookAt(position: Vector3, target: Vector3, up: Vector3, result: Matrix4): Matrix4;
+    /**
+     * 使用矩阵内部数据构造一个新矩阵
+     * @returns
+     */
+    clone(): Matrix4;
+    /**
+     * 将矩阵数据拷贝到 result 中
+     * @param result
+     * @returns
+     */
+    copyTo(result: Matrix4): Matrix4;
+    /**
+     * 将矩阵数据从 source 拷贝回来
+     * @param source
+     * @returns
+     */
+    copyFrom(source: Matrix4): this;
+    /**
+     * 平移矩阵，相当于该矩阵与使用 vector 构造的平移矩阵相乘
+     * @param vector
+     * @returns 🎯计算结果将保存在调用矩阵中，并作为函数返回值返回。
+     */
+    translate(vector: Vector3): Matrix4;
+    /**
+     * 使用 vector 缩放矩阵，相当于该矩阵与使用 vector 构造的缩放矩阵相乘。
+     * @param vector
+     * @returns 🎯计算结果将保存在调用矩阵中，并作为函数返回值返回。
+     */
+    scale(vector: Vector3): Matrix4;
+    /**
+     * 计算矩阵与输入矩阵相乘的结果。
+     * @param matrix
+     * @returns 🎯计算结果将保存在调用矩阵中，并作为函数返回值返回。
+     */
+    multiply(matrix: Matrix4): Matrix4;
+    /**
+     * 将矩阵数据按照列主序导出为 number[] 对象。
+     * @returns
+     */
+    toArray(): number[];
+    /**
+     * 将矩阵按照列主序方式导出为 Float32Array 对象。
+     * @returns
+     */
+    toFloat32Array(): Float32Array;
+    /**
+     * 矩阵与四维向量相乘。
+     * @param vector
+     * @returns
+     */
+    multiplyByVector4(vector: Vector4): Vector4;
+    /**
+     * 矩阵与三维向量相乘，内部将三维向量第四个分量当作 1 来处理。
+     * @param vector
+     * @returns
+     */
+    multiplyByVector3(vector: Vector3): Vector3;
+    /**
+     * 返回矩阵中指定索引位置数据
+     * @param index
+     * @returns
+     */
+    at(index: number): number;
+    /**
+     * 矩阵乘一个旋转矩阵，矩阵乘一个绕 axis 轴旋转 angle 角度的旋转矩阵
+     * @param angle
+     * @param axis
+     * @returns
+     */
+    rotate(angle: number, axis: Vector3): Matrix4 | undefined;
+    /**
+     * 计算矩阵的逆矩阵，会修改矩阵数据
+     */
+    inverse(): Matrix4;
+    /**
+     * 计算矩阵的转置，结果保存在原矩阵中（会修改矩阵数据）
+     * @returns
+     */
+    transpose(): Matrix4;
+    /**
+     * 4x4 单位矩阵
+     */
+    static IDENTITY: Readonly<Matrix4>;
+    /**
+     * 数据都为 0 的矩阵
+     */
+    static ZERO: Readonly<Matrix4>;
+}
+export { Matrix4 };

package/dist/math/quaternion.d.ts

@@ -0,0 +1,214 @@
+import { Matrix4 } from './matrix4';
+import { Matrix3 } from './matrix3';
+import type { Vec4DataType } from './type';
+import { Vector3 } from './vector3';
+import type { Euler } from './euler';
+/**
+ * 使用四元数表示一个旋转
+ */
+declare class Quaternion {
+    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;
+    /**
+     * 构造一个四元素表示绕 axis 轴旋转 angle 角度
+     * @param axis
+     * @param angle
+     * @param result
+     * @returns
+     */
+    static fromAxisAngle(axis: Vector3 | Readonly<Vector3>, angle: number, result: Quaternion): Quaternion;
+    /**
+     * 从旋转矩阵构造一个四元数
+     * @param matrix
+     * @param result
+     * @returns
+     */
+    static fromRotationMatrix(matrix: Matrix3, result: Quaternion): Quaternion;
+    /**
+     * 从相机 heading、pitch、roll 构造一个四元数。heading 表示绕 z 轴旋转角度、pitch 表示绕 y 轴旋转角度、roll 表示绕 x 轴旋转角度
+     * @param headingPitchRoll
+     * @param result
+     * @returns
+     */
+    static fromHeadingPitchRoll(headingPitchRoll: {
+        heading: number;
+        pitch: number;
+        roll: number;
+    }, result: Quaternion): Quaternion;
+    /**
+     * 将欧拉角转成四元数
+     * @param euler
+     * @param result
+     * @returns
+     */
+    static setFromEuler(euler: Euler, result: Quaternion): Quaternion;
+    /**
+     * 四元数打包成数组
+     * @param value
+     * @param array
+     * @param startingIndex
+     * @returns
+     */
+    static pack(value: Quaternion, array: Vec4DataType, startingIndex?: number): Vec4DataType;
+    /**
+     * 从数组中解包四元数
+     * @param array
+     * @param startingIndex
+     * @param result
+     * @returns
+     */
+    static unpack(array: Vec4DataType, startingIndex: number, result: Quaternion): Quaternion;
+    /**
+     * 从数组构造一个四元数
+     * @param array
+     * @param startingIndex
+     * @param result
+     * @returns
+     */
+    static fromArray(array: Vec4DataType): Quaternion;
+    /**
+     * 两个四元数相乘
+     * @param left
+     * @param right
+     * @param result
+     * @returns
+     */
+    static multiply(left: Quaternion, right: Quaternion, result: Quaternion): Quaternion;
+    /**
+     * 从输入四元数克隆一个四元数
+     * @param quaternion
+     * @param result
+     * @returns
+     */
+    static clone(quaternion: Quaternion | Readonly<Quaternion>): Quaternion;
+    static copyTo(quaternion: Quaternion | Readonly<Quaternion>, result: Quaternion): Quaternion;
+    /**
+     * 四元数的共轭
+     * @param quaternion
+     * @param result
+     * @returns
+     */
+    static conjugate(quaternion: Quaternion, result: Quaternion): Quaternion;
+    /**
+     * 四元数的模的平方
+     * @param quaternion
+     * @returns
+     */
+    static magnitudeSquared(quaternion: Quaternion): number;
+    /**
+     * 四元数的模
+     * @param quaternion
+     * @returns
+     */
+    static magnitude(quaternion: Quaternion): number;
+    /**
+     * 单位化四元数
+     * @param quaternion
+     * @param result
+     * @returns
+     */
+    static normalize(quaternion: Quaternion, result: Quaternion): Quaternion;
+    /**
+     * 四元数求逆
+     * @param quaternion
+     * @param result
+     * @returns
+     */
+    static inverse(quaternion: Quaternion, result: Quaternion): Quaternion;
+    static add(left: Quaternion, right: Quaternion, result: Quaternion): Quaternion;
+    static subtract(left: Quaternion, right: Quaternion, result: Quaternion): Quaternion;
+    static negate(quaternion: Quaternion, result: Quaternion): Quaternion;
+    static dot(left: Quaternion, right: Quaternion): number;
+    static multiplyByScalar(quaternion: Quaternion, scalar: number, result: Quaternion): Quaternion;
+    static computeAxis(quaternion: Quaternion, result: Vector3): Vector3;
+    /**
+     * 计算旋转角度
+     * @param quaternion
+     * @returns
+     */
+    static computeAngle(quaternion: Quaternion): number;
+    /**
+     * 线性插值
+     * @param start
+     * @param end
+     * @param t
+     * @param result
+     * @returns
+     */
+    static lerp(start: Quaternion, end: Quaternion, t: number, result: Quaternion): Quaternion;
+    /**
+     * 球面线性插值
+     * @param start
+     * @param end
+     * @param t
+     * @param result
+     * @returns
+     */
+    static slerp(start: Quaternion, end: Quaternion, t: number, result: Quaternion): Quaternion;
+    static equals(left: Quaternion, right: Quaternion): boolean;
+    static equalsEpsilon(left: Quaternion, right: Quaternion, epsilon?: number): boolean;
+    /**
+     * 将四元数转变为一个 4x4 矩阵
+     * @param result
+     * @returns
+     */
+    toMatrix4(result: Matrix4): Matrix4;
+    /**
+     * 使用四元数内部数据克隆出一个新的四元数
+     * @returns
+     */
+    clone(): Quaternion;
+    /**
+     * 将四元数数据拷贝给 result
+     * @param result
+     */
+    copyTo(result: Quaternion): Quaternion;
+    /**
+     * 将四元数数据从 source 拷贝回来
+     * @param source
+     */
+    copyFrom(source: Quaternion): this;
+    /**
+     * 绕 x 轴旋转角度分量
+     * @returns
+     */
+    roll(): number;
+    /**
+     * 绕 y 轴旋转分量
+     * @returns
+     */
+    pitch(): number;
+    /**
+     * 绕 z 轴旋转分量
+     * @returns
+     */
+    yaw(): number;
+    inverse(): Quaternion;
+    conjugate(): Quaternion;
+    length(): number;
+    normalize(): Quaternion;
+    add(other: Quaternion): Quaternion;
+    multiply(other: Quaternion): Quaternion;
+    set(x: number, y: number, z: number, w: number): Quaternion;
+    setFromEuler(euler: Euler): Quaternion;
+    toArray(): number[];
+    static IDENTITY: Readonly<Quaternion>;
+    static ZERO: Readonly<Quaternion>;
+}
+export { Quaternion };

package/dist/math/sphere.d.ts

@@ -0,0 +1,81 @@
+import { Box3 } from './box3';
+import { Vector3 } from './vector3';
+/**
+ * 球体的几何表示
+ */
+declare class Sphere {
+    /** 球半径 */
+    radius: number;
+    /** 球中心点 */
+    center: Vector3;
+    constructor(center?: Vector3, radius?: number);
+    set(center: Vector3, radius: number): Sphere;
+    /**
+     * 从顶点数组中构造一个球
+     * @param points
+     * @param optionalCenter
+     * @returns
+     */
+    setFromPoints(points: Vector3[], optionalCenter?: Vector3): Sphere;
+    copyFrom(sphere: Sphere): Sphere;
+    isEmpty(): boolean;
+    makeEmpty(): Sphere;
+    /**
+     * 判断点是否在球内（包含球面）
+     * @param point
+     * @returns
+     */
+    containsPoint(point: Vector3): boolean;
+    /**
+     * 点到球的距离
+     * @param point
+     * @returns
+     */
+    distanceToPoint(point: Vector3): number;
+    /**
+     * 判断球 this 与球 other 是否相交
+     * @param other
+     * @returns
+     */
+    intersectsSphere(other: Sphere): boolean;
+    /**
+     * 判断球与包围盒是否相交
+     * @param box
+     * @returns
+     */
+    intersectsBox(box: Box3): boolean;
+    /**
+     * 限制点只能取球内值
+     * @param point
+     * @param target
+     * @returns
+     */
+    clampPoint(point: Vector3, target: Vector3): Vector3;
+    /**
+     * 获取球体的包围盒
+     * @param target
+     * @returns
+     */
+    getBoundingBox(target: Box3): Box3;
+    /**
+     * 球的三维空间平移
+     * @param offset
+     * @returns
+     */
+    translate(offset: Vector3): Sphere;
+    /**
+     * 通过空间点扩展/缩放球
+     * @param offset
+     * @returns
+     */
+    expandByPoint(point: Vector3): Sphere;
+    /**
+     * 球的并集
+     * @param offset
+     * @returns
+     */
+    union(sphere: Sphere): Sphere;
+    equals(sphere: Sphere): boolean;
+    clone(): Sphere;
+}
+export { Sphere };

package/dist/math/type.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 二维向量内部数据类型
+ */
+type Vec2DataType = number[] | [number, number] | Float32Array;
+/**
+* 三维向量内部数据类型
+*/
+type Vec3DataType = number[] | [number, number, number] | Float32Array;
+/**
+* 四维向量内部数据类型
+*/
+type Vec4DataType = number[] | [number, number, number, number] | Float32Array;
+/**
+* 二维矩阵内部数据类型
+*/
+type Mat2DataType = number[] | [number, number, number, number] | Float32Array;
+/**
+* 三维矩阵内部数据类型
+*/
+type Mat3DataType = number[] | [number, number, number, number, number, number, number, number, number] | Float32Array;
+/**
+* 四维矩阵内部数据类型
+*/
+type Mat4DataType = number[] | [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number] | Float32Array;
+/**
+ * 四元数内部数据类型
+ */
+type QuatDataType = number[] | [number, number, number, number] | Float32Array;
+export { Vec2DataType, Vec3DataType, Vec4DataType, Mat2DataType, Mat3DataType, Mat4DataType, QuatDataType, };

package/dist/math/utilities/index.d.ts

@@ -0,0 +1,9 @@
+declare class MathUtils {
+    static EPSILON6: number;
+    static EPSILON7: number;
+    static EPSILON21: number;
+    static acosClamped(value: number): number;
+    static clamp(value: number, min: number, max: number): number;
+    static equalsEpsilon(left: number, right: number, relativeEpsilon: number, absoluteEpsilon: number): boolean;
+}
+export { MathUtils };