acmi-parser 1.0.0 → 1.2.0

package/dist/types/math3d/core/classes/pose.d.ts

@@ -0,0 +1,39 @@
+import { Matrix4 } from './matrix4';
+import { Vector3 } from './vector3';
+import { Euler } from './euler';
+import { NumericArray } from '../../types';
+type PoseOptions = {
+    position?: Readonly<NumericArray>;
+    orientation?: Readonly<NumericArray>;
+    x?: number;
+    y?: number;
+    z?: number;
+    roll?: number;
+    pitch?: number;
+    yaw?: number;
+};
+export declare class Pose {
+    readonly position: Vector3;
+    readonly orientation: Euler;
+    constructor({ x, y, z, roll, pitch, yaw, position, orientation, }?: PoseOptions);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get roll(): number;
+    set roll(value: number);
+    get pitch(): number;
+    set pitch(value: number);
+    get yaw(): number;
+    set yaw(value: number);
+    getPosition(): Vector3;
+    getOrientation(): Euler;
+    equals(pose: Pose): boolean;
+    exactEquals(pose: Pose): boolean;
+    getTransformationMatrix(): Matrix4;
+    getTransformationMatrixFromPose(pose: Pose): Matrix4;
+    getTransformationMatrixToPose(pose: Pose): Matrix4;
+}
+export {};

package/dist/types/math3d/core/classes/quaternion.d.ts

@@ -0,0 +1,64 @@
+import { NumericArray } from '../../types';
+import { MathArray } from './base/math-array';
+import { Euler } from './euler';
+export declare class Quaternion extends MathArray {
+    constructor(x?: number | Readonly<NumericArray>, y?: number, z?: number, w?: number);
+    copy(array: Readonly<NumericArray>): this;
+    set(x: number, y: number, z: number, w: number): this;
+    fromObject(object: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): this;
+    /**
+     * Creates a quaternion from the given 3x3 rotation matrix.
+     * NOTE: The resultant quaternion is not normalized, so you should
+     * be sure to renormalize the quaternion yourself where necessary.
+     * @param m
+     * @returns
+     */
+    fromMatrix3(m: Readonly<NumericArray>): this;
+    fromAxisRotation(axis: Readonly<NumericArray>, rad: number): this;
+    fromEuler(e: Euler): this;
+    /** Set a quat to the identity quaternion */
+    identity(): this;
+    setAxisAngle(axis: Readonly<NumericArray>, rad: number): this;
+    get ELEMENTS(): number;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    len(): number;
+    lengthSquared(): number;
+    dot(a: Readonly<NumericArray>): number;
+    rotationTo(vectorA: NumericArray, vectorB: NumericArray): this;
+    add(a: Readonly<NumericArray>): this;
+    calculateW(): this;
+    conjugate(): this;
+    invert(): this;
+    lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray> | number, t?: number): this;
+    multiplyRight(a: Readonly<NumericArray>): this;
+    multiplyLeft(a: Readonly<NumericArray>): this;
+    normalize(): this;
+    rotateX(rad: number): this;
+    rotateY(rad: number): this;
+    rotateZ(rad: number): this;
+    scale(b: number): this;
+    slerp(target: Readonly<NumericArray>, ratio: number): this;
+    slerp(start: Readonly<NumericArray>, target: Readonly<NumericArray>, ratio: number): this;
+    slerp(params: {
+        start: Readonly<NumericArray>;
+        target: Readonly<NumericArray>;
+        ratio: number;
+    }): this;
+    transformVector4(vector: Readonly<NumericArray>, result?: NumericArray): NumericArray;
+    lengthSq(): number;
+    setFromAxisAngle(axis: Readonly<NumericArray>, rad: number): this;
+    premultiply(a: Readonly<NumericArray>): this;
+    multiply(a: Readonly<NumericArray>): this;
+}

package/dist/types/math3d/core/classes/spherical-coordinates.d.ts

