Matrix3D  - AS3

一个用于确定矩阵是否可逆的数字。

Matrix3D 对象必须是可逆的。可以使用 determinant 属性确保 Matrix3D 对象是可逆的。如果行列式为零，则矩阵没有逆矩阵。例如，如果矩阵的整个行或列为零，或如果两个行或列相等，则行列式为零。行列式还可用于对一系列方程进行求解。

仅正方形矩阵（例如 Matrix3D 类）具有行列式。

相关 API 元素

一个保存显示对象在转换参照帧中的 3D 坐标 (x,y,z) 位置的 Vector3D 对象。利用 position 属性，可立即访问显示对象矩阵的平移矢量，而无需分解和重新组合矩阵。

利用 position 属性，可以获取和设置转换矩阵的平移元素。

相关 API 元素

一个由 16 个数字组成的矢量，其中，每四个元素可以是 4x4 矩阵的一列。

如果 rawData 属性设置为一个不可逆的矩阵，则会引发异常。Matrix3D 对象必须是可逆的。如果需要不可逆的矩阵，请创建 Matrix3D 对象的子类。

相关 API 元素

创建 Matrix3D 对象。可以使用一个由 16 个数字组成的矢量来初始化 Matrix3D 对象，其中，每四个元素可以是一列。创建 Matrix3D 对象之后，可以使用 rawData 属性访问该对象的矩阵元素。

如果未定义任何参数，则构造函数会生成一个恒等或单位 Matrix3D 对象。在矩阵表示法中，恒等矩阵中的主对角线位置上的所有元素的值均为一，而所有其他元素的值均为零。恒等矩阵的 rawData 属性的值为 1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1。恒等矩阵的位置或平移值为 Vector3D(0,0,0)，旋转设置为 Vector3D(0,0,0)，缩放值为 Vector3D(1,1,1)。

相关 API 元素

通过将另一个 Matrix3D 对象与当前 Matrix3D 对象相乘来后置一个矩阵。得到的结果将合并两个矩阵转换。可以将一个 Matrix3D 对象与多个矩阵相乘。最终的 Matrix3D 对象将包含所有转换的结果。

矩阵乘法运算与矩阵加法运算不同。矩阵乘法运算是不可交换的。换句话说，A 乘以 B 并不等于 B 乘以 A。在使用 append() 方法时，乘法运算将从左侧开始，这意味着 lhs Matrix3D 对象位于乘法运算符的左侧。

首次调用 append() 方法时，此方法会对父级空间进行相关修改。后续调用与后置的 Matrix3D 对象的参照帧相关。

append() 方法会将当前矩阵替换为后置的矩阵。如果要后置两个矩阵，而不更改当前矩阵，请使用 clone() 方法复制当前矩阵，然后对生成的副本应用 append() 方法。

参数

相关 API 元素

在 Matrix3D 对象上后置一个增量旋转。在将 Matrix3D 对象应用于显示对象时，矩阵会在 Matrix3D 对象中先执行其他转换，再执行旋转。

显示对象的旋转由以下元素定义：一个轴、绕该轴旋转的增量角度和对象旋转中心的可选轴点。轴可以是任何常规方向。常见的轴为 X_AXIS (Vector3D(1,0,0))、Y_AXIS (Vector3D(0,1,0)) 和 Z_AXIS (Vector3D(0,0,1))。在航空术语中，有关 y 轴的旋转称为偏航。有关 x 轴的旋转称为俯仰。有关 z 轴的旋转称为翻滚。

转换的顺序很重要。先旋转再平移的转换所产生的效果与先平移再旋转的转换所产生的效果不同。

旋转效果不是绝对效果。它与当前位置和方向相关。要确保对转换矩阵进行绝对更改，请使用 recompose() 方法。appendRotation() 方法也与显示对象的轴旋转属性（例如 rotationX 属性）不同。旋转属性始终先于任何平移执行，而 appendRotation() 方法相对于矩阵中已存在的内容执行。要确保获得与显示对象的轴旋转属性类似的效果，请使用 prependRotation() 方法，该方法会在矩阵中先执行旋转，然后再执行其他转换。

在将 appendRotation() 方法的转换应用于显示对象的 Matrix3D 对象时，缓存的显示对象旋转属性值无效。

