rhodonite 0.4.2 → 0.5.2

package/dist/esm/foundation/math/MathClassUtil.d.ts

@@ -1,37 +1,37 @@
-import Vector2 from './Vector2';
-import Vector3 from './Vector3';
-import Vector4 from './Vector4';
-import Quaternion from './Quaternion';
-import Matrix33 from './Matrix33';
-import Matrix44 from './Matrix44';
-import { CompositionTypeEnum } from '../definitions/CompositionType';
-import MutableVector3 from './MutableVector3';
-export default class MathClassUtil {
-    private static __tmpVector4_0;
-    private static __tmpVector4_1;
-    constructor();
-    static arrayToVector(element: Array<number>): Vector2 | Vector3 | Vector4;
-    static arrayToVectorOrMatrix(element: Array<number>): Vector2 | Vector3 | Vector4 | Matrix33 | Matrix44;
-    static getImmutableValueClass(compositionType: CompositionTypeEnum): Function | undefined;
-    static getMutableValueClass(compositionType: CompositionTypeEnum): Function | undefined;
-    static cloneOfMathObjects(element: any): any;
-    static isAcceptableArrayForQuaternion(element: Array<number>): boolean;
-    static arrayToQuaternion(element: Array<number>): Quaternion;
-    static makeSubArray(array: Array<any>, componentN: number): any;
-    static vectorToArray(element: Vector2 | Vector3 | Vector4 | Quaternion): number[];
-    /**
-     * discriminate which Vector instance
-     * @param element any Vector instance
-     * @return number of Vector instance
-     */
-    static componentNumberOfVector(element: Vector2 | Vector3 | Vector4 | Quaternion | Array<any>): number;
-    static packNormalizedVec4ToVec2(x: number, y: number, z: number, w: number, criteria: number): number[];
-    static unProjectTo(windowPosX: number, windowPosY: number, windowPosZ: number, inversePVMat44: Matrix44, viewportVec4: Vector4, out: MutableVector3): import("./IVector").IMutableVector3;
-    static add(lhs: any, rhs: any): any;
-    static subtract(lhs: any, rhs: any): number | Vector2 | Vector3 | Vector4 | number[] | Quaternion | undefined;
-    static multiplyNumber(lhs: any, rhs: number): number | Vector2 | Vector3 | Vector4 | number[] | Quaternion | undefined;
-    static divideNumber(lhs: any, rhs: number): number | Vector2 | Vector3 | Vector4 | number[] | Quaternion | undefined;
-    static initWithScalar(objForDetectType: any, val: number): number | Vector2 | Vector3 | Vector4 | number[] | Quaternion | undefined;
-    static initWithFloat32Array(objForDetectType: any, val: any, floatArray: Float32Array, compositionType: CompositionTypeEnum): any;
-    static _setForce(objForDetectType: any, val: any): void;
-}
+import Vector2 from './Vector2';
+import Vector3 from './Vector3';
+import Vector4 from './Vector4';
+import Quaternion from './Quaternion';
+import Matrix33 from './Matrix33';
+import Matrix44 from './Matrix44';
+import { CompositionTypeEnum } from '../definitions/CompositionType';
+import MutableVector3 from './MutableVector3';
+export default class MathClassUtil {
+    private static __tmpVector4_0;
+    private static __tmpVector4_1;
+    constructor();
+    static arrayToVector(element: Array<number>): Vector2 | Vector3 | Vector4;
+    static arrayToVectorOrMatrix(element: Array<number>): Vector2 | Vector3 | Vector4 | Matrix33 | Matrix44;
+    static getImmutableValueClass(compositionType: CompositionTypeEnum): Function | undefined;
+    static getMutableValueClass(compositionType: CompositionTypeEnum): Function | undefined;
+    static cloneOfMathObjects(element: any): any;
+    static isAcceptableArrayForQuaternion(element: Array<number>): boolean;
+    static arrayToQuaternion(element: Array<number>): Quaternion;
+    static makeSubArray(array: Array<any>, componentN: number): any;
+    static vectorToArray(element: Vector2 | Vector3 | Vector4 | Quaternion): number[];
+    /**
+     * discriminate which Vector instance
+     * @param element any Vector instance
+     * @return number of Vector instance
+     */
+    static componentNumberOfVector(element: Vector2 | Vector3 | Vector4 | Quaternion | Array<any>): number;
+    static packNormalizedVec4ToVec2(x: number, y: number, z: number, w: number, criteria: number): number[];
+    static unProjectTo(windowPosX: number, windowPosY: number, windowPosZ: number, inversePVMat44: Matrix44, viewportVec4: Vector4, out: MutableVector3): import("./IVector").IMutableVector3;
+    static add(lhs: any, rhs: any): any;
+    static subtract(lhs: any, rhs: any): number | Vector2 | Vector3 | Vector4 | number[] | Quaternion | undefined;
+    static multiplyNumber(lhs: any, rhs: number): number | Vector2 | Vector3 | Vector4 | number[] | Quaternion | undefined;
+    static divideNumber(lhs: any, rhs: number): number | Vector2 | Vector3 | Vector4 | number[] | Quaternion | undefined;
+    static initWithScalar(objForDetectType: any, val: number): number | Vector2 | Vector3 | Vector4 | number[] | Quaternion | undefined;
+    static initWithFloat32Array(objForDetectType: any, val: any, floatArray: Float32Array, compositionType: CompositionTypeEnum): any;
+    static _setForce(objForDetectType: any, val: any): void;
+}