@@ -0,0 +1,59 @@
+import { NumericArray } from '../../types';
+import { Vector3 } from './vector3';
+type SphericalCoordinatesOptions = {
+    phi?: number;
+    theta?: number;
+    radius?: number;
+    bearing?: number;
+    pitch?: number;
+    altitude?: number;
+    radiusScale?: number;
+};
+type FormatOptions = {
+    printTypes?: boolean;
+};
+/**
+ * The poles (phi) are at the positive and negative y axis.
+ * The equator starts at positive z.
+ * @link https://en.wikipedia.org/wiki/Spherical_coordinate_system
+ */
+export declare class SphericalCoordinates {
+    phi: number;
+    theta: number;
+    radius: number;
+    radiusScale: number;
+    /**
+     * Creates a new SphericalCoordinates object
+     * @param options
+     * @param [options.phi] =0 - rotation around X (latitude)
+     * @param [options.theta] =0 - rotation around Y (longitude)
+     * @param [options.radius] =1 - Distance from center
+     * @param [options.bearing]
+     * @param [options.pitch]
+     * @param [options.altitude]
+     * @param [options.radiusScale] =1
+     */
+    constructor({ phi, theta, radius, bearing, pitch, altitude, radiusScale, }?: SphericalCoordinatesOptions);
+    toString(): string;
+    formatString({ printTypes }: FormatOptions): string;
+    equals(other: SphericalCoordinates): boolean;
+    exactEquals(other: SphericalCoordinates): boolean;
+    get bearing(): number;
+    set bearing(v: number);
+    get pitch(): number;
+    set pitch(v: number);
+    get longitude(): number;
+    get latitude(): number;
+    get lng(): number;
+    get lat(): number;
+    get z(): number;
+    set(radius: number, phi: number, theta: number): this;
+    clone(): SphericalCoordinates;
+    copy(other: SphericalCoordinates): this;
+    fromLngLatZ([lng, lat, z]: [number, number, number]): this;
+    fromVector3(v: Readonly<NumericArray>): this;
+    toVector3(): Vector3;
+    makeSafe(): this;
+    check(): this;
+}
+export {};

package/dist/types/math3d/core/classes/vector2.d.ts

