rhodonite 0.4.2 → 0.5.2

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

@@ -1,51 +1,53 @@
-import { IVector2, IVector3, IVector4 } from './IVector';
-import { TypedArray } from '../../types/CommonTypes';
-import { IQuaternion, ILogQuaternion, IMutableQuaternion } from './IQuaternion';
-import { IMutableVector3 } from './IVector';
-import { IMatrix44 } from './IMatrix';
-import AbstractQuaternion from './AbstractQuaternion';
-export default class Quaternion extends AbstractQuaternion implements IQuaternion {
-    private static __tmp_upVec;
-    constructor(x?: number | TypedArray | IVector2 | IVector3 | IVector4 | IQuaternion | ILogQuaternion | Array<number> | null, y?: number, z?: number, w?: number);
-    get className(): string;
-    static get compositionType(): import("../definitions/CompositionType").CompositionTypeEnum;
-    static identity(): Quaternion;
-    static dummy(): Quaternion;
-    static invert(quat: IQuaternion): IQuaternion;
-    static invertTo(quat: IQuaternion, out: IMutableQuaternion): IQuaternion;
-    /**
-     * Compute spherical linear interpolation
-     */
-    static qlerp(l_quat: IQuaternion, r_quat: IQuaternion, ratio: number): IQuaternion;
-    /**
-     *  Compute the spherical linear interpolation and output it as the fourth argument
-     */
-    static qlerpTo(l_quat: IQuaternion, r_quat: IQuaternion, ratio: number, out: IMutableQuaternion): IMutableQuaternion;
-    static lerp(l_quat: IQuaternion, r_quat: IQuaternion, ratio: number): Quaternion;
-    static lerpTo(l_quat: IQuaternion, r_quat: IQuaternion, ratio: number, out: IMutableQuaternion): IMutableQuaternion;
-    static axisAngle(vec: IVector3, radian: number): Quaternion;
-    static fromMatrix(mat: IMatrix44): Quaternion;
-    static fromMatrixTo(mat: IMatrix44, out: IMutableQuaternion): IMutableQuaternion;
-    static lookFromTo(fromDirection: IVector3, toDirection: IVector3): IQuaternion;
-    static lookForward(forward: IVector3): IQuaternion;
-    static lookForwardAccordingToThisUp(forward: IVector3, up: IVector3): IQuaternion;
-    static fromPosition(vec: IVector3): Quaternion;
-    static add(l_quat: IQuaternion, r_quat: IQuaternion): Quaternion;
-    static addTo(l_quat: IQuaternion, r_quat: IQuaternion, out: IMutableQuaternion): IMutableQuaternion;
-    static subtract(l_quat: IQuaternion, r_quat: IQuaternion): Quaternion;
-    static subtractTo(l_quat: IQuaternion, r_quat: IQuaternion, out: IMutableQuaternion): IMutableQuaternion;
-    static multiply(l_quat: IQuaternion, r_quat: IQuaternion): Quaternion;
-    static multiplyTo(l_quat: IQuaternion, r_quat: IQuaternion, out: IMutableQuaternion): IMutableQuaternion;
-    static multiplyNumber(quat: IQuaternion, value: number): Quaternion;
-    static multiplyNumberTo(quat: IQuaternion, value: number, out: IMutableQuaternion): IMutableQuaternion;
-    static divideNumber(quat: IQuaternion, value: number): Quaternion;
-    static divideNumberTo(quat: IQuaternion, value: number, out: IMutableQuaternion): IMutableQuaternion;
-    toString(): string;
-    toStringApproximately(): string;
-    flattenAsArray(): number[];
-    isDummy(): boolean;
-    isEqual(quat: IQuaternion, delta?: number): boolean;
-    isStrictEqual(quat: IQuaternion): boolean;
-    toEulerAnglesTo(out: IMutableVector3): IMutableVector3;
-    clone(): IQuaternion;
-}
+import { IVector2, IVector3, IVector4 } from './IVector';
+import { Array4, TypedArray } from '../../types/CommonTypes';
+import { IQuaternion, ILogQuaternion, IMutableQuaternion } from './IQuaternion';
+import { IMutableVector3 } from './IVector';
+import { IMatrix44 } from './IMatrix';
+import AbstractQuaternion from './AbstractQuaternion';
+export default class Quaternion extends AbstractQuaternion implements IQuaternion {
+    private static __tmp_upVec;
+    constructor(x?: number | TypedArray | IVector2 | IVector3 | IVector4 | IQuaternion | ILogQuaternion | Array<number> | null, y?: number, z?: number, w?: number);
+    get className(): string;
+    static get compositionType(): import("../definitions/CompositionType").CompositionTypeEnum;
+    static identity(): Quaternion;
+    static dummy(): Quaternion;
+    static invert(quat: IQuaternion): IQuaternion;
+    static invertTo(quat: IQuaternion, out: IMutableQuaternion): IQuaternion;
+    /**
+     * Compute spherical linear interpolation
+     */
+    static qlerp(l_quat: IQuaternion, r_quat: IQuaternion, ratio: number): IQuaternion;
+    /**
+     *  Compute the spherical linear interpolation and output it as the fourth argument
+     */
+    static qlerpTo(l_quat: IQuaternion, r_quat: IQuaternion, ratio: number, out: IMutableQuaternion): IMutableQuaternion;
+    static lerp(l_quat: IQuaternion, r_quat: IQuaternion, ratio: number): Quaternion;
+    static lerpTo(l_quat: IQuaternion, r_quat: IQuaternion, ratio: number, out: IMutableQuaternion): IMutableQuaternion;
+    static axisAngle(vec: IVector3, radian: number): Quaternion;
+    static fromMatrix(mat: IMatrix44): Quaternion;
+    static fromMatrixTo(mat: IMatrix44, out: IMutableQuaternion): IMutableQuaternion;
+    static lookFromTo(fromDirection: IVector3, toDirection: IVector3): IQuaternion;
+    static lookForward(forward: IVector3): IQuaternion;
+    static lookForwardAccordingToThisUp(forward: IVector3, up: IVector3): IQuaternion;
+    static fromPosition(vec: IVector3): Quaternion;
+    static add(l_quat: IQuaternion, r_quat: IQuaternion): Quaternion;
+    static addTo(l_quat: IQuaternion, r_quat: IQuaternion, out: IMutableQuaternion): IMutableQuaternion;
+    static subtract(l_quat: IQuaternion, r_quat: IQuaternion): Quaternion;
+    static subtractTo(l_quat: IQuaternion, r_quat: IQuaternion, out: IMutableQuaternion): IMutableQuaternion;
+    static multiply(l_quat: IQuaternion, r_quat: IQuaternion): Quaternion;
+    static multiplyTo(l_quat: IQuaternion, r_quat: IQuaternion, out: IMutableQuaternion): IMutableQuaternion;
+    static multiplyNumber(quat: IQuaternion, value: number): Quaternion;
+    static multiplyNumberTo(quat: IQuaternion, value: number, out: IMutableQuaternion): IMutableQuaternion;
+    static divideNumber(quat: IQuaternion, value: number): Quaternion;
+    static divideNumberTo(quat: IQuaternion, value: number, out: IMutableQuaternion): IMutableQuaternion;
+    toString(): string;
+    toStringApproximately(): string;
+    flattenAsArray(): number[];
+    isDummy(): boolean;
+    isEqual(quat: IQuaternion, delta?: number): boolean;
+    isStrictEqual(quat: IQuaternion): boolean;
+    toEulerAnglesTo(out: IMutableVector3): IMutableVector3;
+    clone(): IQuaternion;
+    static fromCopyArray4(array: Array4<number>): Quaternion;
+    static fromCopyXYZW(x: number, y: number, z: number, w: number): Quaternion;
+}

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