一种用于让一个显示对象绕相对于其位置的特定点旋转的方法是：将该对象平移设置为指定的点，使用 appendRotation() 方法旋转该对象，然后将该对象向后平移到原始位置。在下面的示例中，myObject 3D 显示对象将围绕坐标 (10,10,0) 进行 y 轴旋转。

    
    myObject.z = 1; 
    myObject.transform.matrix3D.appendTranslation(10,10,0);
    myObject.transform.matrix3D.appendRotation(1, Vector3D.Y_AXIS);
    myObject.transform.matrix3D.appendTranslation(-10,-10,0);
     
    

参数

相关 API 元素

在 Matrix3D 对象上后置一个增量缩放，沿 x、y 和 z 轴改变位置。在将 Matrix3D 对象应用于显示对象时，矩阵会在 Matrix3D 对象中先执行其他转换，然后再执行缩放更改。默认的缩放系数为 (1.0, 1.0, 1.0)。

缩放将作为沿三个轴（x、y、z）进行的三个增量更改集进行定义。可以将每个轴与不同的数字相乘。在将缩放更改应用于显示对象时，该对象的大小会增大或减小。例如，将 x、y 和 z 轴设置为 2 将使对象大小为原来的两倍，而将轴设置为 0.5 将使对象的大小为原来的一半。要确保缩放转换只影响特定的轴，请将其他参数设置为 1。参数为 1 表示不沿特定的轴进行任何缩放更改。

appendScale() 方法可用于调整大小和管理扭曲（例如显示对象的拉伸或收缩），或用于某个位置上的放大和缩小。在显示对象的旋转和平移过程中，将自动执行缩放转换。

转换的顺序很重要。先调整大小再平移的转换所产生的效果与先平移再调整大小的转换所产生的效果不同。

参数

相关 API 元素

在 Matrix3D 对象上后置一个增量平移，沿 x、y 和 z 轴重新定位。在将 Matrix3D 对象应用于显示对象时，矩阵会在 Matrix3D 对象中先执行其他转换，然后再执行平移更改。

平移将作为沿三个轴（x、y、z）进行的三个增量更改集进行定义。在对显示对象应用转换时，显示对象会从当前位置沿 x、y 和 z 轴按参数指定的增量移动。要确保平移只影响特定的轴，请将其他参数设置为零。参数为零表示不沿特定的轴进行任何更改。

平移更改不是绝对更改。它们与矩阵的当前位置和方向相关。要确保对转换矩阵进行绝对更改，请使用 recompose() 方法。转换的顺序也很重要。先平移再旋转的转换所产生的效果与先旋转再平移所产生的效果不同。

参数

相关 API 元素

返回一个新 Matrix3D 对象，它是与当前 Matrix3D 对象完全相同的副本。

将 Vector3D 对象复制到调用方 Matrix3D 对象的特定列中。

参数

将调用方 Matrix3D 对象的特定列复制到 Vector3D 对象中。

参数

将源 Matrix3D 对象中的所有矩阵数据复制到调用方 Matrix3D 对象中。

参数

将源 Vector 对象中的所有矢量数据复制到调用方 Matrix3D 对象中。利用可选索引参数，您可以选择矢量中的任何起始文字插槽。

参数

将调用方 Matrix3D 对象中的所有矩阵数据复制到提供的矢量中。利用可选索引参数，您可以选择矢量中的任何目标起始文字插槽。

参数

将 Vector3D 对象复制到调用方 Matrix3D 对象的特定行中。

参数

将调用方 Matrix3D 对象的特定行复制到 Vector3D 对象中。

参数

参数

将转换矩阵的平移、旋转和缩放设置作为由三个 Vector3D 对象组成的矢量返回。第一个 Vector3D 对象容纳平移元素。第二个 Vector3D 对象容纳旋转元素。第三个 Vector3D 对象容纳缩放元素。

一些 Matrix3D 方法（例如 interpolateTo() 方法）会自动分解和重新组成矩阵以执行其转换。

要使用绝对父级参照帧来修改矩阵转换，请使用 decompose() 方法检索设置，然后做出适当的更改。然后，可以使用 recompose() 方法将 Matrix3D 对象设置为修改后的转换。