@@ -0,0 +1,54 @@
+import { Vector } from './base/vector';
+import { NumericArray } from '../../types';
+/**
+ * Two-element vector class.
+ * Subclass of Array<number>
+ */
+export declare class Vector2 extends Vector {
+    constructor(x?: number | Readonly<NumericArray>, y?: number);
+    set(x: number, y: number): this;
+    copy(array: Readonly<NumericArray>): this;
+    fromObject(object: {
+        x: number;
+        y: number;
+    }): this;
+    toObject(object: {
+        x?: number;
+        y?: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    get ELEMENTS(): number;
+    /**
+     * Returns angle from x axis
+     * @returns
+     */
+    horizontalAngle(): number;
+    /**
+     * Returns angle from y axis
+     * @returns
+     */
+    verticalAngle(): number;
+    /**
+     * Transforms as point
+     * @param matrix4
+     * @returns
+     */
+    transform(matrix4: Readonly<NumericArray>): this;
+    /**
+     * transforms as point (4th component is implicitly 1)
+     * @param matrix4
+     * @returns
+     */
+    transformAsPoint(matrix4: Readonly<NumericArray>): this;
+    /**
+     * transforms as vector (4th component is implicitly 0, ignores translation. slightly faster)
+     * @param matrix4
+     * @returns
+     */
+    transformAsVector(matrix4: Readonly<NumericArray>): this;
+    transformByMatrix3(matrix3: Readonly<NumericArray>): this;
+    transformByMatrix2x3(matrix2x3: Readonly<NumericArray>): this;
+    transformByMatrix2(matrix2: Readonly<NumericArray>): this;
+}

package/dist/types/math3d/core/classes/vector3.d.ts

@@ -0,0 +1,59 @@
+import { NumericArray } from '../../types';
+import { Vector } from './base/vector';
+/**
+ * Three-element vector class.
+ * Subclass of Array<number>
+ */
+export declare class Vector3 extends Vector {
+    static get ZERO(): Vector3;
+    static get X_AXIS(): Vector3;
+    static get Y_AXIS(): Vector3;
+    static get Z_AXIS(): Vector3;
+    /**
+     * @class
+     * @param x
+     * @param y
+     * @param z
+     */
+    constructor(x?: number | Readonly<NumericArray>, y?: number, z?: number);
+    set(x: number, y: number, z: number): this;
+    copy(array: Readonly<NumericArray>): this;
+    fromObject(object: {
+        x: number;
+        y: number;
+        z: number;
+    }): this;
+    toObject(object: {
+        x?: number;
+        y?: number;
+        z?: number;
+    }): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    get ELEMENTS(): number;
+    get z(): number;
+    set z(value: number);
+    angle(vector: Readonly<NumericArray>): number;
+    static cross<T extends NumericArray>(left: Readonly<NumericArray>, right: Readonly<NumericArray>, result?: T): T;
+    cross(vector: Readonly<NumericArray>): this;
+    rotateX({ radians, origin, }: {
+        radians: number;
+        origin?: Readonly<NumericArray>;
+    }): this;
+    rotateY({ radians, origin, }: {
+        radians: number;
+        origin?: Readonly<NumericArray>;
+    }): this;
+    rotateZ({ radians, origin, }: {
+        radians: number;
+        origin?: Readonly<NumericArray>;
+    }): this;
+    transform(matrix4: Readonly<NumericArray>): this;
+    transformAsPoint(matrix4: Readonly<NumericArray>): this;
+    transformAsVector(matrix4: Readonly<NumericArray>): this;
+    transformByMatrix3(matrix3: Readonly<NumericArray>): this;
+    transformByMatrix2(matrix2: Readonly<NumericArray>): this;
+    transformByQuaternion(quaternion: Readonly<NumericArray>): this;
+}

package/dist/types/math3d/core/classes/vector4.d.ts

@@ -0,0 +1,40 @@
+import { NumericArray } from '../../types';
+import { Vector } from './base/vector';
+import { Matrix4 } from './matrix4';
+/**
+ * Four-element vector class.
+ * Subclass of Array<number>
+ */
+export declare class Vector4 extends Vector {
+    static get ZERO(): Vector4;
+    constructor(x?: number | Readonly<NumericArray>, y?: number, z?: number, w?: number);
+    set(x: number, y: number, z: number, w: number): this;
+    copy(array: Readonly<NumericArray>): this;
+    fromObject(object: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): this;
+    toObject(object: {
+        x?: number;
+        y?: number;
+        z?: number;
+        w?: number;
+    }): {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    get ELEMENTS(): number;
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    transform(matrix4: Readonly<NumericArray>): this;
+    transformByMatrix3(matrix3: Readonly<NumericArray>): this;
+    transformByMatrix2(matrix2: Readonly<NumericArray>): this;
+    transformByQuaternion(quaternion: Readonly<NumericArray>): this;
+    applyMatrix4(m: Matrix4): this;
+}

package/dist/types/math3d/core/gl-matrix/common.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Common utilities
+ * @module glMatrix
+ */
+export declare const EPSILON = 0.000001;
+export declare let ARRAY_TYPE: Float32ArrayConstructor | ArrayConstructor;
+export declare const RANDOM: () => number;
+export declare const ANGLE_ORDER = 0;
+/**
+ * Symmetric round
+ * see https://www.npmjs.com/package/round-half-up-symmetric#user-content-detailed-background
+ *
+ * @param {Number} a value to round
+ */
+export declare function round(a: number): number;
+/**
+ * Sets the type of array used when creating new vectors and matrices
+ *
+ * @param {Float32ArrayConstructor | ArrayConstructor} type Array type, such as Float32Array or Array
+ */
+export declare function setMatrixArrayType(type: Float32ArrayConstructor | ArrayConstructor): void;
+/**
+ * Convert Degree To Radian
+ *
+ * @param {Number} a Angle in Degrees
+ */
+export declare function toRadian(a: number): number;
+/**
+ * Tests whether or not the arguments have approximately the same value, within an absolute
+ * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less
+ * than or equal to 1.0, and a relative tolerance is used for larger values)
+ *
+ * @param {Number} a The first number to test.
+ * @param {Number} b The second number to test.
+ * @returns {Boolean} True if the numbers are approximately equal, false otherwise.
+ */
+export declare function equals(a: number, b: number): boolean;

package/dist/types/math3d/core/gl-matrix/mat3.d.ts

@@ -0,0 +1,286 @@
+/**
+ * 3x3 Matrix
+ * @module mat3
+ */
+/**
+ * Creates a new identity mat3
+ *
+ * @returns {mat3} a new 3x3 matrix
+ */
+export declare function create(): any[] | Float32Array<ArrayBuffer>;
+/**
+ * Copies the upper-left 3x3 values into the given mat3.
+ *
+ * @param {mat3} out the receiving 3x3 matrix
+ * @param {ReadonlyMat4} a   the source 4x4 matrix
+ * @returns {mat3} out
+ */
+export declare function fromMat4(out: any, a: any): any;
+/**
+ * Creates a new mat3 initialized with values from an existing matrix
+ *
+ * @param {ReadonlyMat3} a matrix to clone
+ * @returns {mat3} a new 3x3 matrix
+ */
+export declare function clone(a: any): any[] | Float32Array<ArrayBuffer>;
+/**
+ * Copy the values from one mat3 to another
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the source matrix
+ * @returns {mat3} out
+ */
+export declare function copy(out: any, a: any): any;
+/**
+ * Create a new mat3 with the given values
+ *
+ * @param {Number} m00 Component in column 0, row 0 position (index 0)
+ * @param {Number} m01 Component in column 0, row 1 position (index 1)
+ * @param {Number} m02 Component in column 0, row 2 position (index 2)
+ * @param {Number} m10 Component in column 1, row 0 position (index 3)
+ * @param {Number} m11 Component in column 1, row 1 position (index 4)
+ * @param {Number} m12 Component in column 1, row 2 position (index 5)
+ * @param {Number} m20 Component in column 2, row 0 position (index 6)
+ * @param {Number} m21 Component in column 2, row 1 position (index 7)
+ * @param {Number} m22 Component in column 2, row 2 position (index 8)
+ * @returns {mat3} A new mat3
+ */
+export declare function fromValues(m00: any, m01: any, m02: any, m10: any, m11: any, m12: any, m20: any, m21: any, m22: any): any[] | Float32Array<ArrayBuffer>;
+/**
+ * Set the components of a mat3 to the given values
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {Number} m00 Component in column 0, row 0 position (index 0)
+ * @param {Number} m01 Component in column 0, row 1 position (index 1)
+ * @param {Number} m02 Component in column 0, row 2 position (index 2)
+ * @param {Number} m10 Component in column 1, row 0 position (index 3)
+ * @param {Number} m11 Component in column 1, row 1 position (index 4)
+ * @param {Number} m12 Component in column 1, row 2 position (index 5)
+ * @param {Number} m20 Component in column 2, row 0 position (index 6)
+ * @param {Number} m21 Component in column 2, row 1 position (index 7)
+ * @param {Number} m22 Component in column 2, row 2 position (index 8)
+ * @returns {mat3} out
+ */
+export declare function set(out: any, m00: any, m01: any, m02: any, m10: any, m11: any, m12: any, m20: any, m21: any, m22: any): any;
+/**
+ * Set a mat3 to the identity matrix
+ *
+ * @param {mat3} out the receiving matrix
+ * @returns {mat3} out
+ */
+export declare function identity(out: any): any;
+/**
+ * Transpose the values of a mat3
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the source matrix
+ * @returns {mat3} out
+ */
+export declare function transpose(out: any, a: any): any;
+/**
+ * Inverts a mat3
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the source matrix
+ * @returns {mat3} out
+ */
+export declare function invert(out: any, a: any): any;
+/**
+ * Calculates the adjugate of a mat3
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the source matrix
+ * @returns {mat3} out
+ */
+export declare function adjoint(out: any, a: any): any;
+/**
+ * Calculates the determinant of a mat3
+ *
+ * @param {ReadonlyMat3} a the source matrix
+ * @returns {Number} determinant of a
+ */
+export declare function determinant(a: any): number;
+/**
+ * Multiplies two mat3's
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the first operand
+ * @param {ReadonlyMat3} b the second operand
+ * @returns {mat3} out
+ */
+export declare function multiply(out: any, a: any, b: any): any;
+/**
+ * Translate a mat3 by the given vector
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the matrix to translate
+ * @param {ReadonlyVec2} v vector to translate by
+ * @returns {mat3} out
+ */
+export declare function translate(out: any, a: any, v: any): any;
+/**
+ * Rotates a mat3 by the given angle
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat3} out
+ */
+export declare function rotate(out: any, a: any, rad: any): any;
+/**
+ * Scales the mat3 by the dimensions in the given vec2
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the matrix to scale
+ * @param {ReadonlyVec2} v the vec2 to scale the matrix by
+ * @returns {mat3} out
+ **/
+export declare function scale(out: any, a: any, v: any): any;
+/**
+ * Creates a matrix from a vector translation
+ * This is equivalent to (but much faster than):
+ *
+ *     mat3.identity(dest);
+ *     mat3.translate(dest, dest, vec);
+ *
+ * @param {mat3} out mat3 receiving operation result
+ * @param {ReadonlyVec2} v Translation vector
+ * @returns {mat3} out
+ */
+export declare function fromTranslation(out: any, v: any): any;
+/**
+ * Creates a matrix from a given angle
+ * This is equivalent to (but much faster than):
+ *
+ *     mat3.identity(dest);
+ *     mat3.rotate(dest, dest, rad);
+ *
+ * @param {mat3} out mat3 receiving operation result
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat3} out
+ */
+export declare function fromRotation(out: any, rad: any): any;
+/**
+ * Creates a matrix from a vector scaling
+ * This is equivalent to (but much faster than):
+ *
+ *     mat3.identity(dest);
+ *     mat3.scale(dest, dest, vec);
+ *
+ * @param {mat3} out mat3 receiving operation result
+ * @param {ReadonlyVec2} v Scaling vector
+ * @returns {mat3} out
+ */
+export declare function fromScaling(out: any, v: any): any;
+/**
+ * Copies the values from a mat2d into a mat3
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat2d} a the matrix to copy
+ * @returns {mat3} out
+ **/
+export declare function fromMat2d(out: any, a: any): any;
+/**
+ * Calculates a 3x3 matrix from the given quaternion
+ *
+ * @param {mat3} out mat3 receiving operation result
+ * @param {ReadonlyQuat} q Quaternion to create matrix from
+ *
+ * @returns {mat3} out
+ */
+export declare function fromQuat(out: any, q: any): any;
+/**
+ * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix
+ *
+ * @param {mat3} out mat3 receiving operation result
+ * @param {ReadonlyMat4} a Mat4 to derive the normal matrix from
+ *
+ * @returns {mat3} out
+ */
+export declare function normalFromMat4(out: any, a: any): any;
+/**
+ * Generates a 2D projection matrix with the given bounds
+ *
+ * @param {mat3} out mat3 frustum matrix will be written into
+ * @param {number} width Width of your gl context
+ * @param {number} height Height of gl context
+ * @returns {mat3} out
+ */
+export declare function projection(out: any, width: any, height: any): any;
+/**
+ * Returns a string representation of a mat3
+ *
+ * @param {ReadonlyMat3} a matrix to represent as a string
+ * @returns {String} string representation of the matrix
+ */
+export declare function str(a: any): string;
+/**
+ * Returns Frobenius norm of a mat3
+ *
+ * @param {ReadonlyMat3} a the matrix to calculate Frobenius norm of
+ * @returns {Number} Frobenius norm
+ */
+export declare function frob(a: any): number;
+/**
+ * Adds two mat3's
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the first operand
+ * @param {ReadonlyMat3} b the second operand
+ * @returns {mat3} out
+ */
+export declare function add(out: any, a: any, b: any): any;
+/**
+ * Subtracts matrix b from matrix a
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the first operand
+ * @param {ReadonlyMat3} b the second operand
+ * @returns {mat3} out
+ */
+export declare function subtract(out: any, a: any, b: any): any;
+/**
+ * Multiply each element of the matrix by a scalar.
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {ReadonlyMat3} a the matrix to scale
+ * @param {Number} b amount to scale the matrix's elements by
+ * @returns {mat3} out
+ */
+export declare function multiplyScalar(out: any, a: any, b: any): any;
+/**
+ * Adds two mat3's after multiplying each element of the second operand by a scalar value.
+ *
+ * @param {mat3} out the receiving vector
+ * @param {ReadonlyMat3} a the first operand
+ * @param {ReadonlyMat3} b the second operand
+ * @param {Number} scale the amount to scale b's elements by before adding
+ * @returns {mat3} out
+ */
+export declare function multiplyScalarAndAdd(out: any, a: any, b: any, scale: any): any;
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ *
+ * @param {ReadonlyMat3} a The first matrix.
+ * @param {ReadonlyMat3} b The second matrix.
+ * @returns {Boolean} True if the matrices are equal, false otherwise.
+ */
+export declare function exactEquals(a: any, b: any): boolean;
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ *
+ * @param {ReadonlyMat3} a The first matrix.
+ * @param {ReadonlyMat3} b The second matrix.
+ * @returns {Boolean} True if the matrices are equal, false otherwise.
+ */
+export declare function equals(a: any, b: any): boolean;
+/**
+ * Alias for {@link mat3.multiply}
+ * @function
+ */
+export declare const mul: typeof multiply;
+/**
+ * Alias for {@link mat3.subtract}
+ * @function
+ */
+export declare const sub: typeof subtract;