@@ -1,36 +1,40 @@
-import { IScalar } from './IVector';
-import { TypedArray, TypedArrayConstructor } from '../../types/CommonTypes';
-import AbstractVector from './AbstractVector';
-export declare class Scalar_<T extends TypedArrayConstructor> extends AbstractVector {
-    constructor(x: number | TypedArray | null, { type }: {
-        type: T;
-    });
-    getValue(): number;
-    getValueInArray(): number[];
-    get x(): number;
-    get raw(): TypedArray;
-    isStrictEqual(scalar: Scalar_<T>): boolean;
-    isEqual(scalar: Scalar_<T>, delta?: number): boolean;
-    get glslStrAsFloat(): string;
-    get glslStrAsInt(): string;
-}
-export default class Scalar extends Scalar_<Float32ArrayConstructor> implements IScalar {
-    constructor(x: number | TypedArray | null);
-    static zero(): Scalar;
-    static one(): Scalar;
-    static dummy(): Scalar;
-    get className(): string;
-    /**
-     * change to string
-     */
-    toString(): string;
-    clone(): Scalar;
-}
-export declare class Scalard extends Scalar_<Float64ArrayConstructor> {
-    constructor(x: number | TypedArray | null);
-    static zero(): Scalard;
-    static one(): Scalard;
-    static dummy(): Scalard;
-    clone(): Scalard;
-}
-export declare type Scalarf = Scalar;
+import { IScalar } from './IVector';
+import { FloatTypedArrayConstructor, TypedArray, TypedArrayConstructor } from '../../types/CommonTypes';
+import AbstractVector from './AbstractVector';
+export declare class Scalar_<T extends TypedArrayConstructor> extends AbstractVector {
+    constructor(v: TypedArray, { type }: {
+        type: T;
+    });
+    getValue(): number;
+    getValueInArray(): number[];
+    get x(): number;
+    get raw(): TypedArray;
+    isStrictEqual(scalar: Scalar_<T>): boolean;
+    isEqual(scalar: Scalar_<T>, delta?: number): boolean;
+    get glslStrAsFloat(): string;
+    get glslStrAsInt(): string;
+    static _fromCopyNumber(value: number, type: FloatTypedArrayConstructor): Scalar_<FloatTypedArrayConstructor>;
+    static _dummy(type: FloatTypedArrayConstructor): Scalar_<FloatTypedArrayConstructor>;
+}
+export default class Scalar extends Scalar_<Float32ArrayConstructor> implements IScalar {
+    constructor(x: TypedArray);
+    static fromCopyNumber(value: number): Scalar;
+    static zero(): Scalar;
+    static one(): Scalar;
+    static dummy(): Scalar;
+    get className(): string;
+    /**
+     * change to string
+     */
+    toString(): string;
+    clone(): Scalar;
+}
+export declare class Scalard extends Scalar_<Float64ArrayConstructor> {
+    constructor(x: TypedArray);
+    static fromCopyNumber(value: number): Scalard;
+    static zero(): Scalard;
+    static one(): Scalard;
+    static dummy(): Scalard;
+    clone(): Scalard;
+}
+export declare type Scalarf = Scalar;

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

