@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/geom/Matrix.js

@@ -0,0 +1,414 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+import { Matrix as AwayMatrix } from '@awayjs/core';
+var Matrix = /** @class */ (function (_super) {
+    __extends(Matrix, _super);
+    /**
+   * Creates a new Matrix object with the specified parameters. In matrix
+   * notation, the properties are organized like this:
+   *
+   * <p>If you do not provide any parameters to the <code>new Matrix()</code>
+   * constructor, it creates an <i>identity matrix</i> with the following
+   * values:</p>
+   *
+   * <p>In matrix notation, the identity matrix looks like this:</p>
+   *
+   * @param a  The value that affects the positioning of pixels along the
+   *           <i>x</i> axis when scaling or rotating an image.
+   * @param b  The value that affects the positioning of pixels along the
+   *           <i>y</i> axis when rotating or skewing an image.
+   * @param c  The value that affects the positioning of pixels along the
+   *           <i>x</i> axis when rotating or skewing an image.
+   * @param d  The value that affects the positioning of pixels along the
+   *           <i>y</i> axis when scaling or rotating an image..
+   * @param tx The distance by which to translate each point along the <i>x</i>
+   *           axis.
+   * @param ty The distance by which to translate each point along the <i>y</i>
+   *           axis.
+   */
+    function Matrix(aAdaptee, b, c, d, tx, ty) {
+        if (aAdaptee === void 0) { aAdaptee = 1; }
+        if (b === void 0) { b = 0; }
+        if (c === void 0) { c = 0; }
+        if (d === void 0) { d = 1; }
+        if (tx === void 0) { tx = 0; }
+        if (ty === void 0) { ty = 0; }
+        var _this = _super.call(this) || this;
+        _this._adaptee = (aAdaptee instanceof AwayMatrix) ? aAdaptee : new AwayMatrix(+aAdaptee, +b, +c, +d, +tx, +ty);
+        return _this;
+    }
+    Matrix.classInitializer = function () {
+        this.FROZEN_IDENTITY_MATRIX = Object.freeze(this.axConstruct([]));
+        this.TEMP_MATRIX = this.axConstruct([]);
+    };
+    Object.defineProperty(Matrix.prototype, "adaptee", {
+        // "invert", "identity", "createBox",
+        // "createGradientBox", "rotate", "translate",
+        // "scale", "deltaTransformPoint", "transformPoint",
+        // "copyFrom", "setTo", "copyRowTo", "copyColumnTo",
+        // "copyRowFrom", "copyColumnFrom", "clone",
+        // "toString"];
+        get: function () {
+            return this._adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Matrix.prototype, "a", {
+        /**
+       * The value that affects the positioning of pixels along the <i>x</i> axis
+       * when scaling or rotating an image.
+       */
+        get: function () {
+            return this._adaptee.rawData[0];
+        },
+        set: function (value) {
+            this._adaptee.rawData[0] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Matrix.prototype, "b", {
+        /**
+       * The value that affects the positioning of pixels along the <i>y</i> axis
+       * when rotating or skewing an image.
+       */
+        get: function () {
+            return this._adaptee.rawData[1];
+        },
+        set: function (value) {
+            this._adaptee.rawData[1] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Matrix.prototype, "c", {
+        /**
+       * The value that affects the positioning of pixels along the <i>x</i> axis
+       * when rotating or skewing an image.
+       */
+        get: function () {
+            return this._adaptee.rawData[2];
+        },
+        set: function (value) {
+            this._adaptee.rawData[2] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Matrix.prototype, "d", {
+        /**
+       * The value that affects the positioning of pixels along the <i>y</i> axis
+       * when scaling or rotating an image.
+       */
+        get: function () {
+            return this._adaptee.rawData[3];
+        },
+        set: function (value) {
+            this._adaptee.rawData[3] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Matrix.prototype, "tx", {
+        /**
+       * The distance by which to translate each point along the <i>x</i> axis.
+       */
+        get: function () {
+            return this._adaptee.rawData[4];
+        },
+        set: function (value) {
+            this._adaptee.rawData[4] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Matrix.prototype, "ty", {
+        /**
+       * The distance by which to translate each point along the <i>y</i> axis.
+       */
+        get: function () {
+            return this._adaptee.rawData[5];
+        },
+        set: function (value) {
+            this._adaptee.rawData[5] = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Matrix.FromUntyped = function (object) {
+        return new this.sec.flash.geom.Matrix(object.a, object.b, object.c, object.d, object.tx, object.ty);
+    };
+    // Keep in sync with writeExternal below!
+    Matrix.FromDataBuffer = function (input) {
+        return new this.sec.flash.geom.Matrix(input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat());
+    };
+    /**
+   * Concatenates a matrix with the current matrix, effectively combining the
+   * geometric effects of the two. In mathematical terms, concatenating two
+   * matrixes is the same as combining them using matrix multiplication.
+   *
+   * <p>For example, if matrix <code>m1</code> scales an object by a factor of
+   * four, and matrix <code>m2</code> rotates an object by 1.5707963267949
+   * radians(<code>Math.PI/2</code>), then <code>m1.concat(m2)</code>
+   * transforms <code>m1</code> into a matrix that scales an object by a factor
+   * of four and rotates the object by <code>Math.PI/2</code> radians. </p>
+   *
+   * <p>This method replaces the source matrix with the concatenated matrix. If
+   * you want to concatenate two matrixes without altering either of the two
+   * source matrixes, first copy the source matrix by using the
+   * <code>clone()</code> method, as shown in the Class Examples section.</p>
+   *
+   * @param matrix The matrix to be concatenated to the source matrix.
+   */
+    Matrix.prototype.concat = function (other) {
+        this._adaptee.concat(other.adaptee);
+    };
+    /**
+   * Performs the opposite transformation of the original matrix. You can apply
+   * an inverted matrix to an object to undo the transformation performed when
+   * applying the original matrix.
+   */
+    Matrix.prototype.invert = function () {
+        this._adaptee.invert();
+    };
+    /**
+   * Sets each matrix property to a value that causes a null transformation. An
+   * object transformed by applying an identity matrix will be identical to the
+   * original.
+   *
+   * <p>After calling the <code>identity()</code> method, the resulting matrix
+   * has the following properties: <code>a</code>=1, <code>b</code>=0,
+   * <code>c</code>=0, <code>d</code>=1, <code>tx</code>=0,
+   * <code>ty</code>=0.</p>
+   *
+   * <p>In matrix notation, the identity matrix looks like this:</p>
+   *
+   */
+    Matrix.prototype.identity = function () {
+        this._adaptee.identity();
+    };
+    /**
+   * Includes parameters for scaling, rotation, and translation. When applied
+   * to a matrix it sets the matrix's values based on those parameters.
+   *
+   * <p>Using the <code>createBox()</code> method lets you obtain the same
+   * matrix as you would if you applied the <code>identity()</code>,
+   * <code>rotate()</code>, <code>scale()</code>, and <code>translate()</code>
+   * methods in succession. For example, <code>mat1.createBox(2,2,Math.PI/4,
+   * 100, 100)</code> has the same effect as the following:</p>
+   *
+   * @param scaleX   The factor by which to scale horizontally.
+   * @param scaleY   The factor by which scale vertically.
+   * @param rotation The amount to rotate, in radians.
+   * @param tx       The number of pixels to translate(move) to the right
+   *                 along the <i>x</i> axis.
+   * @param ty       The number of pixels to translate(move) down along the
+   *                 <i>y</i> axis.
+   */
+    Matrix.prototype.createBox = function (scaleX, scaleY, rotation, tx, ty) {
+        if (rotation === void 0) { rotation = 0; }
+        if (tx === void 0) { tx = 0; }
+        if (ty === void 0) { ty = 0; }
+        this._adaptee.createBox(scaleX, scaleY, rotation, tx, ty);
+    };
+    /**
+   * Creates the specific style of matrix expected by the
+   * <code>beginGradientFill()</code> and <code>lineGradientStyle()</code>
+   * methods of the Graphics class. Width and height are scaled to a
+   * <code>scaleX</code>/<code>scaleY</code> pair and the
+   * <code>tx</code>/<code>ty</code> values are offset by half the width and
+   * height.
+   *
+   * <p>For example, consider a gradient with the following
+   * characteristics:</p>
+   *
+   * <ul>
+   *   <li><code>GradientType.LINEAR</code></li>
+   *   <li>Two colors, green and blue, with the ratios array set to <code>[0,
+   * 255]</code></li>
+   *   <li><code>SpreadMethod.PAD</code></li>
+   *   <li><code>InterpolationMethod.LINEAR_RGB</code></li>
+   * </ul>
+   *
+   * <p>The following illustrations show gradients in which the matrix was
+   * defined using the <code>createGradientBox()</code> method with different
+   * parameter settings:</p>
+   *
+   * @param width    The width of the gradient box.
+   * @param height   The height of the gradient box.
+   * @param rotation The amount to rotate, in radians.
+   * @param tx       The distance, in pixels, to translate to the right along
+   *                 the <i>x</i> axis. This value is offset by half of the
+   *                 <code>width</code> parameter.
+   * @param ty       The distance, in pixels, to translate down along the
+   *                 <i>y</i> axis. This value is offset by half of the
+   *                 <code>height</code> parameter.
+   */
+    Matrix.prototype.createGradientBox = function (width, height, rotation, tx, ty) {
+        if (rotation === void 0) { rotation = 0; }
+        if (tx === void 0) { tx = 0; }
+        if (ty === void 0) { ty = 0; }
+        this._adaptee.createGradientBox(width, height, rotation, tx, ty);
+    };
+    /**
+   * Applies a rotation transformation to the Matrix object.
+   *
+   * <p>The <code>rotate()</code> method alters the <code>a</code>,
+   * <code>b</code>, <code>c</code>, and <code>d</code> properties of the
+   * Matrix object. In matrix notation, this is the same as concatenating the
+   * current matrix with the following:</p>
+   *
+   * @param angle The rotation angle in radians.
+   */
+    Matrix.prototype.rotate = function (angle) {
+        this._adaptee.rotate(angle);
+    };
+    /**
+   * Translates the matrix along the <i>x</i> and <i>y</i> axes, as specified
+   * by the <code>dx</code> and <code>dy</code> parameters.
+   *
+   * @param dx The amount of movement along the <i>x</i> axis to the right, in
+   *           pixels.
+   * @param dy The amount of movement down along the <i>y</i> axis, in pixels.
+   */
+    Matrix.prototype.translate = function (dx, dy) {
+        this._adaptee.translate(dx, dy);
+    };
+    /**
+   * Applies a scaling transformation to the matrix. The <i>x</i> axis is
+   * multiplied by <code>sx</code>, and the <i>y</i> axis it is multiplied by
+   * <code>sy</code>.
+   *
+   * <p>The <code>scale()</code> method alters the <code>a</code> and
+   * <code>d</code> properties of the Matrix object. In matrix notation, this
+   * is the same as concatenating the current matrix with the following
+   * matrix:</p>
+   *
+   * @param sx A multiplier used to scale the object along the <i>x</i> axis.
+   * @param sy A multiplier used to scale the object along the <i>y</i> axis.
+   */
+    Matrix.prototype.scale = function (sx, sy) {
+        this._adaptee.scale(sx, sy);
+    };
+    /**
+   * Given a point in the pretransform coordinate space, returns the
+   * coordinates of that point after the transformation occurs. Unlike the
+   * standard transformation applied using the <code>transformPoint()</code>
+   * method, the <code>deltaTransformPoint()</code> method's transformation
+   * does not consider the translation parameters <code>tx</code> and
+   * <code>ty</code>.
+   *
+   * @param point The point for which you want to get the result of the matrix
+   *              transformation.
+   * @return The point resulting from applying the matrix transformation.
+   */
+    Matrix.prototype.deltaTransformPoint = function (point) {
+        return new this.sec.flash.geom.Point(this._adaptee.deltaTransformPoint(point.adaptee));
+    };
+    /**
+   * Returns the result of applying the geometric transformation represented by
+   * the Matrix object to the specified point.
+   *
+   * @param point The point for which you want to get the result of the Matrix
+   *              transformation.
+   * @return The point resulting from applying the Matrix transformation.
+   */
+    Matrix.prototype.transformPoint = function (point) {
+        return new this.sec.flash.geom.Point(this._adaptee.transformPoint(point.adaptee));
+    };
+    /**
+   * Copies all of the matrix data from the source Point object into the
+   * calling Matrix object.
+   *
+   * @param sourceMatrix The Matrix object from which to copy the data.
+   */
+    Matrix.prototype.copyFrom = function (sourceMatrix) {
+        this._adaptee.copyFrom(sourceMatrix.adaptee);
+    };
+    /**
+   * Sets the members of Matrix to the specified values.
+   *
+   * @param a  The value that affects the positioning of pixels along the
+   *           <i>x</i> axis when scaling or rotating an image.
+   * @param b  The value that affects the positioning of pixels along the
+   *           <i>y</i> axis when rotating or skewing an image.
+   * @param c  The value that affects the positioning of pixels along the
+   *           <i>x</i> axis when rotating or skewing an image.
+   * @param d  The value that affects the positioning of pixels along the
+   *           <i>y</i> axis when scaling or rotating an image..
+   * @param tx The distance by which to translate each point along the <i>x</i>
+   *           axis.
+   * @param ty The distance by which to translate each point along the <i>y</i>
+   *           axis.
+   */
+    Matrix.prototype.setTo = function (a, b, c, d, tx, ty) {
+        this._adaptee.setTo(a, b, c, d, tx, ty);
+    };
+    /**
+   * Copies specific row of the calling Matrix object into the Vector3D object.
+   * The w element of the Vector3D object will not be changed.
+   *
+   * @param row      The row from which to copy the data from.
+   * @param vector3D The Vector3D object from which to copy the data.
+   */
+    Matrix.prototype.copyRowTo = function (row, vector3D) {
+        this._adaptee.copyRowTo(row, vector3D.adaptee);
+    };
+    /**
+   * Copies specific column of the calling Matrix object into the Vector3D
+   * object. The w element of the Vector3D object will not be changed.
+   *
+   * @param column   The column from which to copy the data from.
+   * @param vector3D The Vector3D object from which to copy the data.
+   */
+    Matrix.prototype.copyColumnTo = function (column, vector3D) {
+        this._adaptee.copyColumnTo(column, vector3D.adaptee);
+    };
+    /**
+     * Copies a Vector3D object into specific row of the calling Matrix object.
+     *
+     * @param row      The row from which to copy the data from.
+     * @param vector3D The Vector3D object from which to copy the data.
+     */
+    Matrix.prototype.copyRowFrom = function (row, vector3D) {
+        this._adaptee.copyRowFrom(row, vector3D.adaptee);
+    };
+    /**
+     * Copies a Vector3D object into specific column of the calling Matrix3D
+     * object.
+     *
+     * @param column   The column from which to copy the data from.
+     * @param vector3D The Vector3D object from which to copy the data.
+     */
+    Matrix.prototype.copyColumnFrom = function (column, vector3D) {
+        this._adaptee.copyColumnFrom(column, vector3D.adaptee);
+    };
+    /**
+     * Returns a new Matrix object that is a clone of this matrix, with an exact
+     * copy of the contained object.
+     *
+     * @return A Matrix object.
+     */
+    Matrix.prototype.clone = function () {
+        return new this.sec.flash.geom.Matrix(this._adaptee.clone());
+    };
+    Matrix.prototype.toString = function () {
+        var m = this._adaptee.rawData;
+        return '(a=' + m[0] + ', b=' + m[1] + ', c=' + m[2] + ', d=' + m[3] + ', tx=' + m[4] + ', ty=' + m[5] + ')';
+    };
+    // Keep in sync with static FromDataBuffer above!
+    Matrix.prototype.writeExternal = function (output) {
+        var m = this._adaptee.rawData;
+        output.writeFloat(m[0]);
+        output.writeFloat(m[1]);
+        output.writeFloat(m[2]);
+        output.writeFloat(m[3]);
+        output.writeFloat(m[4]);
+        output.writeFloat(m[5]);
+    };
+    Matrix.classSymbols = null; // [];
+    Matrix.instanceSymbols = null; // ["a", "b", "c", "d", "tx", "ty", "concat",
+    return Matrix;
+}(ASObject));
+export { Matrix };

package/dist/lib/geom/Matrix3D.d.ts

@@ -0,0 +1,45 @@
+import { Vector3D } from './Vector3D';
+import { ASObject } from '@awayfl/avm2';
+import { Matrix3D as AwayMatrix3D } from '@awayjs/core';
+import { Float64Vector, GenericVector } from '@awayfl/avm2';
+export declare class Matrix3D extends ASObject {
+    private _adaptee;
+    static classInitializer: any;
+    static axClass: typeof Matrix3D;
+    get adaptee(): AwayMatrix3D;
+    constructor(v?: Float64Vector | AwayMatrix3D);
+    static interpolate(thisMat: Matrix3D, toMat: Matrix3D, percent: number): Matrix3D;
+    get rawData(): Float64Vector;
+    set rawData(v: Float64Vector);
+    get position(): Vector3D;
+    set position(pos: Vector3D);
+    get determinant(): number;
+    clone(): Matrix3D;
+    copyToMatrix3D(dest: Matrix3D): void;
+    append(lhs: Matrix3D): void;
+    prepend(rhs: Matrix3D): void;
+    invert(): boolean;
+    identity(): void;
+    decompose(orientationStyle?: string): GenericVector;
+    recompose(components: Float64Vector, orientationStyle?: string): boolean;
+    appendTranslation(x: number, y: number, z: number): void;
+    appendRotation(degrees: number, axis: Vector3D, pivotPoint?: Vector3D): void;
+    appendScale(xScale: number, yScale: number, zScale: number): void;
+    prependTranslation(x: number, y: number, z: number): void;
+    prependRotation(degrees: number, axis: Vector3D, pivotPoint?: Vector3D): void;
+    prependScale(xScale: number, yScale: number, zScale: number): void;
+    transformVector(v: Vector3D): Vector3D;
+    deltaTransformVector(v: Vector3D): Vector3D;
+    transformVectors(vin: Float64Vector, vout: Float64Vector): void;
+    transpose(): void;
+    pointAt(pos: Vector3D, at?: Vector3D, up?: Vector3D): void;
+    interpolateTo(toMat: Matrix3D, percent: number): void;
+    copyFrom(sourceMatrix3D: Matrix3D): void;
+    copyRawDataTo(vector: Float64Vector, index?: number, transpose?: boolean): void;
+    copyRawDataFrom(vector: Float64Vector, index?: number, transpose?: boolean): void;
+    copyRowTo(row: number, vector3D: Vector3D): void;
+    copyColumnTo(column: number, vector3D: Vector3D): void;
+    copyRowFrom(row: number, vector3D: Vector3D): void;
+    copyColumnFrom(column: number, vector3D: Vector3D): void;
+}
+//# sourceMappingURL=Matrix3D.d.ts.map

package/dist/lib/geom/Matrix3D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Matrix3D.d.ts","sourceRoot":"","sources":["../../../lib/geom/Matrix3D.ts"],"names":[],"mappings":"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"}

package/dist/lib/geom/Matrix3D.js

@@ -0,0 +1,213 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+import { notImplemented, release, somewhatImplemented } from '@awayfl/swf-loader';
+import { axCoerceString } from '@awayjs/graphics';
+import { Matrix3D as AwayMatrix3D } from '@awayjs/core';
+/*
+  * _matrix stores data by columns
+  *  | 0  4  8  12 |
+  *  | 1  5  9  13 |
+  *  | 2  6 10  14 |
+  *  | 3  7 11  15 |
+  */
+var transposeTransform = new Uint32Array([
+    0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15
+]);
+var Matrix3D = /** @class */ (function (_super) {
+    __extends(Matrix3D, _super);
+    function Matrix3D(v) {
+        if (v === void 0) { v = null; }
+        var _this = _super.call(this) || this;
+        if (v instanceof AwayMatrix3D) {
+            _this._adaptee = v;
+        }
+        else {
+            _this._adaptee = new AwayMatrix3D();
+            if (v && v.length >= 16) {
+                _this.copyRawDataFrom(v, 0, false);
+            }
+            else {
+                _this.identity();
+            }
+        }
+        return _this;
+    }
+    Object.defineProperty(Matrix3D.prototype, "adaptee", {
+        get: function () {
+            return this._adaptee;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Matrix3D.interpolate = function (thisMat, toMat, percent) {
+        percent = +percent;
+        release || notImplemented('public flash.geom.Matrix3D::static interpolate');
+        return;
+    };
+    Object.defineProperty(Matrix3D.prototype, "rawData", {
+        get: function () {
+            var result = new this.sec.Float64Vector();
+            this.copyRawDataTo(result, 0, false);
+            return result;
+        },
+        set: function (v) {
+            this.copyRawDataFrom(v, 0, false);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Matrix3D.prototype, "position", {
+        get: function () {
+            return new this.sec.flash.geom.Vector3D(this._adaptee.position);
+        },
+        set: function (pos) {
+            this.copyColumnFrom(3, pos);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Matrix3D.prototype, "determinant", {
+        get: function () {
+            return this._adaptee.determinant;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Matrix3D.prototype.clone = function () {
+        return new this.sec.flash.geom.Matrix3D(this._adaptee.clone());
+    };
+    Matrix3D.prototype.copyToMatrix3D = function (dest) {
+        this._adaptee.copyTo(dest.adaptee);
+    };
+    Matrix3D.prototype.append = function (lhs) {
+        this._adaptee.append(lhs.adaptee);
+    };
+    Matrix3D.prototype.prepend = function (rhs) {
+        this._adaptee.prepend(rhs.adaptee);
+    };
+    Matrix3D.prototype.invert = function () {
+        return this._adaptee.invert();
+    };
+    Matrix3D.prototype.identity = function () {
+        this._adaptee.identity();
+    };
+    Matrix3D.prototype.decompose = function (orientationStyle) {
+        if (orientationStyle === void 0) { orientationStyle = 'eulerAngles'; }
+        var array = this._adaptee.decompose(axCoerceString(orientationStyle));
+        var v = new this.sec.ObjectVector(3, true);
+        for (var i = 0; i < 3; i++)
+            v.axSetNumericProperty(i, new this.sec.flash.geom.Vector3D(array[i]));
+        return v;
+    };
+    Matrix3D.prototype.recompose = function (components, orientationStyle) {
+        if (orientationStyle === void 0) { orientationStyle = 'eulerAngles'; }
+        //this._adaptee.recompose()
+        orientationStyle = axCoerceString(orientationStyle);
+        release || notImplemented('public flash.geom.Matrix3D::recompose');
+        return;
+    };
+    Matrix3D.prototype.appendTranslation = function (x, y, z) {
+        this._adaptee.appendTranslation(+x, +y, +z);
+    };
+    Matrix3D.prototype.appendRotation = function (degrees, axis, pivotPoint) {
+        if (pivotPoint === void 0) { pivotPoint = null; }
+        release || somewhatImplemented('public flash.geom.Matrix3D::appendRotation');
+        this._adaptee.appendRotation(+degrees, axis.adaptee);
+    };
+    Matrix3D.prototype.appendScale = function (xScale, yScale, zScale) {
+        this._adaptee.appendScale(+xScale, +yScale, +zScale);
+    };
+    Matrix3D.prototype.prependTranslation = function (x, y, z) {
+        this._adaptee.prependTranslation(+x, +y, +z);
+    };
+    Matrix3D.prototype.prependRotation = function (degrees, axis, pivotPoint) {
+        if (pivotPoint === void 0) { pivotPoint = null; }
+        release || somewhatImplemented('public flash.geom.Matrix3D::prependRotation');
+        this._adaptee.prependRotation(+degrees, axis.adaptee);
+    };
+    Matrix3D.prototype.prependScale = function (xScale, yScale, zScale) {
+        this._adaptee.prependScale(+xScale, +yScale, +zScale);
+    };
+    Matrix3D.prototype.transformVector = function (v) {
+        return new this.sec.flash.geom.Vector3D(this._adaptee.transformVector(v.adaptee, null, true));
+    };
+    Matrix3D.prototype.deltaTransformVector = function (v) {
+        return new this.sec.flash.geom.Vector3D(this._adaptee.deltaTransformVector(v.adaptee));
+    };
+    Matrix3D.prototype.transformVectors = function (vin, vout) {
+        var m = this._adaptee._rawData;
+        var m11 = m[0], m12 = m[4], m13 = m[8], m14 = m[12], m21 = m[1], m22 = m[5], m23 = m[9], m24 = m[13], m31 = m[2], m32 = m[6], m33 = m[10], m34 = m[14];
+        for (var i = 0; i < vin.length - 2; i += 3) {
+            var x = vin.axGetNumericProperty(i), y = vin.axGetNumericProperty(i + 1), z = vin.axGetNumericProperty(i + 2);
+            vout.push(m11 * x + m12 * y + m13 * z + m14);
+            vout.push(m21 * x + m22 * y + m23 * z + m24);
+            vout.push(m31 * x + m32 * y + m33 * z + m34);
+        }
+    };
+    Matrix3D.prototype.transpose = function () {
+        this._adaptee.transpose();
+    };
+    Matrix3D.prototype.pointAt = function (pos, at, up) {
+        if (at === void 0) { at = null; }
+        if (up === void 0) { up = null; }
+        release || notImplemented('public flash.geom.Matrix3D::pointAt');
+        return;
+    };
+    Matrix3D.prototype.interpolateTo = function (toMat, percent) {
+        percent = +percent;
+        release || notImplemented('public flash.geom.Matrix3D::interpolateTo');
+        return;
+    };
+    Matrix3D.prototype.copyFrom = function (sourceMatrix3D) {
+        this._adaptee.copyFrom(sourceMatrix3D.adaptee);
+    };
+    Matrix3D.prototype.copyRawDataTo = function (vector, index, transpose) {
+        if (index === void 0) { index = 0; }
+        if (transpose === void 0) { transpose = false; }
+        index = index >>> 0;
+        transpose = !!transpose;
+        var m = this._adaptee._rawData;
+        if (transpose) {
+            for (var i = 0, j = index | 0; i < 16; i++, j++) {
+                vector.axSetNumericProperty(j, m[transposeTransform[i]]);
+            }
+        }
+        else {
+            for (var i = 0, j = index | 0; i < 16; i++, j++) {
+                vector.axSetNumericProperty(j, m[i]);
+            }
+        }
+    };
+    Matrix3D.prototype.copyRawDataFrom = function (vector, index, transpose) {
+        if (index === void 0) { index = 0; }
+        if (transpose === void 0) { transpose = false; }
+        index = index >>> 0;
+        transpose = !!transpose;
+        var m = this._adaptee._rawData;
+        if (transpose) {
+            for (var i = 0, j = index | 0; i < 16; i++, j++) {
+                m[transposeTransform[i]] = vector.axGetNumericProperty(j) || 0; // removing NaN
+            }
+        }
+        else {
+            for (var i = 0, j = index | 0; i < 16; i++, j++) {
+                m[i] = vector.axGetNumericProperty(j) || 0; // removing NaN
+            }
+        }
+    };
+    Matrix3D.prototype.copyRowTo = function (row /*uint*/, vector3D) {
+        this._adaptee.copyRowTo(row >>> 0, vector3D.adaptee);
+    };
+    Matrix3D.prototype.copyColumnTo = function (column /*uint*/, vector3D) {
+        this._adaptee.copyColumnTo(column >>> 0, vector3D.adaptee);
+    };
+    Matrix3D.prototype.copyRowFrom = function (row /*uint*/, vector3D) {
+        this._adaptee.copyRowFrom(row >>> 0, vector3D.adaptee);
+    };
+    Matrix3D.prototype.copyColumnFrom = function (column /*uint*/, vector3D) {
+        this._adaptee.copyColumnFrom(column >>> 0, vector3D.adaptee);
+    };
+    Matrix3D.classInitializer = null;
+    return Matrix3D;
+}(ASObject));
+export { Matrix3D };

package/dist/lib/geom/PerspectiveProjection.d.ts

@@ -0,0 +1,2 @@
+export { PerspectiveProjection } from '@awayjs/core';
+//# sourceMappingURL=PerspectiveProjection.d.ts.map

package/dist/lib/geom/PerspectiveProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerspectiveProjection.d.ts","sourceRoot":"","sources":["../../../lib/geom/PerspectiveProjection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC"}