package/dist/esm/foundation/math/MathUtil.d.ts

@@ -1,55 +1,55 @@
-import MutableMatrix33 from './MutableMatrix33';
-import MutableVector3 from './MutableVector3';
-import { Count, Size } from '../../types/CommonTypes';
-declare function radianToDegree(rad: number): number;
-declare function degreeToRadian(deg: number): number;
-/**
- * check whether or not this texture size is power of two.
- *
- * @param x texture size.
- * @returns check whether or not the size x is power of two.
- */
-declare function isPowerOfTwo(x: number): boolean;
-declare function isPowerOfTwoTexture(width: Size, height: Size): boolean;
-declare function packNormalizedVec4ToVec2(x: number, y: number, z: number, w: number, criteria: number): number[];
-declare function gaussianCdf(x: number, mu: number, sigma: number): number;
-declare function invGaussianCdf(U: number, mu: number, sigma: number): number;
-declare function computeEigenValuesAndVectors(A: MutableMatrix33, Q: MutableMatrix33, w: MutableVector3): 0 | -1;
-declare function convertToStringAsGLSLFloat(value: number): string;
-declare function nearZeroToZero(value: number): number;
-declare function financial(val: number | string): string;
-declare function roundAsFloat(value: number): number;
-/**
- * This function calculates the ratio of a discrete Gaussian distribution.
- * The sampling points are one away from each other. The sum of the ratios is 1.
- * @kernelSize number of sampling points
- * @variance variance of the Gaussian distribution
- * @mean mean of the Gaussian distribution
- * e.g. kernelSize = 2 (mean=0) => the sampling points are -0.5 and 0.5
- * e.g. kernelSize = 3 (mean=1) => the sampling points are 0.0, 1.0 and 2.0
- * @effectiveDigit effectiveDigit of values in return array
- * @returns array of the Gaussian distribution where the sum of the elements is 1
- */
-declare function computeGaussianDistributionRatioWhoseSumIsOne({ kernelSize, variance, mean, effectiveDigit, }: {
-    kernelSize: Count;
-    variance: number;
-    mean?: number;
-    effectiveDigit?: Count;
-}): any[];
-export declare const MathUtil: Readonly<{
-    radianToDegree: typeof radianToDegree;
-    degreeToRadian: typeof degreeToRadian;
-    toHalfFloat: () => (val: number) => number;
-    isPowerOfTwo: typeof isPowerOfTwo;
-    isPowerOfTwoTexture: typeof isPowerOfTwoTexture;
-    packNormalizedVec4ToVec2: typeof packNormalizedVec4ToVec2;
-    convertToStringAsGLSLFloat: typeof convertToStringAsGLSLFloat;
-    nearZeroToZero: typeof nearZeroToZero;
-    gaussianCdf: typeof gaussianCdf;
-    invGaussianCdf: typeof invGaussianCdf;
-    computeEigenValuesAndVectors: typeof computeEigenValuesAndVectors;
-    computeGaussianDistributionRatioWhoseSumIsOne: typeof computeGaussianDistributionRatioWhoseSumIsOne;
-    roundAsFloat: typeof roundAsFloat;
-    financial: typeof financial;
-}>;
-export {};
+import MutableMatrix33 from './MutableMatrix33';
+import MutableVector3 from './MutableVector3';
+import { Count, Size } from '../../types/CommonTypes';
+declare function radianToDegree(rad: number): number;
+declare function degreeToRadian(deg: number): number;
+/**
+ * check whether or not this texture size is power of two.
+ *
+ * @param x texture size.
+ * @returns check whether or not the size x is power of two.
+ */
+declare function isPowerOfTwo(x: number): boolean;
+declare function isPowerOfTwoTexture(width: Size, height: Size): boolean;
+declare function packNormalizedVec4ToVec2(x: number, y: number, z: number, w: number, criteria: number): number[];
+declare function gaussianCdf(x: number, mu: number, sigma: number): number;
+declare function invGaussianCdf(U: number, mu: number, sigma: number): number;
+declare function computeEigenValuesAndVectors(A: MutableMatrix33, Q: MutableMatrix33, w: MutableVector3): 0 | -1;
+declare function convertToStringAsGLSLFloat(value: number): string;
+declare function nearZeroToZero(value: number): number;
+declare function financial(val: number | string): string;
+declare function roundAsFloat(value: number): number;
+/**
+ * This function calculates the ratio of a discrete Gaussian distribution.
+ * The sampling points are one away from each other. The sum of the ratios is 1.
+ * @kernelSize number of sampling points
+ * @variance variance of the Gaussian distribution
+ * @mean mean of the Gaussian distribution
+ * e.g. kernelSize = 2 (mean=0) => the sampling points are -0.5 and 0.5
+ * e.g. kernelSize = 3 (mean=1) => the sampling points are 0.0, 1.0 and 2.0
+ * @effectiveDigit effectiveDigit of values in return array
+ * @returns array of the Gaussian distribution where the sum of the elements is 1
+ */
+declare function computeGaussianDistributionRatioWhoseSumIsOne({ kernelSize, variance, mean, effectiveDigit, }: {
+    kernelSize: Count;
+    variance: number;
+    mean?: number;
+    effectiveDigit?: Count;
+}): any[];
+export declare const MathUtil: Readonly<{
+    radianToDegree: typeof radianToDegree;
+    degreeToRadian: typeof degreeToRadian;
+    toHalfFloat: () => (val: number) => number;
+    isPowerOfTwo: typeof isPowerOfTwo;
+    isPowerOfTwoTexture: typeof isPowerOfTwoTexture;
+    packNormalizedVec4ToVec2: typeof packNormalizedVec4ToVec2;
+    convertToStringAsGLSLFloat: typeof convertToStringAsGLSLFloat;
+    nearZeroToZero: typeof nearZeroToZero;
+    gaussianCdf: typeof gaussianCdf;
+    invGaussianCdf: typeof invGaussianCdf;
+    computeEigenValuesAndVectors: typeof computeEigenValuesAndVectors;
+    computeGaussianDistributionRatioWhoseSumIsOne: typeof computeGaussianDistributionRatioWhoseSumIsOne;
+    roundAsFloat: typeof roundAsFloat;
+    financial: typeof financial;
+}>;
+export {};