decompose() 方法的参数指定要用于转换的方向样式。默认方向为 eulerAngles，它通过三个不同的对应于每个轴的旋转角来定义方向。这些旋转是连续发生的，并且相互不更改轴。显示对象的轴旋转属性执行欧拉角方向样式转换。另外两个方向样式选项分别为 axisAngle 和 quaternion。轴角方向结合使用轴和角度来确定方向。对象绕其旋转的轴是一个单位矢量，它表示一个方向。角表示有关矢量的旋转幅度。方向还确定显示对象面对的方向，而角确定哪个方向是向上。appendRotation() 和 prependRotation() 方法使用轴角方向。四元数方向使用复数和矢量的第四个元素。方向由三个旋转轴（x、y、z）和一个旋转角 (w) 表示。interpolate() 方法使用四元数。

参数

相关 API 元素

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.geom.*;
    import flash.events.Event;
    
    public class Matrix3DdecomposeExample extends MovieClip {
        private var ellipse:Shape = new Shape();

        public function Matrix3DdecomposeExample():void {
            
            ellipse.x = (this.stage.stageWidth / 2);
            ellipse.y = (this.stage.stageHeight - 40);
            ellipse.z = 1;
            ellipse.graphics.beginFill(0xFF0000);
            ellipse.graphics.lineStyle(2);
            ellipse.graphics.drawEllipse(0, 0, 50, 40);
            ellipse.graphics.endFill();
            addChild(ellipse);

            ellipse.addEventListener(Event.ENTER_FRAME, enterFrameHandler);
        }

        private function enterFrameHandler(e:Event):void {  

            var v3:Vector.<Vector3D> = new Vector.<Vector3D>(3);
            v3 = ellipse.transform.matrix3D.decompose();
            v3[0].incrementBy(new Vector3D(0,0,1));
            v3[2].incrementBy(new Vector3D(0.01,0,0));
            ellipse.transform.matrix3D.recompose(v3);
        }
    }
}

使用不含平移元素的转换矩阵将 Vector3D 对象从一个空间坐标转换到另一个空间坐标。返回的 Vector3D 对象将容纳应用旋转和缩放转换之后的新坐标。如果 deltaTransformVector() 方法应用的是仅包含平移转换的矩阵，则返回的 Vector3D 对象与原始 Vector3D 对象相同。

通过使用 deltaTransformVector() 方法，可以让一个坐标空间中的显示对象对第二个显示对象的旋转转换做出响应。该对象不复制旋转；它只是更改其位置以反映旋转中的更改。例如，为了使用 display.Graphics API 绘制一个旋转的 3D 显示对象，则必须将该对象的旋转坐标映射到一个 2D 点。首先，在每次旋转后使用 deltaTransformVector() 方法检索对象的 3D 坐标。然后，应用显示对象的 local3DToGlobal() 方法，以将 3D 坐标平移到 2D 点。然后，可以使用 2D 点来绘制旋转的 3D 对象。

注意：此方法会将所传递的 Vector3D 的 w 分量自动设置为 0.0。

参数

相关 API 元素

将当前矩阵转换为恒等或单位矩阵。恒等矩阵中的主对角线位置上的元素的值为一，而所有其他元素的值为零。生成的结果是一个矩阵，其中，rawData 值为 1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1，旋转设置为 Vector3D(0,0,0)，位置或平移设置为 Vector3D(0,0,0)，缩放设置为 Vector3D(1,1,1)。以下是恒等矩阵的表示形式。

通过应用恒等矩阵转换的对象不执行任何转换。换句话说，如果一个矩阵与一个恒等矩阵相乘，则会生成一个与原始矩阵相同（恒等）的矩阵。

朝着目标矩阵的平移、旋转和缩放转换插补某个矩阵的这些转换。

interpolate() 方法可避免在使用方法（例如显示对象的轴旋转属性）时出现一些不需要的结果。interpolate() 方法可使缓存的显示对象旋转属性值无效，并在插补前将显示对象矩阵的方向元素转换为四元数。此方法可以确保旋转的路径最短且最有效。它还生成平滑的、无万向节锁定的旋转。当使用欧拉角时（此时将单独处理每个轴）会出现万向节锁定。在绕两个或更多轴旋转的过程中，这些轴可能会对齐，从而导致意外结果。四元数旋转可避免万向节锁定。

