The value that affects the positioning of pixels along the x axis when scaling or rotating an image.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.a);  // 1

myMatrix.a = 2;
trace(myMatrix.a);  // 2

The value that affects the positioning of pixels along the y axis when rotating or skewing an image.

import flash.geom.Matrix;
 
var myMatrix:Matrix = new Matrix();
trace(myMatrix.b);  // 0

var degrees:Number = 30;
var radians:Number = (degrees/180) ~~ Math.PI;
myMatrix.b = Math.tan(radians);
trace(myMatrix.b);  // 0.5773502691896257

The value that affects the positioning of pixels along the x axis when rotating or skewing an image.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.c);  // 0

var degrees:Number = 30;
var radians:Number = (degrees/180) ~~ Math.PI;
myMatrix.c = Math.tan(radians);
trace(myMatrix.c);  // 0.5773502691896257

The value that affects the positioning of pixels along the y axis when scaling or rotating an image.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.d);  // 1

myMatrix.d = 2;
trace(myMatrix.d);  // 2

The distance by which to translate each point along the x axis.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.tx);  // 0

myMatrix.tx = 50;  // 50
trace(myMatrix.tx);

The distance by which to translate each point along the y axis.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.ty);  // 0

myMatrix.ty = 50;
trace(myMatrix.ty);  // 50

Creates a new Matrix object with the specified parameters. In matrix notation, the properties are organized like this:

If you do not provide any parameters to the new Matrix() constructor, it creates an identity matrix with the following values:

a = 1

b = 0

c = 0

d = 1

tx = 0

ty = 0

In matrix notation, the identity matrix looks like this:

import flash.geom.Matrix;

var matrix_1:Matrix = new Matrix();
trace(matrix_1);  // (a=1, b=0, c=0, d=1, tx=0, ty=0)

var matrix_2:Matrix = new Matrix(1, 2, 3, 4, 5, 6);
trace(matrix_2);  // (a=1, b=2, c=3, d=4, tx=5, ty=6)

Returns a new Matrix object that is a clone of this matrix, with an exact copy of the contained object.

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.

For example, if matrix m1 scales an object by a factor of four, and matrix m2 rotates an object by 1.5707963267949 radians (Math.PI/2), then m1.concat(m2) transforms m1 into a matrix that scales an object by a factor of four and rotates the object by Math.PI/2 radians.

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 clone() method, as shown in the Class Examples section.

Copies a Vector3D object into specific column of the calling Matrix3D object.

Copies specific column of the calling Matrix object into the Vector3D object. The w element of the Vector3D object will not be changed.

Copies all of the matrix data from the source Point object into the calling Matrix object.

Copies a Vector3D object into specific row of the calling Matrix object.

Copies specific row of the calling Matrix object into the Vector3D object. The w element of the Vector3D object will not be changed.

Includes parameters for scaling, rotation, and translation. When applied to a matrix it sets the matrix's values based on those parameters.

Using the createBox() method lets you obtain the same matrix as you would if you applied the identity(), rotate(), scale(), and translate() methods in succession. For example, mat1.createBox(2,2,Math.PI/4, 100, 100) has the same effect as the following:

     import flash.geom.Matrix;
          var mat1:Matrix = new Matrix();
     mat1.identity();
     mat1.rotate(Math.PI/4);
     mat1.scale(2,2);
     mat1.translate(10,20);
     

     var mat1 = new air.Matrix();
     mat1.identity();
     mat1.rotate(Math.PI/4);
     mat1.scale(2, 2);
     mat1.translate(10, 20);
     

See also

