rhodonite 0.4.2 → 0.5.2

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

@@ -1,34 +1,34 @@
-import { Scalar_ } from './Scalar';
-import { TypedArray, TypedArrayConstructor } from '../../types/CommonTypes';
-export declare class MutableScalar_<T extends TypedArrayConstructor> extends Scalar_<T> {
-    constructor(x: number | TypedArray | null, { type }: {
-        type: T;
-    });
-    copyComponents(vec: Scalar_<T>): void;
-    get x(): number;
-    set x(x: number);
-    get y(): number;
-    get z(): number;
-    get w(): number;
-    /**
-     * change to string
-     */
-    toString(): string;
-    setValue(value: number): this;
-}
-export default class MutableScalar extends MutableScalar_<Float32ArrayConstructor> {
-    constructor(x: number | TypedArray | null);
-    clone(): MutableScalar;
-    static one(): MutableScalar;
-    static dummy(): MutableScalar;
-    static zero(): MutableScalar;
-    get className(): string;
-}
-export declare class MutableScalard extends MutableScalar_<Float64ArrayConstructor> {
-    constructor(x: number | TypedArray | null);
-    clone(): MutableScalard;
-    static one(): MutableScalard;
-    static dummy(): MutableScalard;
-    static zero(): MutableScalard;
-}
-export declare type MutableScalarf = MutableScalar;
+import { Scalar_ } from './Scalar';
+import { TypedArray, TypedArrayConstructor } from '../../types/CommonTypes';
+export declare class MutableScalar_<T extends TypedArrayConstructor> extends Scalar_<T> {
+    constructor(x: TypedArray, { type }: {
+        type: T;
+    });
+    copyComponents(vec: Scalar_<T>): void;
+    get x(): number;
+    set x(x: number);
+    get y(): number;
+    get z(): number;
+    get w(): number;
+    /**
+     * change to string
+     */
+    toString(): string;
+    setValue(value: number): this;
+}
+export default class MutableScalar extends MutableScalar_<Float32ArrayConstructor> {
+    constructor(x: TypedArray);
+    clone(): MutableScalar;
+    static one(): MutableScalar;
+    static dummy(): MutableScalar;
+    static zero(): MutableScalar;
+    get className(): string;
+}
+export declare class MutableScalard extends MutableScalar_<Float64ArrayConstructor> {
+    constructor(x: TypedArray);
+    clone(): MutableScalard;
+    static one(): MutableScalard;
+    static dummy(): MutableScalard;
+    static zero(): MutableScalard;
+}
+export declare type MutableScalarf = MutableScalar;

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

