@itwin/core-orbitgt 3.0.0-dev.100

package/lib/cjs/spatial/geom/Transform.js

@@ -0,0 +1,749 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module OrbitGT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transform = void 0;
+const Bounds_1 = require("./Bounds");
+const Coordinate_1 = require("./Coordinate");
+/**
+ * Class Transform defines a generic 3D transformation.
+ *
+ * @version 1.0 November 2015
+ */
+/** @internal */
+class Transform {
+    /**
+     * Create a new (identity) transform.
+     */
+    constructor() {
+        this._elements = new Float64Array(16);
+        this._elements[0] = 1.0; // m00
+        this._elements[1] = 0.0; // m01
+        this._elements[2] = 0.0; // m02
+        this._elements[3] = 0.0; // m03
+        this._elements[4] = 0.0; // m10
+        this._elements[5] = 1.0; // m11
+        this._elements[6] = 0.0; // m12
+        this._elements[7] = 0.0; // m13
+        this._elements[8] = 0.0; // m20
+        this._elements[9] = 0.0; // m21
+        this._elements[10] = 1.0; // m22
+        this._elements[11] = 0.0; // m23
+        this._elements[12] = 0.0; // m30
+        this._elements[13] = 0.0; // m31
+        this._elements[14] = 0.0; // m32
+        this._elements[15] = 1.0; // m33
+    }
+    /**
+     * Create a new (identity) transform.
+     */
+    static create() {
+        return new Transform();
+    }
+    /**
+     * Create a transformation from elements.
+     * @param elements the 16 matrix elements (row major order).
+     * @return the transformation.
+     */
+    static fromRowMajor(elements) {
+        if (elements == null)
+            return null;
+        if (elements.length == 0)
+            return null;
+        let transform = new Transform();
+        let index = 0;
+        for (let r = 0; r < 4; r++)
+            for (let c = 0; c < 4; c++)
+                transform.setElement(r, c, elements[index++]);
+        return transform;
+    }
+    /**
+     * Create a transformation from elements.
+     * @param elements the 16 matrix elements (column major order).
+     * @return the transformation.
+     */
+    static fromColumnMajor(elements) {
+        if (elements == null)
+            return null;
+        if (elements.length == 0)
+            return null;
+        let transform = new Transform();
+        let index = 0;
+        for (let c = 0; c < 4; c++)
+            for (let r = 0; r < 4; r++)
+                transform.setElement(r, c, elements[index++]);
+        return transform;
+    }
+    /**
+     * Create a transformation from elements.
+     * @param elements the 9 matrix elements (row major order).
+     * @return the transformation.
+     */
+    static fromRotationElements(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
+        let transform = new Transform();
+        transform.setElement(0, 0, m00);
+        transform.setElement(0, 1, m01);
+        transform.setElement(0, 2, m02);
+        transform.setElement(1, 0, m10);
+        transform.setElement(1, 1, m11);
+        transform.setElement(1, 2, m12);
+        transform.setElement(2, 0, m20);
+        transform.setElement(2, 1, m21);
+        transform.setElement(2, 2, m22);
+        return transform;
+    }
+    /**
+     * Create a transformation from elements.
+     * @param elements the 16 matrix elements (row major order).
+     * @return the transformation.
+     */
+    static fromElements(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23) {
+        let transform = Transform.fromRotationElements(m00, m01, m02, m10, m11, m12, m20, m21, m22);
+        transform.setElement(0, 3, m03);
+        transform.setElement(1, 3, m13);
+        transform.setElement(2, 3, m23);
+        return transform;
+    }
+    /**
+     * Get an element.
+     * @param index the index of the element.
+     * @return the element.
+     */
+    get(index) {
+        return this._elements[index];
+    }
+    /**
+     * Set an element.
+     * @param index the index of the element.
+     * @param value the value.
+     */
+    set(index, value) {
+        this._elements[index] = value;
+    }
+    /**
+     * Get an element.
+     * @param row the row index.
+     * @param col the column index.
+     * @return the element.
+     */
+    getElement(row, col) {
+        return this._elements[row * 4 + col];
+    }
+    /**
+     * Set an element.
+     * @param row the row index.
+     * @param col the column index.
+     * @param value the value.
+     */
+    setElement(row, col, value) {
+        this._elements[row * 4 + col] = value;
+    }
+    /**
+     * Get the elements.
+     * @return the elements (row major order).
+     */
+    getElements() {
+        return this._elements;
+    }
+    /**
+     * Set the elements.
+     * @param elements the elements (row major order).
+     */
+    setElements(elements) {
+        for (let i = 0; i < this._elements.length; i++)
+            this._elements[i] = elements[i];
+    }
+    /**
+     * Get the X column.
+     * @return the X column.
+     */
+    getColumnX() {
+        return new Coordinate_1.Coordinate(this.getElement(0, 0), this.getElement(1, 0), this.getElement(2, 0));
+    }
+    /**
+     * Get the Y column.
+     * @return the Y column.
+     */
+    getColumnY() {
+        return new Coordinate_1.Coordinate(this.getElement(0, 1), this.getElement(1, 1), this.getElement(2, 1));
+    }
+    /**
+     * Get the Z column.
+     * @return the Z column.
+     */
+    getColumnZ() {
+        return new Coordinate_1.Coordinate(this.getElement(0, 2), this.getElement(1, 2), this.getElement(2, 2));
+    }
+    /**
+     * Get the translation column.
+     * @return the translation column.
+     */
+    getTranslation() {
+        return new Coordinate_1.Coordinate(this.getElement(0, 3), this.getElement(1, 3), this.getElement(2, 3));
+    }
+    /**
+     * Set the translation.
+     * @param tx the x position of the translation.
+     * @param ty the y position of the translation.
+     * @param tz the z position of the translation.
+     * @return the tranformation.
+     */
+    setTranslation(tx, ty, tz) {
+        this.setElement(0, 3, tx);
+        this.setElement(1, 3, ty);
+        this.setElement(2, 3, tz);
+        return this;
+    }
+    /**
+     * Clear the translation.
+     * @return the tranformation.
+     */
+    clearTranslation() {
+        this.setElement(0, 3, 0.0);
+        this.setElement(1, 3, 0.0);
+        this.setElement(2, 3, 0.0);
+        return this;
+    }
+    /**
+     * Swap two rows.
+     * @param row1 the first row.
+     * @param row2 the second row.
+     */
+    swapRows(row1, row2) {
+        for (let i = 0; i < 4; i++) {
+            let e1 = this.getElement(row1, i);
+            let e2 = this.getElement(row2, i);
+            this.setElement(row1, i, e2);
+            this.setElement(row2, i, e1);
+        }
+    }
+    /**
+     * Swap two columns.
+     * @param col1 the first column.
+     * @param col2 the second column.
+     */
+    swapColumns(col1, col2) {
+        for (let i = 0; i < 4; i++) {
+            let e1 = this.getElement(i, col1);
+            let e2 = this.getElement(i, col2);
+            this.setElement(i, col1, e2);
+            this.setElement(i, col2, e1);
+        }
+    }
+    /**
+     * Swap the YZ coordinates.
+     */
+    swapYZ() {
+        let result = Transform.multiply2(this, Transform.createSwapYZ());
+        this.setElements(result.getElements());
+    }
+    /**
+     * Calculate the cosine of an angle.
+     * @param angle the angle (in degrees).
+     * @return the cosine.
+     */
+    static cos(angle) {
+        /* One? */
+        if (angle == 0.0)
+            return 1.0;
+        if (angle == 360.0)
+            return 1.0;
+        /* Minus one? */
+        if (angle == 180.0)
+            return -1.0;
+        if (angle == -180.0)
+            return -1.0;
+        /* Zero? */
+        if (angle == 90.0)
+            return 0.0;
+        if (angle == -90.0)
+            return 0.0;
+        if (angle == 270.0)
+            return 0.0;
+        /* Calculate */
+        return Math.cos(angle / 180.0 * Math.PI);
+    }
+    /**
+     * Calculate the sine of an angle.
+     * @param angle the angle (in degrees).
+     * @return the sine.
+     */
+    static sin(angle) {
+        /* One? */
+        if (angle == 90.0)
+            return 1.0;
+        /* Minus one? */
+        if (angle == -90.0)
+            return -1.0;
+        if (angle == 270.0)
+            return -1.0;
+        /* Zero? */
+        if (angle == 0.0)
+            return 0.0;
+        if (angle == 360.0)
+            return 0.0;
+        if (angle == 180.0)
+            return 0.0;
+        if (angle == -180.0)
+            return 0.0;
+        /* Calculate */
+        return Math.sin(angle / 180.0 * Math.PI);
+    }
+    /**
+     * Rotate around the X axis.
+ * @param angle the rotation angle (degree).
+     */
+    rotateX(angle) {
+        if (angle == 0.0)
+            return;
+        let result = Transform.multiply2(this, Transform.createRotationX(angle));
+        this.setElements(result.getElements());
+    }
+    /**
+     * Apply a rotation around X axis.
+     * @param point the (mutable) point to rotate.
+     * @param rotation the (Y->Z,counterclockwise) rotation (degrees).
+     */
+    static rotatePointX(point, rotation) {
+        if (rotation == 0.0)
+            return;
+        let a = rotation;
+        let dcos = Transform.cos(a);
+        let dsin = Transform.sin(a);
+        let ny = dcos * point.getY() - dsin * point.getZ();
+        let nz = dsin * point.getY() + dcos * point.getZ();
+        point.setXYZ(point.getX(), ny, nz);
+    }
+    /**
+     * Rotate around the Y axis.
+ * @param angle the rotation angle (degree).
+     */
+    rotateY(angle) {
+        if (angle == 0.0)
+            return;
+        let result = Transform.multiply2(this, Transform.createRotationY(angle));
+        this.setElements(result.getElements());
+    }
+    /**
+     * Apply a rotation around Y axis.
+     * @param point the (mutable) point to rotate.
+     * @param rotation the (Z->X,counterclockwise) rotation (degrees).
+     */
+    static rotatePointY(point, rotation) {
+        if (rotation == 0.0)
+            return;
+        let a = -rotation; // swapped orientation to CCW on 09/03/2012
+        let dcos = Transform.cos(a);
+        let dsin = Transform.sin(a);
+        let nx = dcos * point.getX() - dsin * point.getZ();
+        let nz = dsin * point.getX() + dcos * point.getZ();
+        point.setXYZ(nx, point.getY(), nz);
+    }
+    /**
+     * Rotate around the Z axis.
+ * @param angle the rotation angle (degree).
+     */
+    rotateZ(angle) {
+        if (angle == 0.0)
+            return;
+        let result = Transform.multiply2(this, Transform.createRotationZ(angle));
+        this.setElements(result.getElements());
+    }
+    /**
+     * Apply a rotation around Z axis.
+     * @param point the (mutable) point to rotate.
+     * @param rotation the (X->Y,counterclockwise) rotation (degrees).
+     */
+    static rotatePointZ(point, rotation) {
+        if (rotation == 0.0)
+            return;
+        let a = rotation;
+        let dcos = Transform.cos(a);
+        let dsin = Transform.sin(a);
+        let nx = dcos * point.getX() - dsin * point.getY();
+        let ny = dsin * point.getX() + dcos * point.getY();
+        point.setXYZ(nx, ny, point.getZ());
+    }
+    /**
+     * Multiply two matrices.
+     * @param a the first transform.
+     * @param b the second transform.
+     * @return the result transform (a x b).
+     */
+    static multiply2(a, b) {
+        /* Allow nulls */
+        if (a == null)
+            a = new Transform();
+        if (b == null)
+            b = new Transform();
+        /* Fill the destination transform "d" */
+        let d = new Transform();
+        for (let i = 0; i < 4; i++) {
+            /* Get the next row from "a" */
+            let ai0 = a.getElement(i, 0);
+            let ai1 = a.getElement(i, 1);
+            let ai2 = a.getElement(i, 2);
+            let ai3 = a.getElement(i, 3);
+            /* Set the target row in "d" */
+            d.setElement(i, 0, ai0 * b.getElement(0, 0) + ai1 * b.getElement(1, 0) + ai2 * b.getElement(2, 0) + ai3 * b.getElement(3, 0)); // multiply by column(0) of "b"
+            d.setElement(i, 1, ai0 * b.getElement(0, 1) + ai1 * b.getElement(1, 1) + ai2 * b.getElement(2, 1) + ai3 * b.getElement(3, 1)); // multiply by column(1) of "b"
+            d.setElement(i, 2, ai0 * b.getElement(0, 2) + ai1 * b.getElement(1, 2) + ai2 * b.getElement(2, 2) + ai3 * b.getElement(3, 2)); // multiply by column(2) of "b"
+            d.setElement(i, 3, ai0 * b.getElement(0, 3) + ai1 * b.getElement(1, 3) + ai2 * b.getElement(2, 3) + ai3 * b.getElement(3, 3)); // multiply by column(3) of "b"
+        }
+        /* Return the transform */
+        return d;
+    }
+    /**
+     * Concatenate a transform.
+     * @param transform the transform to concatenate.
+     * @return the combined transformation.
+ */
+    concat(transform) {
+        return Transform.multiply2(this, transform);
+    }
+    /**
+     * Multiply.
+     * @param transform the transform to multiply with.
+ */
+    multiply(transform) {
+        let result = Transform.multiply2(this, transform);
+        this.setElements(result.getElements());
+    }
+    /**
+     * Translate.
+ * @param tx the x translation.
+ * @param ty the y translation.
+ * @param tz the z translation.
+ */
+    translate(tx, ty, tz) {
+        let result = Transform.multiply2(this, Transform.createTranslation(tx, ty, tz));
+        this.setElements(result.getElements());
+    }
+    /**
+     * Translate.
+ * @param point the xyz translation.
+ */
+    translatePoint(point) {
+        this.translate(point.getX(), point.getY(), point.getZ());
+    }
+    /**
+     * Scale.
+ * @param sx the x scale.
+ * @param sy the y scale.
+ * @param sz the z scale.
+ */
+    scale(sx, sy, sz) {
+        let result = Transform.multiply2(this, Transform.createScale(sx, sy, sz));
+        this.setElements(result.getElements());
+    }
+    /**
+     * Scale XYZ.
+ * @param s the scale.
+ */
+    scale3(s) {
+        this.scale(s, s, s);
+    }
+    /**
+     * Create the inverse transform.
+     * @return the inverse transform.
+     */
+    createInverse() {
+        /* Get the 3x3 elements */
+        let a = this.getElement(0, 0);
+        let b = this.getElement(0, 1);
+        let c = this.getElement(0, 2);
+        let d = this.getElement(1, 0);
+        let e = this.getElement(1, 1);
+        let f = this.getElement(1, 2);
+        let g = this.getElement(2, 0);
+        let h = this.getElement(2, 1);
+        let i = this.getElement(2, 2);
+        /* Invert the 3x3 matrix */
+        let idet = 1.0 / (a * (e * i - h * f) - b * (d * i - g * f) + c * (d * h - g * e));
+        let inverse = new Transform();
+        inverse.setElement(0, 0, (e * i - f * h) * idet);
+        inverse.setElement(0, 1, -(b * i - c * h) * idet);
+        inverse.setElement(0, 2, (b * f - c * e) * idet);
+        inverse.setElement(1, 0, -(d * i - f * g) * idet);
+        inverse.setElement(1, 1, (a * i - c * g) * idet);
+        inverse.setElement(1, 2, -(a * f - c * d) * idet);
+        inverse.setElement(2, 0, (d * h - e * g) * idet);
+        inverse.setElement(2, 1, -(a * h - b * g) * idet);
+        inverse.setElement(2, 2, (a * e - b * d) * idet);
+        /* Invert the translation */
+        let t = new Coordinate_1.Coordinate(this.getElement(0, 3), this.getElement(1, 3), this.getElement(2, 3));
+        inverse.transformTo(t, t);
+        inverse.setElement(0, 3, -t.getX());
+        inverse.setElement(1, 3, -t.getY());
+        inverse.setElement(2, 3, -t.getZ());
+        /* Done */
+        return inverse;
+    }
+    /**
+     * Invert.
+ */
+    invert() {
+        let result = this.createInverse();
+        this.setElements(result.getElements());
+    }
+    /**
+     * Create a copy.
+     * @return a copy.
+     */
+    copy() {
+        let copy = new Transform();
+        for (let i = 0; i < 16; i++)
+            copy._elements[i] = this._elements[i];
+        return copy;
+    }
+    /**
+     * Create an identity transform.
+     * @return the transform.
+     */
+    static createIdentity() {
+        return new Transform();
+    }
+    /**
+     * Create a translation transform.
+     * @param tx the x translation.
+     * @param ty the y translation.
+     * @param tz the z translation.
+     * @return the transform.
+     */
+    static createTranslation(tx, ty, tz) {
+        let transform = Transform.createIdentity();
+        transform.setElement(0, 3, tx);
+        transform.setElement(1, 3, ty);
+        transform.setElement(2, 3, tz);
+        return transform;
+    }
+    /**
+     * Create a translation transform.
+     * @param position the translation.
+     * @return the transform.
+     */
+    static createTranslation2(position) {
+        return Transform.createTranslation(position.getX(), position.getY(), position.getZ());
+    }
+    /**
+     * Create a scale transform.
+     * @param sx the x translation.
+     * @param sy the y translation.
+     * @param sz the z translation.
+     * @return the transform.
+     */
+    static createScale(sx, sy, sz) {
+        let transform = Transform.createIdentity();
+        transform.setElement(0, 0, sx);
+        transform.setElement(1, 1, sy);
+        transform.setElement(2, 2, sz);
+        return transform;
+    }
+    /**
+     * Create a rotation-round-X transform.
+     * @param angle the rotation angle (degree).
+     * @return the transform.
+     */
+    static createRotationX(angle) {
+        let rad = (angle / 180.0 * Math.PI);
+        let sin = (angle == 90.0) ? 1.0 : Math.sin(rad);
+        let cos = (angle == 90.0) ? 0.0 : Math.cos(rad);
+        let transform = Transform.createIdentity();
+        transform.setElement(1, 1, cos);
+        transform.setElement(2, 1, sin);
+        transform.setElement(1, 2, -sin);
+        transform.setElement(2, 2, cos);
+        return transform;
+    }
+    /**
+     * Create a rotation-round-Y transform.
+     * @param angle the rotation angle (degree).
+     * @return the transform.
+     */
+    static createRotationY(angle) {
+        let rad = (angle / 180.0 * Math.PI);
+        let sin = Math.sin(rad);
+        let cos = Math.cos(rad);
+        let transform = Transform.createIdentity();
+        transform.setElement(0, 0, cos);
+        transform.setElement(2, 0, -sin);
+        transform.setElement(0, 2, sin);
+        transform.setElement(2, 2, cos);
+        return transform;
+    }
+    /**
+     * Create a rotation-round-Z transform.
+     * @param angle the rotation angle (degree).
+     * @return the transform.
+     */
+    static createRotationZ(angle) {
+        let rad = (angle / 180.0 * Math.PI);
+        let sin = Math.sin(rad);
+        let cos = Math.cos(rad);
+        let transform = Transform.createIdentity();
+        transform.setElement(0, 0, cos);
+        transform.setElement(1, 0, sin);
+        transform.setElement(0, 1, -sin);
+        transform.setElement(1, 1, cos);
+        return transform;
+    }
+    /**
+     * Create a swap YZ transform.
+     * @return the transform.
+     */
+    static createSwapYZ() {
+        let transform = Transform.createIdentity();
+        transform.setElement(1, 1, 0.0);
+        transform.setElement(1, 2, 1.0);
+        transform.setElement(2, 1, 1.0);
+        transform.setElement(2, 2, 0.0);
+        return transform;
+    }
+    /**
+     * Create a transformation from elements.
+     * @param elements the elements (row major order)
+     * @return the transformation.
+     */
+    static createWithElements(elements) {
+        let transform = Transform.createIdentity();
+        transform.setElements(elements);
+        return transform;
+    }
+    /**
+     * Create a transformation from columns.
+     * @param col0 the first column.
+     * @param col1 the second column.
+     * @param col2 the third column.
+     * @param col3 the fourth column (considered zero if null).
+     * @return the transformation.
+     */
+    static createWithColumns(col0, col1, col2, col3) {
+        let transform = Transform.createIdentity();
+        transform.setElement(0, 0, col0.getX());
+        transform.setElement(1, 0, col0.getY());
+        transform.setElement(2, 0, col0.getZ());
+        transform.setElement(0, 1, col1.getX());
+        transform.setElement(1, 1, col1.getY());
+        transform.setElement(2, 1, col1.getZ());
+        transform.setElement(0, 2, col2.getX());
+        transform.setElement(1, 2, col2.getY());
+        transform.setElement(2, 2, col2.getZ());
+        if (col3 != null) {
+            transform.setElement(0, 3, col3.getX());
+            transform.setElement(1, 3, col3.getY());
+            transform.setElement(2, 3, col3.getZ());
+        }
+        return transform;
+    }
+    /**
+     * Create an orthogonal rotation from a quaternion.
+     * @param a the first quaternion element (q1).
+     * @param b the second quaternion element (q2).
+     * @param c the third quaternion element (q3).
+     * @param d the fourth quaternion element (q4).
+     * @return the rotation matrix.
+     */
+    static fromQuaternion(a, b, c, d) {
+        // See "Quaternions and spatial rotation" section "From a quaternion to an orthogonal matrix"
+        // at https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation
+        //
+        /* We should have a unit quaternion */
+        let len = (a * a + b * b + c * c + d * d);
+        /* First row */
+        let m00 = a * a + b * b - c * c - d * d;
+        let m01 = 2.0 * b * c - 2.0 * a * d;
+        let m02 = 2.0 * b * d + 2.0 * a * c;
+        /* Second row */
+        let m10 = 2.0 * b * c + 2.0 * a * d;
+        let m11 = a * a - b * b + c * c - d * d;
+        let m12 = 2.0 * c * d - 2.0 * a * b;
+        /* Third row */
+        let m20 = 2.0 * b * d - 2.0 * a * c;
+        let m21 = 2.0 * c * d + 2.0 * a * b;
+        let m22 = a * a - b * b - c * c + d * d;
+        /* Return the rotation */
+        let transform = new Transform();
+        transform.setElement(0, 0, m00);
+        transform.setElement(0, 1, m01);
+        transform.setElement(0, 2, m02);
+        transform.setElement(1, 0, m10);
+        transform.setElement(1, 1, m11);
+        transform.setElement(1, 2, m12);
+        transform.setElement(2, 0, m20);
+        transform.setElement(2, 1, m21);
+        transform.setElement(2, 2, m22);
+        return transform;
+    }
+    /**
+     * Transform a point.
+     * @param source the source point.
+     * @param target the target point (can be same as source).
+     * @return the target point.
+     */
+    transformTo(source, target) {
+        let sx = source.getX();
+        let sy = source.getY();
+        let sz = source.getZ();
+        target.x = this._elements[0] * sx + this._elements[1] * sy + this._elements[2] * sz + this._elements[3];
+        target.y = this._elements[4] * sx + this._elements[5] * sy + this._elements[6] * sz + this._elements[7];
+        target.z = this._elements[8] * sx + this._elements[9] * sy + this._elements[10] * sz + this._elements[11];
+        return target;
+    }
+    /**
+     * Transform a point.
+     * @param source the source point.
+     * @return the target point.
+     */
+    transform(source) {
+        return this.transformTo(source, Coordinate_1.Coordinate.create());
+    }
+    /**
+     * Transform bounds.
+     * @param bounds the bounds.
+     * @return the transformed bounds.
+     */
+    transformBounds(bounds) {
+        /* Not valid? */
+        if (bounds.isValid() == false)
+            return bounds;
+        /* Transform all corners */
+        let nbounds = new Bounds_1.Bounds();
+        let point = Coordinate_1.Coordinate.create();
+        for (let i = 0; i < 8; i++) {
+            /* Transform the next corner */
+            bounds.getCorner(i, point);
+            this.transformTo(point, point);
+            nbounds.add(point);
+        }
+        /* Return the new bounds */
+        return nbounds;
+    }
+    /**
+     * Check if the transform matches another transform.
+     * @param other the other transform.
+     * @return true if same.
+     */
+    same(other) {
+        for (let i = 0; i < 16; i++)
+            if (this._elements[i] != other._elements[i])
+                return false;
+        return true;
+    }
+    /**
+     * The standard toString method.
+     * @see Object#toString
+     */
+    toString() {
+        return "[Transform:m00=" + this._elements[0] + ",m10=" + this._elements[4] + ",m20=" + this._elements[8] +
+            ",m01=" + this._elements[1] + ",m11=" + this._elements[5] + ",m21=" + this._elements[9] +
+            ",m02=" + this._elements[2] + ",m12=" + this._elements[6] + ",m22=" + this._elements[10] +
+            ",m03=" + this._elements[3] + ",m13=" + this._elements[7] + ",m23=" + this._elements[11] + "]";
+    }
+}
+exports.Transform = Transform;
+//# sourceMappingURL=Transform.js.map