对 interpolate() 方法的连续调用会产生这样的效果：显示对象迅速启动，然后缓慢接近另一个显示对象。例如，如果将 thisMat 参数设置为返回的 Matrix3D 对象，将 toMat 参数设置为目标显示对象关联的 Matrix3D 对象，并将 percent 参数设置为 0.1，则显示对象会朝目标对象移动百分之十。对于后续调用或在后续的帧中，对象会移动剩余的 90% 的百分之十，然后移动剩余的 距离的百分之十，直到对象到达目标。

参数

相关 API 元素

朝着目标矩阵的平移、旋转和缩放转换插补此矩阵。

interpolateTo() 方法可避免在使用方法（例如显示对象的轴旋转属性）时出现不需要的结果。interpolateTo() 方法可使缓存的显示对象旋转属性值无效，并在插补前将显示对象矩阵的方向元素转换为四元数。此方法可以确保旋转的路径最短且最有效。它还生成平滑的、无万向节锁定的旋转。当使用欧拉角时（此时将单独处理每个轴）会出现万向节锁定。在绕两个或更多轴旋转的过程中，这些轴可能会对齐，从而导致意外结果。四元数旋转可避免万向节锁定。

注意：在插值的情况下，矩阵的缩放值将重置，此时将标准化矩阵。

对 interpolateTo() 方法的连续调用会产生这样的效果：显示对象迅速启动，然后缓慢接近另一个显示对象。例如，如果 percent 参数设置为 0.1，则显示对象会朝 toMat 参数指定的目标对象移动百分之十。对于后续调用或在后续的帧中，对象会移动剩余的 90% 的百分之十，然后移动剩余的 距离的百分之十，直到对象到达目标。

参数

相关 API 元素

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.display.Graphics;
    import flash.geom.*;
    import flash.events.Event;

    public class InterpolateToExample extends MovieClip {
        private var ellipse1:Shape = new Shape();
        private var ellipse2:Shape = new Shape();

        public function InterpolateToExample():void {

            ellipse1 = myEllipses(250, 100, 500, 0xFF0000);
            addChild(ellipse1);
            
            ellipse2 = myEllipses(-30, 120, 1, 0x00FF00);
            addChild(ellipse2);

            addEventListener(Event.ENTER_FRAME, enterFrameHandler);
        }

        private function myEllipses(x:Number, y:Number, z:Number, c:Number):Shape {
            var s:Shape = new Shape();                            
            s.x = x;
            s.y = y;
            s.z = z;
            s.graphics.beginFill(c);
            s.graphics.lineStyle(2);
            s.graphics.drawEllipse(100, 50, 100, 80);
            s.graphics.endFill();
            return s;
        }

        private function enterFrameHandler(e:Event) {
            ellipse1.rotationY += 1;

            ellipse2.transform.matrix3D.interpolateTo(ellipse1.transform.matrix3D, 0.1);
        }
    }
}

反转当前矩阵。逆矩阵具有与原始矩阵相同的大小，但它执行的转换与原始矩阵相反。例如，如果在原始矩阵中，一个对象按某个方向绕 x 轴旋转，那么在逆矩阵中，该对象将按此方向的反方向绕 x 轴旋转。对一个对象应用逆矩阵可撤消原始矩阵执行的转换。如果将一个矩阵与其逆矩阵相乘，则将产生一个恒等矩阵。

利用矩阵的逆矩阵，可以将一个矩阵除以另一个矩阵。通过将矩阵 A 与矩阵 B 的逆矩阵相乘，可以将矩阵 A 除以矩阵 B。逆矩阵还可以用于摄像头空间。当摄像头在现实世界空间中移动时，现实世界中的对象需按与摄像头相反的方向移动，这样才能从现实世界视点转换到摄像头或视点空间。例如，如果摄像头移动得越近，则对象变得越大。换句话说，如果摄像头沿现实世界的 z 轴下移，则对象会沿此 z 轴上移。

invert() 方法会将当前矩阵替换为逆矩阵。如果要反转矩阵，而不更改当前矩阵，请先使用 clone() 方法复制当前矩阵，然后对生成的副本应用 invert() 方法。

Matrix3D 对象必须是可逆的。

相关 API 元素

旋转显示对象以使其朝向指定的位置。此方法允许对方向进行就地修改。显示对象（即 at Vector3D 对象）的向前方向矢量指向指定的现实世界相关位置。显示对象的向上方向是用 up Vector3D 对象指定的。