package/dist/esm/foundation/math/Matrix22.d.ts

@@ -1,69 +1,69 @@
-import Matrix33 from './Matrix33';
-import Matrix44 from './Matrix44';
-import { IMatrix22 } from './IMatrix';
-import Vector2 from './Vector2';
-import MutableMatrix22 from './MutableMatrix22';
-import MutableVector2 from './MutableVector2';
-import AbstractMatrix from './AbstractMatrix';
-export default class Matrix22 extends AbstractMatrix implements IMatrix22 {
-    constructor(m: null);
-    constructor(m: Float32Array, isColumnMajor?: boolean, notCopyFloatArray?: boolean);
-    constructor(m: Array<number>, isColumnMajor?: boolean);
-    constructor(m: Matrix22, isColumnMajor?: boolean);
-    constructor(m: Matrix33, isColumnMajor?: boolean);
-    constructor(m: Matrix44, isColumnMajor?: boolean);
-    constructor(m0: number, m1: number, m2: number, m3: number, isColumnMajor?: boolean);
-    get m00(): number;
-    get m10(): number;
-    get m01(): number;
-    get m11(): number;
-    get className(): string;
-    static get compositionType(): import("../definitions/CompositionType").CompositionTypeEnum;
-    /**
-     * Create zero matrix
-     */
-    static zero(): Matrix22;
-    /**
-     * Create identity matrix
-     */
-    static identity(): Matrix22;
-    static dummy(): Matrix22;
-    /**
-     * Create transpose matrix
-     */
-    static transpose(mat: Matrix22): Matrix22;
-    /**
-     * Create invert matrix
-     */
-    static invert(mat: Matrix22): Matrix22;
-    static invertTo(mat: Matrix22, outMat: MutableMatrix22): MutableMatrix22;
-    /**
-     * Create Rotation Matrix
-     */
-    static rotate(radian: number): Matrix22;
-    /**
-     * Create Scale Matrix
-     */
-    static scale(vec: Vector2): Matrix22;
-    /**
-     * multiply matrixes
-     */
-    static multiply(l_mat: Matrix22, r_mat: Matrix22): Matrix22;
-    /**
-     * multiply matrixes
-     */
-    static multiplyTo(l_mat: Matrix33, r_mat: Matrix33, outMat: MutableMatrix22): MutableMatrix22;
-    toString(): string;
-    toStringApproximately(): string;
-    flattenAsArray(): number[];
-    isDummy(): boolean;
-    isEqual(mat: Matrix22, delta?: number): boolean;
-    isStrictEqual(mat: Matrix22): boolean;
-    at(row_i: number, column_i: number): number;
-    determinant(): number;
-    multiplyVector(vec: Vector2): any;
-    multiplyVectorTo(vec: Vector2, outVec: MutableVector2): MutableVector2;
-    getScale(): Vector2;
-    getScaleTo(outVec: MutableVector2): MutableVector2;
-    clone(): Matrix22;
-}
+import Matrix33 from './Matrix33';
+import Matrix44 from './Matrix44';
+import { IMatrix22 } from './IMatrix';
+import Vector2 from './Vector2';
+import MutableMatrix22 from './MutableMatrix22';
+import MutableVector2 from './MutableVector2';
+import AbstractMatrix from './AbstractMatrix';
+export default class Matrix22 extends AbstractMatrix implements IMatrix22 {
+    constructor(m: null);
+    constructor(m: Float32Array, isColumnMajor?: boolean, notCopyFloatArray?: boolean);
+    constructor(m: Array<number>, isColumnMajor?: boolean);
+    constructor(m: Matrix22, isColumnMajor?: boolean);
+    constructor(m: Matrix33, isColumnMajor?: boolean);
+    constructor(m: Matrix44, isColumnMajor?: boolean);
+    constructor(m0: number, m1: number, m2: number, m3: number, isColumnMajor?: boolean);
+    get m00(): number;
+    get m10(): number;
+    get m01(): number;
+    get m11(): number;
+    get className(): string;
+    static get compositionType(): import("../definitions/CompositionType").CompositionTypeEnum;
+    /**
+     * Create zero matrix
+     */
+    static zero(): Matrix22;
+    /**
+     * Create identity matrix
+     */
+    static identity(): Matrix22;
+    static dummy(): Matrix22;
+    /**
+     * Create transpose matrix
+     */
+    static transpose(mat: Matrix22): Matrix22;
+    /**
+     * Create invert matrix
+     */
+    static invert(mat: Matrix22): Matrix22;
+    static invertTo(mat: Matrix22, outMat: MutableMatrix22): MutableMatrix22;
+    /**
+     * Create Rotation Matrix
+     */
+    static rotate(radian: number): Matrix22;
+    /**
+     * Create Scale Matrix
+     */
+    static scale(vec: Vector2): Matrix22;
+    /**
+     * multiply matrixes
+     */
+    static multiply(l_mat: Matrix22, r_mat: Matrix22): Matrix22;
+    /**
+     * multiply matrixes
+     */
+    static multiplyTo(l_mat: Matrix33, r_mat: Matrix33, outMat: MutableMatrix22): MutableMatrix22;
+    toString(): string;
+    toStringApproximately(): string;
+    flattenAsArray(): number[];
+    isDummy(): boolean;
+    isEqual(mat: Matrix22, delta?: number): boolean;
+    isStrictEqual(mat: Matrix22): boolean;
+    at(row_i: number, column_i: number): number;
+    determinant(): number;
+    multiplyVector(vec: Vector2): Vector2;
+    multiplyVectorTo(vec: Vector2, outVec: MutableVector2): MutableVector2;
+    getScale(): Vector2;
+    getScaleTo(outVec: MutableVector2): MutableVector2;
+    clone(): Matrix22;
+}

