Matrix  - AS3

O valor afeta o posicionamento dos pixels ao longo do eixo x ao rotacionar ou dimensionar a escala de uma imagem.

import flash.geom.Matrix;

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

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

O valor afeta o posicionamento dos pixels ao longo do eixo y ao rotacionar ou inclinar uma imagem.

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

O valor afeta o posicionamento dos pixels ao longo do eixo x ao rotacionar ou inclinar uma imagem.

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

O valor afeta o posicionamento dos pixels ao longo do eixo y ao rotacionar ou dimensionar a escala de uma imagem.

import flash.geom.Matrix;

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

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

Distância pela qual converter cada ponto ao longo do eixo x.

import flash.geom.Matrix;

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

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

Distância pela qual converter cada ponto ao longo do eixo y.

import flash.geom.Matrix;

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

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

Cria um novo objeto Matrix com os parâmetros especificados. Na rotação da matriz, as propriedades são organizadas da seguinte maneira:

Se você não fornecer nenhum parâmetro para o construtor new Matrix(), ele criará uma identity matrix com os seguintes valores:

a = 1

b = 0

c = 0

d = 1

tx = 0

ty = 0

Na rotação da matriz, a matriz de identidade fica da seguinte maneira:

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)

Retorna um novo objeto Matrix que é um clone dessa matriz, com uma cópia exata do objeto contido.

Concatena uma matriz com a matriz atual, combinando efetivamente os efeitos geométricos das duas. Em termos matemáticos, concatenar duas matrizes é o mesmo que combiná-las usando a multiplicação de matriz.

Por exemplo, se a matriz m1 dimensiona um objeto em um fator de quatro e a matriz m2 gira um objeto em 1.5707963267949 radianos (Math.PI/2), então m1.concat(m2) transforma m1 em uma matriz que dimensiona um objeto em um fator de quatro e gira o objeto em Math.PI/2 radianos.

Este método substitui a matriz de origem pela matriz concatenada. Se você quiser concatenar duas matrizes sem alterar nenhuma das duas matrizes de origem, primeiro copie a matriz de origem usando o método clone(), conforme mostrado na seção Exemplo de classe.

Parâmetros

Copia um objeto de Vector3D na coluna específica do objeto de chamada Matrix3D.

Parâmetros

Copia a coluna específica do objeto de chamada Matrix para o objeto de Vector3D. O elemento w do objeto de Vector3D não será alterado.

Parâmetros

Copia todos dos dados de matriz do objeto de Point de origem para o objeto de chamada Matrix que chama.

Parâmetros

Copia um objeto de Vector3D na linha específica do objeto de chamada Matrix.

Parâmetros

Copia a linha específica do objeto de chamada Matrix para o objeto de Vector3D. O elemento w do objeto de Vector3D não será alterado.

Parâmetros

Inclui parâmetros para dimensionamento, rotação e conversão. Quando aplicados à matriz, eles definem os valores da matriz baseados nesses parâmetros.

Usar o método createBox() permite que você obtenha a mesma matriz que obteria se você aplicasse os métodos identity(), rotate(), scale() e translate() sucessivamente. Por exemplo, mat1.createBox(2,2,Math.PI/4, 100, 100) tem o mesmo efeito que:

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

Parâmetros

Elementos da API relacionados

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;
        }
    }
}

Cria um estilo específico de matriz esperado pelos métodos beginGradientFill() e lineGradientStyle() da classe Graphics. A largura e a altura são dimensionadas em um par scaleX/scaleY e os valores tx/ty são deslocados em metade da largura e da altura.

Por exemplo, considere um gradiente com as seguintes características:

• GradientType.LINEAR
• Duas cores, verde e azul, com a matriz de proporções definida como [0, 255]
• SpreadMethod.PAD
• InterpolationMethod.LINEAR_RGB

As ilustrações a seguir mostram gradientes nos quais a matriz foi definida com o uso do método createGradientBox() com diferentes configurações de parâmetros:

configurações de createGradientBox()	Gradiente resultante
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;

Parâmetros

Elementos da API relacionados

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);
        }
    }
}

Com base em um ponto no espaço de coordenadas de pré-transformação, retorna as coordenadas desse ponto após a ocorrência da transformação. Ao contrário da transformação padrão aplicada com o uso do método transformPoint(), a transformação do método deltaTransformPoint() não considera os parâmetros de conversão tx e ty.

Parâmetros

Define cada propriedade de matriz como um valor que causa uma transformação nula. Um objeto transformado ao aplicar uma matriz de identidade será idêntico ao original.

Após chamar o método identity(), a matriz resultante tem as seguintes propriedades: a=1, b=0, c=0, d=1, tx=0, ty=0.

Na rotação da matriz, a matriz de identidade fica da seguinte maneira:

Realiza a transformação oposta da matriz original. É possível aplicar uma matriz invertida a um objeto para desfazer a transformação realizada ao aplicar a matriz original.

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;
        }
    }
}

Aplica uma transformação de rotação ao objeto Matrix.

O método rotate() altera as propriedades a, b, c e d do objeto Matrix. Na rotação de matriz, isso é o mesmo que concatenar a matriz atual com:

Parâmetros

Aplica uma transformação de dimensionamento à matriz. O eixo x é multiplicado por sx e o eixo y é multiplicado por sy.

O método scale() altera as propriedades a e d do objeto Matrix. Na rotação de matriz, isso é o mesmo que concatenar a matriz atual com a seguinte matriz:

Parâmetros

Estabelece os integrantes da Matrix para os valores especificados

Parâmetros

Retorna um valor de texto que lista as propriedades do objeto Matrix.

Retorna o resultado da aplicação da transformação geométrica representada pelo objeto Matrix para o ponto especificado.

Parâmetros

Converte a matriz ao longo dos eixos x e y, conforme especificado pelos parâmetros dx e dy.

Parâmetros

1. A aplicação cria um novo objeto Matrix myMatrix e ele usa o método trace() para criar os valores de propriedade padrão para o objeto myMatrix.
2. A aplicação chama o createGradientBox() com os parâmetros width e height definidos em 200 pixels, sem rotação, e a distância para converter ao longo dos eixos x e y definidas em 50 pixels.
3. A aplicação imprime o objeto myMatrix novamente para mostrar a alteração após chamar o createGradientBox().
4. O aplicativo define até três variáveis para controlar a maneira como a caixa de gradiente é preenchida:
   • colors: Define as cores de gradiente para o intervalo entre o vermelho sólido e o azul sólido.
   • alphas: Defina a opacidade para sólida.
   • ratios: Define a distribuição das cores para ficarem iguais, tanto para o vermelho quanto para o azul.
5. O aplicativo chama o método de gráfico beginGradientFill(), que opera no objeto myMatrix, e chama o método lineTo(), resultando na caixa preenchida com gradiente.

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);
        }
    }
}