rc-js-util/bin/esm/array/typed-array/mat3/mat3.d.ts

A collection of TS and C++ utilities to help writing performant and correct applications, achieved through strict typing and (removable) invariant checking.

import { ATypedArrayTuple, TTypedArrayTupleMutativeMethods } from "../a-typed-array-tuple.js";
import { TTypedArray } from "../t-typed-array.js";
import { ITypedArrayTupleFactory } from "../i-typed-array-tuple-factory.js";
import { TTypedArrayCtor } from "../t-typed-array-ctor.js";
import { IReadonlyVec3, Vec3 } from "../vec3/vec3.js";
import { TPickExcept } from "../../../typescript/t-pick-except.js";
/**
 * @public
 */
export type TMat3CtorArgs = [
    c1r1: number,
    c2r1: number,
    c3r1: number,
    c1r2: number,
    c2r2: number,
    c3r2: number,
    c1r3: number,
    c2r3: number,
    c3r3: number
];
/**
 * @public
 * Constructor for {@link Mat3}.
 */
export interface IMat3Ctor<TArray extends TTypedArray> {
    readonly BASE: TTypedArrayCtor;
    /**
     * The size in bytes of each element in the array.
     */
    readonly BYTES_PER_ELEMENT: number;
    readonly prototype: Mat3<TArray>;
    readonly factory: ITypedArrayTupleFactory<Mat3<TArray>, TMat3CtorArgs>;
    new (): Mat3<TArray>;
}
/**
 * @public
 * {@link Mat3}.
 */
export interface IReadonlyMat3<TArray extends TTypedArray> extends TPickExcept<Readonly<Mat3<TArray>>, "setValueAt" | "setRow" | "copyFromBuffer" | TTypedArrayTupleMutativeMethods> {
}
/**
 * @public
 * Row major 3x3 matrix.
 *
 * @remarks
 * See static properties for constructors. Instances are not an extension of this class, but of the static members.
 */
export declare abstract class Mat3<TArray extends TTypedArray> extends ATypedArrayTuple<9, TArray> {
    static f64: IMat3Ctor<Float64Array>;
    static f32: IMat3Ctor<Float32Array>;
    static i64: null;
    static u64: null;
    static u32: IMat3Ctor<Uint32Array>;
    static i32: IMat3Ctor<Int32Array>;
    static u16: IMat3Ctor<Uint16Array>;
    static i16: IMat3Ctor<Int16Array>;
    static u8c: IMat3Ctor<Uint8ClampedArray>;
    static u8: IMat3Ctor<Uint8Array>;
    static i8: IMat3Ctor<Int8Array>;
    static getCtor<TCtor extends TTypedArrayCtor>(ctor: TCtor): IMat3Ctor<InstanceType<TCtor>>;
    protected static constructors: Map<import("../t-typed-array-ctor.js").TFullSetTypedArrayCtor, Function>;
    ["constructor"]: IMat3Ctor<TArray>;
    /**
     * c1r1
     */
    0: number;
    /**
     * c2r1
     */
    1: number;
    /**
     * c3r1
     */
    2: number;
    /**
     * c1r2
     */
    3: number;
    /**
     * c2r2
     */
    4: number;
    /**
     * c3r2
     */
    5: number;
    /**
     * c1r3
     */
    6: number;
    /**
     * c2r3
     */
    7: number;
    /**
     * c3r3
     */
    8: number;
    /**
     * Component-wise equals.
     */
    isEqualTo(_other: Mat3<TTypedArray>): boolean;
    setIdentityMatrix(): Mat3<TArray>;
    getValueAt(_column: number, _row: number): number;
    setValueAt(_column: number, _row: number, _value: number): void;
    getRow<TResult extends TTypedArray = TArray>(_row: number, _writeTo?: Vec3<TResult>): Vec3<TResult>;
    setRow(_row: number, _writeFrom: IReadonlyVec3<TTypedArray>): void;
    /**
     * counter clockwise, in radians
     */
    setRotationMatrix(_angle: number): Mat3<TArray>;
    setScalingMatrix(_scalingFactorX: number, _scalingFactorY: number): Mat3<TArray>;
    setTranslationMatrix(_translationX: number, _translationY: number): Mat3<TArray>;
    scalarMultiply<TResult extends TTypedArray = TArray>(_value: number, _result?: Mat3<TResult>): Mat3<TResult>;
    scalarAdd<TResult extends TTypedArray = TArray>(_value: number, _result?: Mat3<TResult>): Mat3<TResult>;
    multiplyMat3<TResult extends TTypedArray = TArray>(_mat: IReadonlyMat3<TTypedArray>, _result?: Mat3<TResult>): Mat3<TResult>;
    getVec3MultiplyX(_x: number): number;
    getVec3MultiplyY(_y: number): number;
    /**
     * Apply this transform as if it were x in a vec3 to both min and max, return the difference.
     */
    getTransformedXLength(_min: number, _max: number): number;
    /**
     * Apply this transform as if it were y in a vec3 to both min and max, return the difference.
     */
    getTransformedYLength(_min: number, _max: number): number;
    getLoggableValue(): number[][];
    /**
     * If endianness is not supplied the platform's endianness will be used.
     */
    copyFromBuffer(_memoryDataView: DataView, _pointer: number, _littleEndian?: boolean): void;
    /**
     * If endianness is not supplied the platform's endianness will be used.
     */
    copyToBuffer(_memoryDataView: DataView, _pointer: number, _littleEndian?: boolean): void;
    /**
     * Although the typed array tuples extend a typed array, they are not structurally compatible.
     * This function returns the argument passed without modification but cast as the underlying storage type, e.g. Float32Array.
     */
    castToBaseType(): TArray;
    protected TTypeGuardMat3: true;
}
/**
 * @public
 * Float32 {@link Mat3}.
 */
export type TF32Mat3 = Mat3<Float32Array>;
/**
 * @public
 * Float64 {@link Mat3}.
 */
export type TF64Mat3 = Mat3<Float64Array>;
//# sourceMappingURL=mat3.d.ts.map