pointAt() 方法可使缓存的显示对象旋转属性值无效。此方法可分解显示对象的矩阵并修改旋转元素，从而让对象转向指定位置。然后，此方法将重新组成（更新）显示对象的矩阵，这将执行转换。如果该对象指向正在移动的目标（例如正在移动的对象位置），则对于每个后续调用，此方法都会让对象朝正在移动的目标旋转。

注意：如果使用 Matrix3D.pointAt() 方法，但不设置可选参数，则默认情况下，某个目标对象将不面对所指定的相对于现实世界的位置。您需要将 at 的值设置为 -y 轴 (0,-1,0)，将 up 的值设置为 -z 轴 (0,0,-1)。

参数

相关 API 元素

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.display.Graphics;
    import flash.geom.*;
    import flash.events.Event;

    public class PointAtExample extends MovieClip {
        private var ellipse:Shape = new Shape();
        private var triangle:Shape = new Shape();

        public function PointAtExample():void {
            ellipse.graphics.beginFill(0xFF0000);
            ellipse.graphics.lineStyle(2);
            ellipse.graphics.drawEllipse(30, 40, 50, 40);
            ellipse.graphics.endFill();
            ellipse.x = 100;
            ellipse.y = 150;
            ellipse.z = 1;

            triangle.graphics.beginFill(0x0000FF);
            triangle.graphics.moveTo(0, 0);
            triangle.graphics.lineTo(40, 40);
            triangle.graphics.lineTo(80, 0);
            triangle.graphics.lineTo(0, 0);
            triangle.graphics.endFill();
            triangle.x = 200;
            triangle.y = 50;
            triangle.z = 1;

            addChild(ellipse);
            addChild(triangle);

            ellipse.addEventListener(Event.ENTER_FRAME, ellipseEnterFrameHandler);
            triangle.addEventListener(Event.ENTER_FRAME, triangleEnterFrameHandler);
        }

        private function ellipseEnterFrameHandler(e:Event) {
            if(e.target.y > 0) {
                e.target.y -= 1;
                e.target.x -= 1;
            }
        }
        
        private function triangleEnterFrameHandler(e:Event) {
            e.target.transform.matrix3D.pointAt(ellipse.transform.matrix3D.position,
                                                Vector3D.X_AXIS, Vector3D.Y_AXIS);
        }
    }
}

通过将当前 Matrix3D 对象与另一个 Matrix3D 对象相乘来前置一个矩阵。得到的结果将合并两个矩阵转换。

矩阵乘法运算与矩阵加法运算不同。矩阵乘法运算是不可交换的。换句话说，A 乘以 B 并不等于 B 乘以 A。在使用 prepend() 方法时，乘法运算将从右侧开始，这意味着 rhs Matrix3D 对象位于乘法运算符的右侧。

prepend() 方法所做的修改与对象空间相关。换句话说，这些修改始终与对象的初始参照帧相关。

prepend() 方法会将当前矩阵替换为前置的矩阵。如果要前置两个矩阵，而不更改当前矩阵，请先使用 clone() 方法复制当前矩阵，然后对生成的副本应用 prepend() 方法。

参数

相关 API 元素

在 Matrix3D 对象上前置一个增量旋转。在将 Matrix3D 对象应用于显示对象时，矩阵会在 Matrix3D 对象中先执行旋转，然后再执行其他转换。

显示对象的旋转由以下元素定义：一个轴、绕该轴旋转的增量角度和对象旋转中心的可选轴点。轴可以是任何常规方向。常见的轴为 X_AXIS (Vector3D(1,0,0))、Y_AXIS (Vector3D(0,1,0)) 和 Z_AXIS (Vector3D(0,0,1))。在航空术语中，有关 y 轴的旋转称为偏航。有关 x 轴的旋转称为俯仰。有关 z 轴的旋转称为翻滚。

转换的顺序很重要。先旋转再平移的转换所产生的效果与先平移再旋转所产生的效果不同。

旋转效果不是绝对效果。此效果与对象有关，它与原始位置和方向的参照帧相对。要确保对转换进行绝对更改，请使用 recompose() 方法。

在将 prependRotation() 方法的转换应用于显示对象的 Matrix3D 对象时，缓存的显示对象旋转属性值无效。

