@galacean/effects-plugin-model 1.0.0 → 1.1.0-alpha.0

package/dist/math/index.d.ts

@@ -1,11 +0,0 @@
-export * from './type';
-export * from './vector2';
-export * from './vector3';
-export * from './vector4';
-export * from './matrix2';
-export * from './matrix3';
-export * from './matrix4';
-export * from './quaternion';
-export * from './euler';
-export * from './box3';
-export * from './sphere';

package/dist/math/matrix2.d.ts

@@ -1,58 +0,0 @@
-import type { Mat2DataType } from './type';
-import { Vector2 } from './vector2';
-/**
- * 2x2 矩阵内部按照列主序存储数据
- */
-declare class Matrix2 {
-    private _data;
-    /**
-     * 按照行主序传入矩阵数据
-     * @param column0Row0 - 第0行0列
-     * @param column1Row0 - 第0行1列
-     * @param column0Row1
-     * @param column1Row1
-     */
-    constructor(column0Row0?: number, column1Row0?: number, column0Row1?: number, column1Row1?: number);
-    getData(): Float32Array;
-    static pack(value: Matrix2, array: Mat2DataType, startingIndex?: number): Mat2DataType;
-    static unpack(array: Mat2DataType, startingIndex: number, result: Matrix2): Matrix2;
-    static packArray(array: Matrix2[], result: Mat2DataType): Mat2DataType;
-    static unpackArray(array: Mat2DataType, result: Matrix2[]): Matrix2[];
-    static clone(matrix: Matrix2): Matrix2;
-    static fromArray(array: Mat2DataType): Matrix2;
-    static fromColumnMajorArray(values: Mat2DataType, result: Matrix2): Matrix2;
-    static fromRowMajorArray(values: Mat2DataType, result: Matrix2): Matrix2;
-    static fromScale(scale: Vector2, result: Matrix2): Matrix2;
-    static fromUniformScale(scale: number, result: Matrix2): Matrix2;
-    static fromRotation(angle: number, result: Matrix2): Matrix2;
-    static toArray(matrix: Matrix2, result: Mat2DataType): Mat2DataType;
-    static getElement(matrix: Matrix2, column: number, row: number): number;
-    static getColumn(matrix: Matrix2, index: number, result: Vector2): Vector2;
-    static setColumn(matrix: Matrix2, index: number, cartesian: Vector2, result: Matrix2): Matrix2;
-    static getRow(matrix: Matrix2, index: number, result?: Vector2): Vector2;
-    static setRow(matrix: Matrix2, index: number, cartesian: Vector2, result: Matrix2): Matrix2;
-    static scale(matrix: Matrix2, scale: Vector2, result?: Matrix2): Matrix2;
-    static setUniformScale(matrix: Matrix2, scale: number, result?: Matrix2): Matrix2;
-    static getScale(matrix: Matrix2, result: Vector2): Vector2;
-    static getMaximumScale(matrix: Matrix2): number;
-    static setRotation(matrix: Matrix2, rotation: Matrix2, result: Matrix2): Matrix2;
-    static getRotation(matrix: Matrix2, result: Matrix2): Matrix2;
-    static multiply(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
-    static add(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
-    static subtract(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
-    static multiplyByVector(matrix: Matrix2, cartesian: Vector2, result: Vector2): Vector2;
-    static multiplyByScalar(matrix: Matrix2, scalar: number, result: Matrix2): Matrix2;
-    static multiplyByScale(matrix: Matrix2, scale: Vector2, result: Matrix2): Matrix2;
-    static multiplyByUniformScale(matrix: Matrix2, scale: number, result: Matrix2): Matrix2;
-    static negate(matrix: Matrix2, result: Matrix2): Matrix2;
-    static transpose(matrix: Matrix2, result: Matrix2): Matrix2;
-    static abs(matrix: Matrix2, result: Matrix2): Matrix2;
-    static equals(left: Matrix2, right: Matrix2): boolean;
-    static equalsArray(matrix: Matrix2, array: Mat2DataType, offset?: number): boolean;
-    static equalsEpsilon(left: Matrix2, right: Matrix2, epsilon: number): boolean;
-    copyTo(result: Matrix2): Matrix2;
-    copyFrom(source: Matrix2): this;
-    static IDENTITY: Readonly<Matrix2>;
-    static ZERO: Readonly<Matrix2>;
-}
-export { Matrix2 };

package/dist/math/matrix3.d.ts

@@ -1,113 +0,0 @@
-import { Vector3 } from './vector3';
-import type { Quaternion } from './quaternion';
-import type { Mat3DataType } from './type';
-declare class Matrix3 {
-    private _data;
-    constructor(column0Row0?: number, column1Row0?: number, column2Row0?: number, column0Row1?: number, column1Row1?: number, column2Row1?: number, column0Row2?: number, column1Row2?: number, column2Row2?: number);
-    getData(): Float32Array;
-    static pack(value: Matrix3, array: Mat3DataType, startingIndex?: number): Mat3DataType;
-    static unpack(array: Mat3DataType, startingIndex: number, result: Matrix3): Matrix3;
-    static packArray(array: Matrix3[], result: Mat3DataType): Mat3DataType;
-    static unpackArray(array: Mat3DataType, result: Matrix3[]): Matrix3[];
-    static clone(matrix: Matrix3): Matrix3;
-    static copyTo(matrix: Matrix3, result: Matrix3): Matrix3;
-    static fromArray(array: Mat3DataType): Matrix3;
-    static fromColumnMajorArray(values: Mat3DataType, result: Matrix3): Matrix3;
-    static fromRowMajorArray(values: Mat3DataType, result: Matrix3): Matrix3;
-    static fromQuaternion(quaternion: Quaternion, result: Matrix3): Matrix3;
-    static fromHeadingPitchRoll(headingPitchRoll: {
-        heading: number;
-        pitch: number;
-        roll: number;
-    }, result: Matrix3): Matrix3;
-    static fromScale(scale: Vector3, result: Matrix3): Matrix3;
-    static fromUniformScale(scale: number, result: Matrix3): Matrix3;
-    static fromCrossProduct(vector: Vector3, result: Matrix3): Matrix3;
-    static fromRotationX(angle: number, result: Matrix3): Matrix3;
-    static fromRotationY(angle: number, result: Matrix3): Matrix3;
-    static fromRotationZ(angle: number, result: Matrix3): Matrix3;
-    static toArray(matrix: Matrix3, result: Mat3DataType): Mat3DataType;
-    static getElement(matrix: Matrix3, column: number, row: number): number;
-    static getColumn(matrix: Matrix3, index: number, result: Vector3): Vector3;
-    static setColumn(matrix: Matrix3, index: number, cartesian: Vector3, result: Matrix3): Matrix3;
-    static getRow(matrix: Matrix3, index: number, result: Vector3): Vector3;
-    static setRow(matrix: Matrix3, index: number, cartesian: Vector3, result: Matrix3): Matrix3;
-    static scale(matrix: Matrix3, scale: Vector3, result: Matrix3): Matrix3;
-    static setUniformScale(matrix: Matrix3, scale: number, result: Matrix3): Matrix3;
-    static getScale(matrix: Matrix3, result: Vector3): Vector3;
-    static getMaximumScale(matrix: Matrix3): number;
-    static setRotation(matrix: Matrix3, rotation: Matrix3, result: Matrix3): Matrix3;
-    static getRotation(matrix: Matrix3, result: Matrix3): Matrix3;
-    static multiply(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
-    static add(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
-    static subtract(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
-    static multiplyByVector(matrix: Matrix3, cartesian: Vector3, result: Vector3): Vector3;
-    static multiplyByScalar(matrix: Matrix3, scalar: number, result: Matrix3): Matrix3;
-    static multiplyByScale(matrix: Matrix3, scale: Vector3, result: Matrix3): Matrix3;
-    static multiplyByUniformScale(matrix: Matrix3, scale: number, result: Matrix3): Matrix3;
-    static negate(matrix: Matrix3, result: Matrix3): Matrix3;
-    static transpose(matrix: Matrix3, result: Matrix3): Matrix3;
-    static abs(matrix: Matrix3, result: Matrix3): Matrix3;
-    static determinant(matrix: Matrix3): number;
-    static inverse(matrix: Matrix3, result: Matrix3): Matrix3;
-    static inverseTranspose(matrix: Matrix3, result: Matrix3): Matrix3;
-    static equals(left: Matrix3, right: Matrix3): boolean;
-    static equalsEpsilon(left: Matrix3, right: Matrix3, epsilon: number): boolean;
-    static getElementIndex(column: number, row: number): number;
-    getElement(column: number, row: number): number;
-    clone(): Matrix3;
-    copyTo(result: Matrix3): Matrix3;
-    copyFrom(source: Matrix3): this;
-    scale(vector: Vector3): Matrix3;
-    multiply(matrix: Matrix3): Matrix3;
-    /**
-       * 将矩阵数据按照列主序导出为number[]对象。
-       * @returns
-       */
-    toArray(): number[];
-    /**
-     * 将矩阵按照列主序方式导出为Float32Array对象。
-     * @returns
-     */
-    toFloat32Array(): Float32Array;
-    /**
-     * 矩阵与四维向量相乘。
-     * @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): Matrix3 | undefined;
-    /**
-     * 计算矩阵的逆矩阵，会修改矩阵数据
-     */
-    inverse(): Matrix3;
-    /**
-     * 计算矩阵的转置，结果保存在原矩阵中（会修改矩阵数据）
-     * @returns
-     */
-    transpose(): Matrix3;
-    static IDENTITY: Readonly<Matrix3>;
-    static ZERO: Readonly<Matrix3>;
-    static COLUMN0ROW0: number;
-    static COLUMN0ROW1: number;
-    static COLUMN0ROW2: number;
-    static COLUMN1ROW0: number;
-    static COLUMN1ROW1: number;
-    static COLUMN1ROW2: number;
-    static COLUMN2ROW0: number;
-    static COLUMN2ROW1: number;
-    static COLUMN2ROW2: number;
-}
-export { Matrix3 };

package/dist/math/matrix4.d.ts

@@ -1,264 +0,0 @@
-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

@@ -1,214 +0,0 @@
-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 };