package/dist/esm/foundation/math/Matrix33.d.ts

@@ -1,86 +1,86 @@
-import Vector3 from './Vector3';
-import Matrix44 from './Matrix44';
-import Quaternion from './Quaternion';
-import { IMatrix, IMatrix33 } from './IMatrix';
-import MutableMatrix33 from './MutableMatrix33';
-import MutableVector3 from './MutableVector3';
-import AbstractMatrix from './AbstractMatrix';
-import { IMutableVector3, IVector3 } from './IVector';
-export default class Matrix33 extends AbstractMatrix implements IMatrix, IMatrix33 {
-    constructor(m: null);
-    constructor(m: Float32Array, isColumnMajor?: boolean, notCopyFloatArray?: boolean);
-    constructor(m: Array<number>, isColumnMajor?: boolean);
-    constructor(m: Matrix33, isColumnMajor?: boolean);
-    constructor(m: Matrix44, isColumnMajor?: boolean);
-    constructor(m: Quaternion, isColumnMajor?: boolean);
-    constructor(m0: number, m1: number, m2: number, m3: number, m4: number, m5: number, m6: number, m7: number, m8: number, isColumnMajor?: boolean);
-    get m00(): number;
-    get m10(): number;
-    get m20(): number;
-    get m01(): number;
-    get m11(): number;
-    get m21(): number;
-    get m02(): number;
-    get m12(): number;
-    get m22(): number;
-    get className(): string;
-    static get compositionType(): import("../definitions/CompositionType").CompositionTypeEnum;
-    /**
-     * zero matrix(static version)
-     */
-    static zero(): Matrix33;
-    /**
-     * Create identity matrix
-     */
-    static identity(): IMatrix33;
-    static dummy(): Matrix33;
-    /**
-     * Create transpose matrix
-     */
-    static transpose(mat: Matrix33): Matrix33;
-    /**
-     * Create invert matrix
-     */
-    static invert(mat: Matrix33): Matrix33;
-    static invertTo(mat: Matrix33, outMat: MutableMatrix33): MutableMatrix33;
-    /**
-   * Create X oriented Rotation Matrix
-   */
-    static rotateX(radian: number): Matrix33;
-    /**
-     * Create Y oriented Rotation Matrix
-     */
-    static rotateY(radian: number): Matrix33;
-    /**
-     * Create Z oriented Rotation Matrix
-     */
-    static rotateZ(radian: number): Matrix33;
-    static rotateXYZ(x: number, y: number, z: number): Matrix33;
-    static rotate(vec: Vector3): Matrix33;
-    /**
-     * Create Scale Matrix
-     */
-    static scale(vec: Vector3): Matrix33;
-    /**
-     * multiply matrixes
-     */
-    static multiply(l_mat: Matrix33, r_mat: Matrix33): Matrix33;
-    /**
-     * multiply matrixes
-     */
-    static multiplyTo(l_mat: Matrix33, r_mat: Matrix33, outMat: MutableMatrix33): MutableMatrix33;
-    toString(): string;
-    toStringApproximately(): string;
-    flattenAsArray(): number[];
-    isDummy(): boolean;
-    isEqual(mat: Matrix33, delta?: number): boolean;
-    isStrictEqual(mat: Matrix33): boolean;
-    at(row_i: number, column_i: number): number;
-    v(i: number): number;
-    determinant(): number;
-    multiplyVector(vec: IVector3): any;
-    multiplyVectorTo(vec: IVector3, outVec: IMutableVector3): IMutableVector3;
-    getScale(): Vector3;
-    getScaleTo(outVec: MutableVector3): MutableVector3;
-    clone(): Matrix33;
-}
+import Vector3 from './Vector3';
+import Matrix44 from './Matrix44';
+import Quaternion from './Quaternion';
+import { IMatrix, IMatrix33 } from './IMatrix';
+import MutableMatrix33 from './MutableMatrix33';
+import MutableVector3 from './MutableVector3';
+import AbstractMatrix from './AbstractMatrix';
+import { IMutableVector3, IVector3 } from './IVector';
+export default class Matrix33 extends AbstractMatrix implements IMatrix, IMatrix33 {
+    constructor(m: null);
+    constructor(m: Float32Array, isColumnMajor?: boolean, notCopyFloatArray?: boolean);
+    constructor(m: Array<number>, isColumnMajor?: boolean);
+    constructor(m: Matrix33, isColumnMajor?: boolean);
+    constructor(m: Matrix44, isColumnMajor?: boolean);
+    constructor(m: Quaternion, isColumnMajor?: boolean);
+    constructor(m0: number, m1: number, m2: number, m3: number, m4: number, m5: number, m6: number, m7: number, m8: number, isColumnMajor?: boolean);
+    get m00(): number;
+    get m10(): number;
+    get m20(): number;
+    get m01(): number;
+    get m11(): number;
+    get m21(): number;
+    get m02(): number;
+    get m12(): number;
+    get m22(): number;
+    get className(): string;
+    static get compositionType(): import("../definitions/CompositionType").CompositionTypeEnum;
+    /**
+     * zero matrix(static version)
+     */
+    static zero(): Matrix33;
+    /**
+     * Create identity matrix
+     */
+    static identity(): IMatrix33;
+    static dummy(): Matrix33;
+    /**
+     * Create transpose matrix
+     */
+    static transpose(mat: Matrix33): Matrix33;
+    /**
+     * Create invert matrix
+     */
+    static invert(mat: Matrix33): Matrix33;
+    static invertTo(mat: Matrix33, outMat: MutableMatrix33): MutableMatrix33;
+    /**
+   * Create X oriented Rotation Matrix
+   */
+    static rotateX(radian: number): Matrix33;
+    /**
+     * Create Y oriented Rotation Matrix
+     */
+    static rotateY(radian: number): Matrix33;
+    /**
+     * Create Z oriented Rotation Matrix
+     */
+    static rotateZ(radian: number): Matrix33;
+    static rotateXYZ(x: number, y: number, z: number): Matrix33;
+    static rotate(vec: Vector3): Matrix33;
+    /**
+     * Create Scale Matrix
+     */
+    static scale(vec: Vector3): Matrix33;
+    /**
+     * multiply matrixes
+     */
+    static multiply(l_mat: Matrix33, r_mat: Matrix33): Matrix33;
+    /**
+     * multiply matrixes
+     */
+    static multiplyTo(l_mat: Matrix33, r_mat: Matrix33, outMat: MutableMatrix33): MutableMatrix33;
+    toString(): string;
+    toStringApproximately(): string;
+    flattenAsArray(): number[];
+    isDummy(): boolean;
+    isEqual(mat: Matrix33, delta?: number): boolean;
+    isStrictEqual(mat: Matrix33): boolean;
+    at(row_i: number, column_i: number): number;
+    v(i: number): number;
+    determinant(): number;
+    multiplyVector(vec: IVector3): any;
+    multiplyVectorTo(vec: IVector3, outVec: IMutableVector3): IMutableVector3;
+    getScale(): Vector3;
+    getScaleTo(outVec: MutableVector3): MutableVector3;
+    clone(): Matrix33;
+}