package
{
    import flash.display.Shape;
	import flash.display.Sprite;
	import flash.geom.Matrix;
	import flash.geom.Transform;
	
	public class Matrix_createBox extends Sprite
	{
		public function Matrix_createBox()
		{
		     var myMatrix:Matrix = new Matrix();
		     trace(myMatrix.toString());  // (a=1, b=0, c=0, d=1, tx=0, ty=0)
		     
		     myMatrix.createBox(1, 2, Math.PI/4, 50, 100);
		     trace(myMatrix.toString());  
		     // (a=0.7071067811865476, b=1.414213562373095, c=-0.7071067811865475, 
		     //  d=1.4142135623730951, tx=50, ty=100)
		     
		     var rectangleShape:Shape = createRectangle(20, 80, 0xFF0000);   
		     addChild(rectangleShape);
		      
		     var rectangleTrans:Transform = new Transform(rectangleShape);
		     rectangleTrans.matrix = myMatrix;
		}
		
		public function createRectangle(w:Number, h:Number, color:Number):Shape 
		{
			var rect:Shape = new Shape();
			rect.graphics.beginFill(color);
			rect.graphics.drawRect(0, 0, w, h);
			addChild(rect);
			return rect;
		}
	}
}

Creates the specific style of matrix expected by the beginGradientFill() and lineGradientStyle() methods of the Graphics class. Width and height are scaled to a scaleX/scaleY pair and the tx/ty values are offset by half the width and height.

For example, consider a gradient with the following characteristics:

• GradientType.LINEAR
• Two colors, green and blue, with the ratios array set to [0, 255]
• SpreadMethod.PAD
• InterpolationMethod.LINEAR_RGB

The following illustrations show gradients in which the matrix was defined using the createGradientBox() method with different parameter settings:

createGradientBox() settings	Resulting gradient
width = 25; height = 25; rotation = 0; tx = 0; ty = 0;
width = 25; height = 25; rotation = 0; tx = 25; ty = 0;
width = 50; height = 50; rotation = 0; tx = 0; ty = 0;
width = 50; height = 50; rotation = Math.PI / 4; // 45 degrees tx = 0; ty = 0;

See also

package
{
    import flash.display.GradientType;
	import flash.display.Sprite;
	import flash.geom.Matrix;
	
	public class Matrix_createGradientBox extends Sprite
	{
		public function Matrix_createGradientBox()
		{
		     var myMatrix:Matrix = new Matrix();
		     trace(myMatrix.toString());          // (a=1, b=0, c=0, d=1, tx=0, ty=0)
		     
		     myMatrix.createGradientBox(200, 200, 0, 50, 50);
		     trace(myMatrix.toString());          // (a=0.1220703125, b=0, c=0, d=0.1220703125, tx=150, ty=150)
		     
		     var colors:Array = [0xFF0000, 0x0000FF];
		     var alphas:Array = [100, 100];
		     var ratios:Array = [0, 0xFF];
		     
		     this.graphics.beginGradientFill(GradientType.LINEAR, colors, alphas, ratios, myMatrix);
		     this.graphics.drawRect(0, 0, 300, 200);
		}
	}
}

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 transformPoint() method, the deltaTransformPoint() method's transformation does not consider the translation parameters tx and ty.

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 transformPoint() method, the deltaTransformPoint() method's transformation does not consider the translation parameters tx and ty.

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.

After calling the identity() method, the resulting matrix has the following properties: a=1, b=0, c=0, d=1, tx=0, ty=0.

In matrix notation, the identity matrix looks like this:

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.