一种使一个显示对象围绕某个相对于其位置的特定点进行旋转的方法是：将该对象平移到指定的点，使用 prependRotation() 方法旋转该对象，然后将该对象平移回原始位置。在下面的示例中，myObject 3D 显示对象将围绕坐标 (10,10,0) 进行 y 轴旋转。

    
    myObject.z = 1; 
    myObject.transform.matrix3D.prependTranslation(10,10,0);
    myObject.transform.matrix3D.prependRotation(1, Vector3D.Y_AXIS);
    myObject.transform.matrix3D.prependTranslation(-10,-10,0);
     
    

参数

相关 API 元素

package {
    import flash.display.MovieClip;
    import flash.display.Shape;
    import flash.geom.*;
    import flash.events.MouseEvent;
    
    public class Matrix3DprependRotationExample extends MovieClip {
        private var ellipse:Shape = new Shape();

        public function Matrix3DprependRotationExample():void {

            ellipse.graphics.beginFill(0xFF0000);
            ellipse.graphics.lineStyle(2);
            ellipse.graphics.drawEllipse(-50, -40, 100, 80);
            ellipse.graphics.endFill();

            ellipse.x = (this.stage.stageWidth / 2);
            ellipse.y = (this.stage.stageHeight / 2);
            ellipse.z = 1;
            
            addChild(ellipse);

            stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
        }

        private function mouseMoveHandler(e:MouseEvent):void {
            var y:int;
            var x:int;
            
            if(e.localX > ellipse.x) {
                y = (Math.round(e.localX) / 100);   
            } else {
                y = -(Math.round(e.localX) / 10);   
            }
            
            if(e.localY > ellipse.y) {
                x = (Math.round(e.localY) / 100);
            } else {
                x = -(Math.round(e.localY) / 100);
            }
            
            ellipse.transform.matrix3D.prependRotation(y, Vector3D.Y_AXIS);
            ellipse.transform.matrix3D.prependRotation(x, Vector3D.X_AXIS);
        }
        
    }
}

在 Matrix3D 对象上前置一个增量缩放，沿 x、y 和 z 轴改变位置。在将 Matrix3D 对象应用于显示对象时，矩阵会在 Matrix3D 对象中先执行缩放更改，然后再执行其他转换。这些更改与对象有关，它与原始位置和方向的参照帧相对。默认的缩放系数为 (1.0, 1.0, 1.0)。

缩放将作为沿三个轴（x、y、z）进行的三个增量更改集进行定义。可以将每个轴与不同的数字相乘。在将缩放更改应用于显示对象时，该对象的大小会增大或减小。例如，将 x、y 和 z 轴设置为 2 将使对象大小为原来的两倍，而将轴设置为 0.5 将使对象的大小为原来的一半。要确保缩放转换只影响特定的轴，请将其他参数设置为 1。参数为 1 表示不沿特定的轴进行任何缩放更改。

prependScale() 方法可用于调整大小和管理扭曲（例如显示对象的拉伸或收缩），还可用于某个位置上的放大和缩小。在显示对象的旋转和平移过程中，将自动执行缩放转换。

转换的顺序很重要。先调整大小再平移的转换所产生的效果与先平移再调整大小的转换所产生的效果不同。

参数

相关 API 元素

在 Matrix3D 对象上前置一个增量平移，沿 x、y 和 z 轴重新定位。在将 Matrix3D 对象应用于显示对象时，矩阵会在 Matrix3D 对象中先执行平移更改，然后再执行其他转换。

平移指定显示对象从其当前位置沿 x、y 和 z 轴移动的距离。prependTranslation() 方法将平移设置为沿三个轴（x、y、z）进行的三个增量更改集。要让平移只影响特定的轴，请将其他参数设置为零。参数为零表示不沿特定的轴进行任何更改。

平移更改不是绝对更改。此效果与对象有关，它与原始位置和方向的参照帧相对。要确保对转换矩阵进行绝对更改，请使用 recompose() 方法。转换的顺序也很重要。先平移再旋转的转换所产生的效果与先旋转再平移的转换所产生的效果不同。当使用 prependTranslation() 时，显示对象将继续按照其面对的方向移动，这与其他转换无关。例如，如果显示对象面向的是正向 x 轴，则该对象将继续按照 prependTranslation() 方法指定的方向移动，这与对象旋转的方式无关。要让平移更改在其他转换之后发生，请使用 appendTranslation() 方法。

参数

相关 API 元素