@@ -1,126 +1,140 @@
-import { IVector2, IVector3, IVector4, IVector, IMutableVector2 } from './IVector';
-import { TypedArray, TypedArrayConstructor } from '../../types/CommonTypes';
-import AbstractVector from './AbstractVector';
-export declare class Vector2_<T extends TypedArrayConstructor> extends AbstractVector {
-    constructor(x: number | TypedArray | IVector2 | IVector3 | IVector4 | Array<number> | null, y: number, { type }: {
-        type: T;
-    });
-    get x(): number;
-    get y(): number;
-    get glslStrAsFloat(): string;
-    get glslStrAsInt(): string;
-    static get compositionType(): import("../definitions/CompositionType").CompositionTypeEnum;
-    /**
-     * to square length(static version)
-     */
-    static lengthSquared(vec: IVector2): number;
-    static lengthBtw(l_vec: IVector2, r_vec: IVector2): number;
-    static angleOfVectors(l_vec: IVector2, r_vec: IVector2): number;
-    static _zero(type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    static _one(type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    static _dummy(type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    /**
-     * normalize(static version)
-     */
-    static _normalize(vec: IVector2, type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    /**
-     * add value（static version）
-     */
-    static _add(l_vec: IVector2, r_vec: IVector2, type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    /**
-     * add value（static version）
-     */
-    static addTo(l_vec: IVector2, r_vec: IVector2, out: IMutableVector2): IMutableVector2;
-    /**
-     * subtract value(static version)
-     */
-    static _subtract(l_vec: IVector2, r_vec: IVector2, type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    /**
-     * subtract value(static version)
-     */
-    static subtractTo(l_vec: IVector2, r_vec: IVector2, out: IMutableVector2): IMutableVector2;
-    /**
-     * multiply value(static version)
-     */
-    static _multiply(vec: IVector2, value: number, type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    /**
-     * multiply value(static version)
-     */
-    static multiplyTo(vec: IVector2, value: number, out: IMutableVector2): IMutableVector2;
-    /**
-     * multiply vector(static version)
-     */
-    static _multiplyVector(l_vec: IVector2, r_vec: IVector2, type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    /**
-     * multiply vector(static version)
-     */
-    static multiplyVectorTo(l_vec: IVector2, r_vec: IVector2, out: IMutableVector2): IMutableVector2;
-    /**
-     * divide by value(static version)
-     */
-    static _divide(vec: IVector2, value: number, type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    /**
-     * divide by value(static version)
-     */
-    static divideTo(vec: IVector2, value: number, out: IMutableVector2): IMutableVector2;
-    /**
-     * divide by vector(static version)
-     */
-    static _divideVector(l_vec: IVector2, r_vec: IVector2, type: TypedArrayConstructor): Vector2_<TypedArrayConstructor>;
-    /**
-     * divide by vector(static version)
-     */
-    static divideVectorTo(l_vec: IVector2, r_vec: IVector2, out: IMutableVector2): IMutableVector2;
-    /**
-     * dot product(static version)
-     */
-    static dot(l_vec: IVector2, r_vec: IVector2): number;
-    /**
-     * change to string
-     */
-    toString(): string;
-    toStringApproximately(): string;
-    flattenAsArray(): number[];
-    isDummy(): boolean;
-    isEqual(vec: IVector2, delta?: number): boolean;
-    isStrictEqual(vec: IVector2): boolean;
-    at(i: number): number;
-    length(): number;
-    lengthSquared(): number;
-    lengthTo(vec: IVector2): number;
-    /**
-     * dot product
-     */
-    dot(vec: IVector2): number;
-    clone(): any;
-}
-export default class Vector2 extends Vector2_<Float32ArrayConstructor> implements IVector, IVector2 {
-    constructor(x: number | TypedArray | IVector2 | IVector3 | IVector4 | Array<number> | null, y?: number);
-    static zero(): Vector2;
-    static one(): Vector2;
-    static dummy(): Vector2;
-    static normalize(vec: IVector2): Vector2;
-    static add(l_vec: IVector2, r_vec: IVector2): Vector2;
-    static subtract(l_vec: IVector2, r_vec: IVector2): Vector2;
-    static multiply(vec: IVector2, value: number): Vector2;
-    static multiplyVector(l_vec: IVector2, r_vec: IVector2): Vector2;
-    static divide(vec: IVector2, value: number): Vector2;
-    static divideVector(l_vec: IVector2, r_vec: IVector2): Vector2;
-    get className(): string;
-    clone(): Vector2;
-}
-export declare class Vector2d extends Vector2_<Float64ArrayConstructor> {
-    constructor(x: number | TypedArray | IVector2 | IVector3 | IVector4 | Array<number> | null, y?: number);
-    static zero(): Vector2d;
-    static one(): Vector2d;
-    static dummy(): Vector2d;
-    static normalize(vec: IVector2): Vector2d;
-    static add(l_vec: IVector2, r_vec: IVector2): Vector2d;
-    static subtract(l_vec: IVector2, r_vec: IVector2): Vector2d;
-    static multiply(vec: IVector2, value: number): Vector2d;
-    static multiplyVector(l_vec: IVector2, r_vec: IVector2): Vector2d;
-    static divide(vec: IVector2, value: number): Vector2d;
-    static divideVector(l_vec: IVector2, r_vec: IVector2): Vector2d;
-    clone(): Vector2d;
-}
-export declare type Vector2f = Vector2;
+import { IVector2, IVector3, IVector4, IVector, IMutableVector2 } from './IVector';
+import type { Array2, FloatTypedArrayConstructor, TypedArray } from '../../types/CommonTypes';
+import AbstractVector from './AbstractVector';
+export declare class Vector2_<T extends FloatTypedArrayConstructor> extends AbstractVector {
+    constructor(v: TypedArray, { type }: {
+        type: T;
+    });
+    get x(): number;
+    get y(): number;
+    get glslStrAsFloat(): string;
+    get glslStrAsInt(): string;
+    static get compositionType(): import("../definitions/CompositionType").CompositionTypeEnum;
+    /**
+     * to square length(static version)
+     */
+    static lengthSquared(vec: IVector2): number;
+    static lengthBtw(l_vec: IVector2, r_vec: IVector2): number;
+    static angleOfVectors(l_vec: IVector2, r_vec: IVector2): number;
+    static _zero(type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    static _one(type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    static _dummy(type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    /**
+     * normalize(static version)
+     */
+    static _normalize(vec: IVector2, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    /**
+     * add value（static version）
+     */
+    static _add(l_vec: IVector2, r_vec: IVector2, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    /**
+     * add value（static version）
+     */
+    static addTo(l_vec: IVector2, r_vec: IVector2, out: IMutableVector2): IMutableVector2;
+    /**
+     * subtract value(static version)
+     */
+    static _subtract(l_vec: IVector2, r_vec: IVector2, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    /**
+     * subtract value(static version)
+     */
+    static subtractTo(l_vec: IVector2, r_vec: IVector2, out: IMutableVector2): IMutableVector2;
+    /**
+     * multiply value(static version)
+     */
+    static _multiply(vec: IVector2, value: number, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    /**
+     * multiply value(static version)
+     */
+    static multiplyTo(vec: IVector2, value: number, out: IMutableVector2): IMutableVector2;
+    /**
+     * multiply vector(static version)
+     */
+    static _multiplyVector(l_vec: IVector2, r_vec: IVector2, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    /**
+     * multiply vector(static version)
+     */
+    static multiplyVectorTo(l_vec: IVector2, r_vec: IVector2, out: IMutableVector2): IMutableVector2;
+    /**
+     * divide by value(static version)
+     */
+    static _divide(vec: IVector2, value: number, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    /**
+     * divide by value(static version)
+     */
+    static divideTo(vec: IVector2, value: number, out: IMutableVector2): IMutableVector2;
+    /**
+     * divide by vector(static version)
+     */
+    static _divideVector(l_vec: IVector2, r_vec: IVector2, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    /**
+     * divide by vector(static version)
+     */
+    static divideVectorTo(l_vec: IVector2, r_vec: IVector2, out: IMutableVector2): IMutableVector2;
+    /**
+     * dot product(static version)
+     */
+    static dot(l_vec: IVector2, r_vec: IVector2): number;
+    /**
+     * change to string
+     */
+    toString(): string;
+    toStringApproximately(): string;
+    flattenAsArray(): number[];
+    isDummy(): boolean;
+    isEqual(vec: IVector2, delta?: number): boolean;
+    isStrictEqual(vec: IVector2): boolean;
+    at(i: number): number;
+    length(): number;
+    lengthSquared(): number;
+    lengthTo(vec: IVector2): number;
+    /**
+     * dot product
+     */
+    dot(vec: IVector2): number;
+    clone(): any;
+    static _fromCopyArray2(array: Array2<number>, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    static _fromCopyArray(array: Array<number>, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    static _fromVector2(vec2: IVector2, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    static _fromCopyVector2(vec2: IVector2, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    static _fromCopyVector3(vec3: IVector3, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+    static _fromCopyVector4(vec4: IVector4, type: FloatTypedArrayConstructor): Vector2_<FloatTypedArrayConstructor>;
+}
+export default class Vector2 extends Vector2_<Float32ArrayConstructor> implements IVector, IVector2 {
+    constructor(x: TypedArray);
+    static fromCopyArray2(array: Array2<number>): Vector2;
+    static fromCopyArray(array: Array<number>): Vector2;
+    static fromCopyVector2(vec2: IVector2): Vector2;
+    static fromCopyVector4(vec4: IVector4): Vector2;
+    static zero(): Vector2;
+    static one(): Vector2;
+    static dummy(): Vector2;
+    static normalize(vec: IVector2): Vector2;
+    static add(l_vec: IVector2, r_vec: IVector2): Vector2;
+    static subtract(l_vec: IVector2, r_vec: IVector2): Vector2;
+    static multiply(vec: IVector2, value: number): Vector2;
+    static multiplyVector(l_vec: IVector2, r_vec: IVector2): Vector2;
+    static divide(vec: IVector2, value: number): Vector2;
+    static divideVector(l_vec: IVector2, r_vec: IVector2): Vector2;
+    get className(): string;
+    clone(): Vector2;
+}
+export declare class Vector2d extends Vector2_<Float64ArrayConstructor> {
+    constructor(x: TypedArray);
+    static fromCopyArray2(array: Array2<number>): Vector2d;
+    static fromCopyArray(array: Array<number>): Vector2d;
+    static fromArrayBuffer(arrayBuffer: ArrayBuffer): Vector2d;
+    static fromFloat64Array(float64Array: Float64Array): Vector2d;
+    static zero(): Vector2d;
+    static one(): Vector2d;
+    static dummy(): Vector2d;
+    static normalize(vec: IVector2): Vector2d;
+    static add(l_vec: IVector2, r_vec: IVector2): Vector2d;
+    static subtract(l_vec: IVector2, r_vec: IVector2): Vector2d;
+    static multiply(vec: IVector2, value: number): Vector2d;
+    static multiplyVector(l_vec: IVector2, r_vec: IVector2): Vector2d;
+    static divide(vec: IVector2, value: number): Vector2d;
+    static divideVector(l_vec: IVector2, r_vec: IVector2): Vector2d;
+    clone(): Vector2d;
+}
+export declare type Vector2f = Vector2;