@@ -1,75 +1,80 @@
-import { Vector2_ } from './Vector2';
-import { IVector2, IVector3, IVector4, IMutableVector, IMutableVector2 } from './IVector';
-import { TypedArray, TypedArrayConstructor } from '../../types/CommonTypes';
-export declare class MutableVector2_<T extends TypedArrayConstructor> extends Vector2_<T> {
-    constructor(x: number | TypedArray | IVector2 | IVector3 | IVector4 | Array<number> | null, y: number, { type }: {
-        type: T;
-    });
-    set x(x: number);
-    get x(): number;
-    set y(y: number);
-    get y(): number;
-    get z(): number;
-    get w(): number;
-    raw(): TypedArray;
-    setAt(i: number, value: number): this;
-    setComponents(x: number, y: number): this;
-    copyComponents(vec: IVector2): this;
-    zero(): this;
-    one(): this;
-    normalize(): this;
-    /**
-     * add value
-     */
-    add(vec: IVector2): this;
-    /**
-     * subtract
-     */
-    subtract(vec: IVector2): this;
-    /**
-     * multiply
-     */
-    multiply(value: number): this;
-    /**
-     * multiply vector
-     */
-    multiplyVector(vec: IVector2): this;
-    /**
-     * divide
-     */
-    divide(value: number): this;
-    /**
-     * divide vector
-     */
-    divideVector(vec: IVector2): this;
-}
-export default class MutableVector2 extends MutableVector2_<Float32ArrayConstructor> implements IMutableVector, IMutableVector2 {
-    constructor(x: number | TypedArray | IVector2 | IVector3 | IVector4 | Array<number> | null, y?: number);
-    static zero(): MutableVector2;
-    static one(): MutableVector2;
-    static dummy(): MutableVector2;
-    static normalize(vec: IVector2): MutableVector2;
-    static add(l_vec: IVector2, r_vec: IVector2): MutableVector2;
-    static subtract(l_vec: IVector2, r_vec: IVector2): MutableVector2;
-    static multiply(vec: IVector2, value: number): MutableVector2;
-    static multiplyVector(l_vec: IVector2, r_vec: IVector2): MutableVector2;
-    static divide(vec: IVector2, value: number): MutableVector2;
-    static divideVector(l_vec: IVector2, r_vec: IVector2): MutableVector2;
-    get className(): string;
-    clone(): MutableVector2;
-}
-export declare class MutableVector2d extends MutableVector2_<Float64ArrayConstructor> {
-    constructor(x: number | TypedArray | IVector2 | IVector3 | IVector4 | Array<number> | null, y?: number);
-    static zero(): MutableVector2d;
-    static one(): MutableVector2d;
-    static dummy(): MutableVector2d;
-    static normalize(vec: IVector2): MutableVector2d;
-    static add(l_vec: IVector2, r_vec: IVector2): MutableVector2d;
-    static subtract(l_vec: IVector2, r_vec: IVector2): MutableVector2d;
-    static multiply(vec: IVector2, value: number): MutableVector2d;
-    static multiplyVector(l_vec: IVector2, r_vec: IVector2): MutableVector2d;
-    static divide(vec: IVector2, value: number): MutableVector2d;
-    static divideVector(l_vec: IVector2, r_vec: IVector2): MutableVector2d;
-    clone(): MutableVector2d;
-}
-export declare type MutableVector2f = MutableVector2;
+import { Vector2_ } from './Vector2';
+import { IVector2, IMutableVector, IMutableVector2 } from './IVector';
+import { TypedArray, FloatTypedArrayConstructor, Array2 } from '../../types/CommonTypes';
+export declare class MutableVector2_<T extends FloatTypedArrayConstructor> extends Vector2_<T> {
+    constructor(x: TypedArray, { type }: {
+        type: T;
+    });
+    set x(x: number);
+    get x(): number;
+    set y(y: number);
+    get y(): number;
+    get z(): number;
+    get w(): number;
+    raw(): TypedArray;
+    setAt(i: number, value: number): this;
+    setComponents(x: number, y: number): this;
+    copyComponents(vec: IVector2): this;
+    zero(): this;
+    one(): this;
+    normalize(): this;
+    /**
+     * add value
+     */
+    add(vec: IVector2): this;
+    /**
+     * subtract
+     */
+    subtract(vec: IVector2): this;
+    /**
+     * multiply
+     */
+    multiply(value: number): this;
+    /**
+     * multiply vector
+     */
+    multiplyVector(vec: IVector2): this;
+    /**
+     * divide
+     */
+    divide(value: number): this;
+    /**
+     * divide vector
+     */
+    divideVector(vec: IVector2): this;
+}
+export default class MutableVector2 extends MutableVector2_<Float32ArrayConstructor> implements IMutableVector, IMutableVector2 {
+    constructor(x: TypedArray);
+    static fromCopyArray2(array: Array2<number>): MutableVector2;
+    static fromCopyArray(array: Array<number>): MutableVector2;
+    static fromFloat32Array(float32Array: Float32Array): MutableVector2;
+    static fromCopyFloat32Array(float32Array: Float32Array): MutableVector2;
+    static zero(): MutableVector2;
+    static one(): MutableVector2;
+    static dummy(): MutableVector2;
+    static normalize(vec: IVector2): MutableVector2;
+    static add(l_vec: IVector2, r_vec: IVector2): MutableVector2;
+    static subtract(l_vec: IVector2, r_vec: IVector2): MutableVector2;
+    static multiply(vec: IVector2, value: number): MutableVector2;
+    static multiplyVector(l_vec: IVector2, r_vec: IVector2): MutableVector2;
+    static divide(vec: IVector2, value: number): MutableVector2;
+    static divideVector(l_vec: IVector2, r_vec: IVector2): MutableVector2;
+    get className(): string;
+    clone(): MutableVector2;
+}
+export declare class MutableVector2d extends MutableVector2_<Float64ArrayConstructor> {
+    constructor(x: TypedArray);
+    static fromCopyArray(array: Array2<number>): MutableVector2d;
+    static zero(): MutableVector2d;
+    static one(): MutableVector2d;
+    static dummy(): MutableVector2d;
+    static normalize(vec: IVector2): MutableVector2d;
+    static add(l_vec: IVector2, r_vec: IVector2): MutableVector2d;
+    static subtract(l_vec: IVector2, r_vec: IVector2): MutableVector2d;
+    static multiply(vec: IVector2, value: number): MutableVector2d;
+    static multiplyVector(l_vec: IVector2, r_vec: IVector2): MutableVector2d;
+    static divide(vec: IVector2, value: number): MutableVector2d;
+    static divideVector(l_vec: IVector2, r_vec: IVector2): MutableVector2d;
+    clone(): MutableVector2d;
+}
+export declare type MutableVector2f = MutableVector2;

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