package {
    import flash.display.MovieClip;
    import flash.display.Sprite;
    import flash.geom.*;
    import flash.events.MouseEvent;

    public class Matrix3DprependTranslationExample extends MovieClip {
        private var ellipse:Sprite = new Sprite();

        public function Matrix3DprependTranslationExample():void {
            ellipse.x = this.stage.stageWidth / 2;
            ellipse.y = this.stage.stageHeight - 100;
            ellipse.z = 1;
            ellipse.graphics.beginFill(0xFF0000);
            ellipse.graphics.lineStyle(2);
            ellipse.graphics.drawEllipse(0, 0, 60, 50);
            ellipse.graphics.endFill();
            addChild(ellipse);

            ellipse.addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
            ellipse.addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
        }

        private function mouseOverHandler(e:MouseEvent):void {
            if(ellipse.y > 0) { 
                ellipse.transform.matrix3D.prependTranslation(0, -10, 0);
            } 
        }
        
        private function mouseOutHandler(e:MouseEvent):void {
            if(ellipse.y > 0) { 
                ellipse.transform.matrix3D.prependTranslation(0, -10, 0);
            } else {
                ellipse.transform.matrix3D.prependTranslation(0, 
                                     (this.stage.stageHeight - 100), 0);
            }   
        }
    }
}

设置转换矩阵的平移、旋转和缩放设置。与显示对象的旋转属性或 Matrix3D 对象的旋转方法所做的增量更改不同，recompose() 方法所做的更改是绝对更改。recompose() 方法将覆盖矩阵转换。

要使用绝对父级参照帧来修改矩阵转换，请使用 decompose() 方法检索设置，然后做出适当的更改。然后，可以使用 recompose() 方法将 Matrix3D 对象设置为修改后的转换。

recompose() 方法的参数指定用于转换的方向样式。默认方向为 eulerAngles，它通过三个不同的对应于每个轴的旋转角来定义方向。这些旋转是连续发生的，并且相互不更改轴。显示对象的轴旋转属性执行欧拉角方向样式转换。另外两个方向样式选项分别为 axisAngle 和 quaternion。轴角方向结合使用轴和角度来确定方向。对象绕其旋转的轴是一个单位矢量，它表示一个方向。角表示有关矢量的旋转幅度。方向还确定显示对象面对的方向，而角确定哪个方向是向上。appendRotation() 和 prependRotation() 方法使用轴角方向。四元数方向使用复数和矢量的第四个元素。方向由三个旋转轴（x、y、z）和一个旋转角 (w) 表示。interpolate() 方法使用四元数。

参数

相关 API 元素

使用转换矩阵将 Vector3D 对象从一个空间坐标转换到另一个空间坐标。返回的 Vector3D 对象将容纳转换后的新坐标。将对 Vector3D 对象中应用所有矩阵转换（包括平移）。

如果已将 transformVector() 方法的结果应用于显示对象的位置，则仅显示对象的位置会发生更改。显示对象的旋转和缩放元素保持不变。

注意：此方法会将所传递的 Vector3D 的 w 分量自动设置为 1.0。

参数

相关 API 元素

使用转换矩阵将由数字构成的矢量从一个空间坐标转换到另一个空间坐标。tranformVectors() 方法将读取 vin Vector 对象中的每三个数字作为一个 3D 坐标 (x,y,z)，并将转换后的 3D 坐标放置到 vout Vector 对象中。所有矩阵转换（包括平移）将应用于 vin Vector 对象。可以使用 transformVectors() 方法将 3D 对象作为网格进行呈现和转换。网格是一个顶点集合，这些顶点定义了对象的形状。

参数

相关 API 元素

将当前 Matrix3D 对象转换为一个矩阵，并将互换其中的行和列。例如，如果当前 Matrix3D 对象的 rawData 包含以下 16 个数字：1,2,3,4,11,12,13,14,21,22,23,24,31,32,33,34，则 transpose() 方法会将每四个元素作为一个行读取并将这些行转换为列。生成的结果是一个矩阵，其 rawData 为：1,11,21,31,2,12,22,32,3,13,23,33,4,14,24,34。

transpose() 方法会将当前矩阵替换为转置矩阵。如果要转置矩阵，而不更改当前矩阵，请先使用 clone() 方法复制当前矩阵，然后对生成的副本应用 transpose() 方法。

正交矩阵是一个正方形矩阵，该矩阵的转置矩阵和逆矩阵相同。