package
{
    import flash.display.Shape;
	import flash.display.Sprite;
	import flash.geom.Matrix;
	import flash.geom.Transform;
	
	public class Matrix_invert extends Sprite
	{
		public function Matrix_invert()
		{
			var rect0:Shape = createRectangle(20, 80, 0xFF0000);   
			var rect1:Shape = createRectangle(20, 80, 0x00FF00);   
			var rect2:Shape = createRectangle(20, 80, 0x0000FF);
			var rect3:Shape = createRectangle(20, 80, 0x000000);
			
			var trans0:Transform = new Transform(rect0);
			var trans1:Transform = new Transform(rect1);
			var trans2:Transform = new Transform(rect2);
			var trans3:Transform = new Transform(rect3);
			 
			var doubleScaleMatrix:Matrix = new Matrix(2, 0, 0, 2, 0, 0);
			trans0.matrix = doubleScaleMatrix;
			trace(doubleScaleMatrix.toString());  // (a=2, b=0, c=0, d=2, tx=0, ty=0)
			 
			var noScaleMatrix:Matrix = new Matrix(1, 0, 0, 1, 0, 0);
			trans1.matrix = noScaleMatrix;
			rect1.x = 50;
			trace(noScaleMatrix.toString());  // (a=1, b=0, c=0, d=1, tx=0, ty=0)
			 
			var halfScaleMatrix:Matrix = doubleScaleMatrix.clone();
			halfScaleMatrix.invert();
			trans2.matrix = halfScaleMatrix;
			rect2.x = 100;
			trace(halfScaleMatrix.toString());  // (a=0.5, b=0, c=0, d=0.5, tx=0, ty=0)
			 
			var originalAndInverseMatrix:Matrix = doubleScaleMatrix.clone();
			originalAndInverseMatrix.concat(halfScaleMatrix);
			trans3.matrix = originalAndInverseMatrix;
			rect3.x = 150;
			trace(originalAndInverseMatrix.toString());  // (a=1, b=0, c=0, d=1, tx=0, ty=0)			
		}
		
		public function createRectangle(w:Number, h:Number, color:Number):Shape 
		{
			var rect:Shape = new Shape();
			rect.graphics.beginFill(color);
			rect.graphics.drawRect(0, 0, w, h);
			addChild(rect);
			return rect;
		}
	}
}

Applies a rotation transformation to the Matrix object.

The rotate() method alters the a, b, c, and d properties of the Matrix object. In matrix notation, this is the same as concatenating the current matrix with the following:

Applies a scaling transformation to the matrix. The x axis is multiplied by sx, and the y axis it is multiplied by sy.

The scale() method alters the a and d properties of the Matrix object. In matrix notation, this is the same as concatenating the current matrix with the following matrix:

Sets the members of Matrix to the specified values

Returns a text value listing the properties of the Matrix object.

Returns the result of applying the geometric transformation represented by the Matrix object to the specified point.

Returns the result of applying the geometric transformation represented by the Matrix object to the specified point.

Translates the matrix along the x and y axes, as specified by the dx and dy parameters.

1. The application creates a new Matrix object myMatrix, and it uses the trace() method to output the default property values for the myMatrix object.
2. The application calls the createGradientBox() with the width and height parameters set to 200 pixels, no rotation, and the distance to translate along the x and y axes set to 50 pixels.
3. The application prints the myMatrix object again to show the change after calling createGradientBox().
4. The application sets up three variables to control how the gradient box is filled:
   • colors: Sets the gradient colors to range between solid red and solid blue.
   • alphas: Sets the opacity to solid.
   • ratios: Sets the distribution of the colors to be equal for both red and blue.
5. The application calls the graphics method beginGradientFill(), which operates on the myMatrix object, and it calls the lineTo() method, resulting in the gradient-filled box.

package {
	import flash.geom.Matrix;
	import flash.display.Sprite;
	import flash.display.GradientType;

	public class MatrixExample extends Sprite {

		public function MatrixExample() {
			var myMatrix:Matrix = new Matrix();
			trace(myMatrix.toString());    // (a=1, b=0, c=0, d=1, tx=0, ty=0)

			myMatrix.createGradientBox(200, 200, 0, 50, 50);
			trace(myMatrix.toString());    // (a=0.1220703125, b=0, c=0, d=0.1220703125, tx=150, ty=150)

			var colors:Array = [0xFF0000, 0x0000FF];
			var alphas:Array = [1, 1];
			var ratios:Array = [0, 0xFF];
			graphics.beginGradientFill(GradientType.LINEAR, colors, alphas, ratios, myMatrix);
			graphics.lineTo(0, 300);
			graphics.lineTo(300, 300);
			graphics.lineTo(300, 0);
			graphics.lineTo(0, 0);
		}
	}
}