@@ -1,94 +1,98 @@
-import { IVector2, IVector3, IVector4, IMutableVector, IMutableVector3 } from './IVector';
-import { TypedArray, FloatTypedArrayConstructor } from '../../types/CommonTypes';
-import { Vector3_ } from './Vector3';
-import { IQuaternion } from './IQuaternion';
-export declare class MutableVector3_<T extends FloatTypedArrayConstructor> extends Vector3_<T> implements IMutableVector, IMutableVector3 {
-    constructor(x: number | TypedArray | IVector2 | IVector3 | IVector4 | Array<number> | null, y: number, z: number, { type }: {
-        type: T;
-    });
-    set x(x: number);
-    get x(): number;
-    set y(y: number);
-    get y(): number;
-    set z(z: number);
-    get z(): number;
-    get w(): number;
-    raw(): TypedArray;
-    setAt(i: number, value: number): this;
-    setComponents(x: number, y: number, z: number): this;
-    copyComponents(vec: IVector3): this;
-    zero(): this;
-    one(): this;
-    /**
-     * normalize
-     */
-    normalize(): this;
-    /**
-     * add value
-     */
-    add(vec: IVector3): this;
-    /**
-     * subtract
-     */
-    subtract(vec: IVector3): this;
-    /**
-     * multiply
-     */
-    multiply(value: number): this;
-    /**
-     * multiply vector
-     */
-    multiplyVector(vec: IVector3): this;
-    /**
-     * divide
-     */
-    divide(value: number): this;
-    /**
-     * divide vector
-     */
-    divideVector(vec: IVector3): this;
-    /**
-     * cross product
-     */
-    cross(vec: IVector3): this;
-    /**
-     * quaternion * vector3
-     */
-    multiplyQuaternion(quat: IQuaternion): this;
-}
-export default class MutableVector3 extends MutableVector3_<Float32ArrayConstructor> {
-    constructor(x: number | TypedArray | IVector2 | IVector3 | IVector4 | Array<number> | null, y?: number, z?: number);
-    static identity(): MutableVector3;
-    static zero(): MutableVector3;
-    static one(): MutableVector3;
-    static dummy(): MutableVector3;
-    static normalize(vec: IVector3): MutableVector3;
-    static add(l_vec: IVector3, r_vec: IVector3): MutableVector3;
-    static subtract(l_vec: IVector3, r_vec: IVector3): MutableVector3;
-    static multiply(vec: IVector3, value: number): MutableVector3;
-    static multiplyVector(l_vec: IVector3, r_vec: IVector3): MutableVector3;
-    static divide(vec: IVector3, value: number): MutableVector3;
-    static divideVector(l_vec: IVector3, r_vec: IVector3): MutableVector3;
-    static cross(l_vec: IVector3, r_vec: IVector3): MutableVector3;
-    static multiplyQuaternion(quat: IQuaternion, vec: IVector3): MutableVector3;
-    get className(): string;
-    clone(): MutableVector3;
-}
-export declare class MutableVector3d extends MutableVector3_<Float64ArrayConstructor> {
-    constructor(x: number | TypedArray | IVector2 | IVector3 | IVector4 | Array<number> | null, y?: number, z?: number);
-    static identity(): MutableVector3d;
-    static zero(): MutableVector3d;
-    static one(): MutableVector3d;
-    static dummy(): MutableVector3d;
-    static normalize(vec: IVector3): MutableVector3d;
-    static add(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
-    static subtract(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
-    static multiply(vec: IVector3, value: number): MutableVector3d;
-    static multiplyVector(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
-    static divide(vec: IVector3, value: number): MutableVector3d;
-    static divideVector(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
-    static cross(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
-    static multiplyQuaternion(quat: IQuaternion, vec: IVector3): MutableVector3d;
-    clone(): MutableVector3d;
-}
-export declare type MutableVector3f = MutableVector3;
+import { IVector3, IMutableVector, IMutableVector3 } from './IVector';
+import { TypedArray, FloatTypedArrayConstructor, Array3 } from '../../types/CommonTypes';
+import { Vector3_ } from './Vector3';
+import { IQuaternion } from './IQuaternion';
+export declare class MutableVector3_<T extends FloatTypedArrayConstructor> extends Vector3_<T> implements IMutableVector, IMutableVector3 {
+    constructor(v: TypedArray, { type }: {
+        type: T;
+    });
+    set x(x: number);
+    get x(): number;
+    set y(y: number);
+    get y(): number;
+    set z(z: number);
+    get z(): number;
+    get w(): number;
+    raw(): TypedArray;
+    setAt(i: number, value: number): this;
+    setComponents(x: number, y: number, z: number): this;
+    copyComponents(vec: IVector3): this;
+    zero(): this;
+    one(): this;
+    /**
+     * normalize
+     */
+    normalize(): this;
+    /**
+     * add value
+     */
+    add(vec: IVector3): this;
+    /**
+     * subtract
+     */
+    subtract(vec: IVector3): this;
+    /**
+     * multiply
+     */
+    multiply(value: number): this;
+    /**
+     * multiply vector
+     */
+    multiplyVector(vec: IVector3): this;
+    /**
+     * divide
+     */
+    divide(value: number): this;
+    /**
+     * divide vector
+     */
+    divideVector(vec: IVector3): this;
+    /**
+     * cross product
+     */
+    cross(vec: IVector3): this;
+    /**
+     * quaternion * vector3
+     */
+    multiplyQuaternion(quat: IQuaternion): this;
+}
+export default class MutableVector3 extends MutableVector3_<Float32ArrayConstructor> {
+    constructor(v: TypedArray);
+    static zero(): MutableVector3;
+    static one(): MutableVector3;
+    static dummy(): MutableVector3;
+    static normalize(vec: IVector3): MutableVector3;
+    static add(l_vec: IVector3, r_vec: IVector3): MutableVector3;
+    static subtract(l_vec: IVector3, r_vec: IVector3): MutableVector3;
+    static multiply(vec: IVector3, value: number): MutableVector3;
+    static multiplyVector(l_vec: IVector3, r_vec: IVector3): MutableVector3;
+    static divide(vec: IVector3, value: number): MutableVector3;
+    static divideVector(l_vec: IVector3, r_vec: IVector3): MutableVector3;
+    static cross(l_vec: IVector3, r_vec: IVector3): MutableVector3;
+    static multiplyQuaternion(quat: IQuaternion, vec: IVector3): MutableVector3;
+    get className(): string;
+    static fromCopyArray3(array: Array3<number>): MutableVector3;
+    static fromCopyArray(array: Array<number>): MutableVector3;
+    static fromFloat32Array(float32Array: Float32Array): MutableVector3;
+    static fromCopyFloat32Array(float32Array: Float32Array): MutableVector3;
+    clone(): MutableVector3;
+}
+export declare class MutableVector3d extends MutableVector3_<Float64ArrayConstructor> {
+    constructor(x: TypedArray);
+    static zero(): MutableVector3d;
+    static one(): MutableVector3d;
+    static dummy(): MutableVector3d;
+    static normalize(vec: IVector3): MutableVector3d;
+    static add(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
+    static subtract(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
+    static multiply(vec: IVector3, value: number): MutableVector3d;
+    static multiplyVector(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
+    static divide(vec: IVector3, value: number): MutableVector3d;
+    static divideVector(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
+    static cross(l_vec: IVector3, r_vec: IVector3): MutableVector3d;
+    static multiplyQuaternion(quat: IQuaternion, vec: IVector3): MutableVector3d;
+    static fromCopyArray3(array: Array3<number>): MutableVector3d;
+    static fromCopyArray(array: Array<number>): MutableVector3d;
+    clone(): MutableVector3d;
+}
+export declare type MutableVector3f = MutableVector3;

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

@@ -1,85 +1,87 @@
-import { IVector4, IMutableVector, IMutableVector4 } from './IVector';
-import { Array4, FloatTypedArray, FloatTypedArrayConstructor } from '../../types/CommonTypes';
-import { Vector4_ } from './Vector4';
-export declare class MutableVector4_<T extends FloatTypedArrayConstructor> extends Vector4_<T> implements IMutableVector, IMutableVector4 {
-    constructor(x: FloatTypedArray, { type }: {
-        type: T;
-    });
-    set x(x: number);
-    get x(): number;
-    set y(y: number);
-    get y(): number;
-    set z(z: number);
-    get z(): number;
-    set w(w: number);
-    get w(): number;
-    raw(): import("../../types/CommonTypes").TypedArray;
-    setAt(i: number, value: number): this;
-    setComponents(x: number, y: number, z: number, w: number): this;
-    copyComponents(vec: IVector4): this;
-    zero(): this;
-    one(): this;
-    /**
-     * normalize
-     */
-    normalize(): this;
-    normalize3(): this;
-    /**
-     * add value
-     */
-    add(vec: IVector4): this;
-    /**
-     * subtract
-     */
-    subtract(vec: IVector4): this;
-    /**
-     * multiply
-     */
-    multiply(value: number): this;
-    /**
-     * multiply vector
-     */
-    multiplyVector(vec: IVector4): this;
-    /**
-     * divide
-     */
-    divide(value: number): this;
-    /**
-     * divide vector
-     */
-    divideVector(vec: IVector4): this;
-    get _updateCount(): number;
-    private __updateCount;
-}
-export default class MutableVector4 extends MutableVector4_<Float32ArrayConstructor> {
-    constructor(x: Float32Array);
-    static fromCopyArray(array: Array4<number>): MutableVector4;
-    static zero(): MutableVector4;
-    static one(): MutableVector4;
-    static dummy(): MutableVector4;
-    static normalize(vec: IVector4): MutableVector4;
-    static add(l_vec: IVector4, r_vec: IVector4): MutableVector4;
-    static subtract(l_vec: IVector4, r_vec: IVector4): MutableVector4;
-    static multiply(vec: IVector4, value: number): MutableVector4;
-    static multiplyVector(l_vec: IVector4, r_vec: IVector4): MutableVector4;
-    static divide(vec: IVector4, value: number): MutableVector4;
-    static divideVector(l_vec: IVector4, r_vec: IVector4): MutableVector4;
-    get className(): string;
-    clone(): MutableVector4;
-}
-export declare class MutableVector4d extends MutableVector4_<Float64ArrayConstructor> {
-    constructor(x: Float64Array);
-    static zero(): MutableVector4d;
-    static one(): MutableVector4d;
-    static dummy(): MutableVector4d;
-    static normalize(vec: IVector4): MutableVector4d;
-    static add(l_vec: IVector4, r_vec: IVector4): MutableVector4d;
-    static subtract(l_vec: IVector4, r_vec: IVector4): MutableVector4d;
-    static multiply(vec: IVector4, value: number): MutableVector4d;
-    static multiplyVector(l_vec: IVector4, r_vec: IVector4): MutableVector4d;
-    static divide(vec: IVector4, value: number): MutableVector4d;
-    static divideVector(l_vec: IVector4, r_vec: IVector4): MutableVector4d;
-    static fromCopyArray(array: Array4<number>): MutableVector4d;
-    clone(): MutableVector4d;
-}
-export declare type MutableVector4f = MutableVector4;
+import { IVector4, IMutableVector, IMutableVector4 } from './IVector';
+import { Array4, FloatTypedArray, FloatTypedArrayConstructor } from '../../types/CommonTypes';
+import { Vector4_ } from './Vector4';
+export declare class MutableVector4_<T extends FloatTypedArrayConstructor> extends Vector4_<T> implements IMutableVector, IMutableVector4 {
+    constructor(x: FloatTypedArray, { type }: {
+        type: T;
+    });
+    set x(x: number);
+    get x(): number;
+    set y(y: number);
+    get y(): number;
+    set z(z: number);
+    get z(): number;
+    set w(w: number);
+    get w(): number;
+    raw(): import("../../types/CommonTypes").TypedArray;
+    setAt(i: number, value: number): this;
+    setComponents(x: number, y: number, z: number, w: number): this;
+    copyComponents(vec: IVector4): this;
+    zero(): this;
+    one(): this;
+    /**
+     * normalize
+     */
+    normalize(): this;
+    normalize3(): this;
+    /**
+     * add value
+     */
+    add(vec: IVector4): this;
+    /**
+     * subtract
+     */
+    subtract(vec: IVector4): this;
+    /**
+     * multiply
+     */
+    multiply(value: number): this;
+    /**
+     * multiply vector
+     */
+    multiplyVector(vec: IVector4): this;
+    /**
+     * divide
+     */
+    divide(value: number): this;
+    /**
+     * divide vector
+     */
+    divideVector(vec: IVector4): this;
+    get _updateCount(): number;
+    private __updateCount;
+}
+export default class MutableVector4 extends MutableVector4_<Float32ArrayConstructor> {
+    constructor(x: Float32Array);
+    static fromCopyArray(array: Array<number>): MutableVector4;
+    static fromCopyArray4(array: Array4<number>): MutableVector4;
+    static zero(): MutableVector4;
+    static one(): MutableVector4;
+    static dummy(): MutableVector4;
+    static normalize(vec: IVector4): MutableVector4;
+    static add(l_vec: IVector4, r_vec: IVector4): MutableVector4;
+    static subtract(l_vec: IVector4, r_vec: IVector4): MutableVector4;
+    static multiply(vec: IVector4, value: number): MutableVector4;
+    static multiplyVector(l_vec: IVector4, r_vec: IVector4): MutableVector4;
+    static divide(vec: IVector4, value: number): MutableVector4;
+    static divideVector(l_vec: IVector4, r_vec: IVector4): MutableVector4;
+    get className(): string;
+    clone(): any;
+}
+export declare class MutableVector4d extends MutableVector4_<Float64ArrayConstructor> {
+    constructor(x: Float64Array);
+    static zero(): MutableVector4d;
+    static one(): MutableVector4d;
+    static dummy(): MutableVector4d;
+    static normalize(vec: IVector4): MutableVector4d;
+    static add(l_vec: IVector4, r_vec: IVector4): MutableVector4d;
+    static subtract(l_vec: IVector4, r_vec: IVector4): MutableVector4d;
+    static multiply(vec: IVector4, value: number): MutableVector4d;
+    static multiplyVector(l_vec: IVector4, r_vec: IVector4): MutableVector4d;
+    static divide(vec: IVector4, value: number): MutableVector4d;
+    static divideVector(l_vec: IVector4, r_vec: IVector4): MutableVector4d;
+    static fromCopyArray4(array: Array4<number>): MutableVector4d;
+    static fromCopyArray(array: Array<number>): MutableVector4d;
+    clone(): MutableVector4d;
+}
+export declare type MutableVector4f = MutableVector4;