Matrix3D  - AS3

Objet Number qui détermine si une matrice est réversible.

Un objet Matrix3D doit être réversible. Pour être certain qu’un objet Matrix3D est réversible, vous pouvez utiliser la propriété determinant. Si la propriété determinant est zéro, il n’existe aucun inverse de la matrice. Par exemple, si une ligne ou une colonne entière d’une matrice est zéro ou si deux lignes ou deux colonnes sont égales, la propriété determinant est zéro. La propriété determinant permet également de résoudre une suite d’équations.

Seule une matrice carrée, telle que la classe Matrix3D, possède une propriété determinant.

Eléments de l’API associés

Objet Vector3D contenant la position, les coordonnées 3D (x,y,z) d’un objet d’affichage dans l’image de référence de la transformation. La propriété position permet d’accéder immédiatement au vecteur de translation de la matrice de l’objet d’affichage sans qu’il soit nécessaire de décomposer et de recomposer la matrice.

La propriété position vous permet d’obtenir et de définir les éléments de translation de la matrice de transformation.

Eléments de l’API associés

Vecteur de 16 numéros, où chacun des quatre éléments est une colonne d’une matrice 4x4.

Une exception est renvoyée si la propriété rawData est définie sur une matrice non réversible. L’objet Matrix3D doit être réversible. Si une matrice non réversible est nécessaire, créez une sous-classe de l’objet Matrix3D.

Eléments de l’API associés

Crée un objet Matrix3D. Les objets Matrix3D peuvent être initialisés avec un objet Vector de 16 nombres, où chaque groupe de quatre éléments est une colonne. Après la création de l’objet Matrix3D, vous pouvez accéder aux éléments de sa matrice par la propriété rawData.

Si aucun paramètre n’est défini, le constructeur produit un objet Matrix3D d’identité ou unitaire. Dans la notation des matrices, une matrice d’identité a une valeur de un pour tous les éléments situés sur la diagonale principale et une valeur de zéro pour tous les autres éléments. La valeur de la propriété rawData d’une matrice d’identité est : 1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1. La position ou la valeur de translation de la matrice d’identité est Vector3D(0,0,0), le paramètre de rotation est Vector3D(0,0,0) et la valeur de mise à l’échelle est Vector3D(1,1,1).

Eléments de l’API associés

Ajoute la matrice en multipliant un autre objet Matrix3D par l’objet Matrix3D actuel. Le résultat combine les deux transformations de matrice. Vous pouvez multiplier un objet Matrix3D par de nombreuses matrices. L’objet Matrix3D final contient le résultat de toutes les transformations.

Les multiplications de matrices diffèrent des additions de matrices. La multiplication de matrices n’est pas commutative. En d’autres termes, A fois B n’est pas égal à B fois A. Avec la méthode append(), la multiplication s’effectue à partir du côté gauche, ce qui signifie que l’objet Matrix3D lhs est situé à gauche de l’opérateur de la multiplication.

La première fois que la méthode append() est appelée, elle effectue une modification par rapport à l’espace parent. Les appels suivants sont relatifs à l’image de référence de l’objet Matrix3D ajouté.

La méthode append() remplace la matrice actuelle par la matrice ajoutée. Si vous souhaitez ajouter deux matrices sans modifier la matrice actuelle, copiez cette dernière à l’aide de la méthode clone() et appliquez la méthode append() à la copie.

Paramètres

Eléments de l’API associés

Ajoute une rotation incrémentielle à la fin d’un objet Matrix3D. Lorsque l’objet Matrix3D est appliqué à un objet d’affichage, la matrice exécute la rotation après les autres transformations dans l’objet Matrix3D.

La rotation de l’objet d’affichage est définie par un axe, un degré incrémentiel de rotation autour de l’axe et un point de pivot facultatif pour le centre de la rotation de l’objet. L’axe peut être toute direction générale. Les axes courants sont X_AXIS (Vector3D(1,0,0)), Y_AXIS (Vector3D(0,1,0)) et Z_AXIS (Vector3D(0,0,1)). Dans la terminologie de l’aviation, la rotation autour de l’axe y est appelée lacet. La rotation autour de l’axe x est appelée tangage ou pas. La rotation autour de l’axe z est appelée roulis.

L’ordre des transformations a son importance. Une rotation suivie d’une transformation de translation n’a pas le même effet qu’une translation suivie d’une transformation de rotation.

L’effet de la rotation n’est pas absolu. Il est relatif à la position et à l’orientation actuelles. Pour apporter une modification absolue à la matrice de transformation, utilisez la méthode recompose(). La méthode appendRotation() diffère également de la propriété rotation de l’axe de l’objet d’affichage, telle que la propriété rotationX. La propriété rotation est toujours exécutée avant toute translation, puisque la méthode appendRotation() est exécutée par rapport à tout élément déjà présent dans la matrice. Pour être certain d’obtenir un effet similaire à la propriété rotation de l’axe de l’objet d’affichage, utilisez la méthode prependRotation(), qui exécute la rotation avant les autres transformations dans la matrice.

Lorsque la transformation de la méthode appendRotation() est appliquée à un objet Matrix3D d’un objet d’affichage, les valeurs mises en cache de la propriété rotation de l’objet d’affichage sont invalidées.

Pour qu’un objet d’affichage pivote autour d’un point spécifique par rapport à son emplacement, une méthode consiste à définir la translation de l’objet sur le point spécifié, à faire pivoter l’objet avec la méthode appendRotation() et à lui appliquer une translation pour le ramener dans sa position d’origine. Dans l’exemple suivant, l’objet d’affichage 3D myObject effectue une rotation sur l’axe y autour de la coordonnée (10,10,0).

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

Paramètres

Eléments de l’API associés

Ajoute un changement d’échelle incrémentiel le long des axes x, y et z à la fin d’un objet Matrix3D. Lorsque l’objet Matrix3D est appliqué à un objet d’affichage, la matrice exécute les changements d’échelle après les autres transformations dans l’objet Matrix3D. Le facteur d’échelle par défaut est (1.0, 1.0, 1.0).

L’échelle est définie comme un ensemble de trois modifications incrémentielles le long des trois axes (x,y,z). Vous pouvez multiplier chaque axe par un nombre différent. Lorsque des modifications d’échelle sont appliquées à un objet d’affichage, la taille de l’objet augmente ou diminue. Par exemple, définir les axes x, y et z sur deux double la taille de l’objet, alors que définir les axes sur 0.5 réduit la taille de moitié. Pour être certain que la transformation d’échelle n’affecte qu’un axe spécifique, définissez les autres paramètres sur un. Un paramètre de un signifie qu’aucune modification d’échelle n’est apportée le long de l’axe spécifique.

La méthode appendScale() peut être utilisée pour le redimensionnement mais aussi pour la gestion des distorsions, par exemple pour étirer ou rétrécir un objet d’affichage, ou pour faire un zoom avant ou arrière sur un emplacement. Les transformations d’échelle sont exécutées automatiquement pendant la rotation et la translation d’un objet d’affichage.

L’ordre des transformations a son importance. Un redimensionnement suivi d’une transformation de translation n’a pas le même effet qu’une translation suivie d’une transformation de redimensionnement.

Paramètres

Eléments de l’API associés

Ajoute une translation incrémentielle, repositionnement le long des axes x, y et z, à la fin d’un objet Matrix3D. Lorsque l’objet Matrix3D est appliqué à un objet d’affichage, la matrice effectue les modifications de translation après les autres transformations dans l’objet Matrix3D.

La translation est définie comme un ensemble de trois modifications incrémentielles le long des trois axes (x,y,z). Lorsque la transformation est appliquée à un objet d’affichage, celui-ci se déplace de son point d’origine le long des axes x, y et z, tel que spécifié par les paramètres. Pour être certain que la translation n’affecte qu’un axe spécifique, définissez les autres paramètres sur zéro. Un paramètre de valeur zéro signifie qu’aucune modification n’a lieu le long de l’axe spécifique.

Les modifications de translation ne sont pas absolues. Elles sont relatives à la position et à l’orientation actuelles de la matrice. Pour apporter une modification absolue à la matrice de transformation, utilisez la méthode recompose(). L’ordre des transformations a aussi son importance. Une translation suivie d’une transformation de rotation n’a pas le même effet qu’une rotation suivie d’une translation.

Paramètres

Eléments de l’API associés

Renvoie un nouvel objet Matrix3D qui est une copie exacte de l’objet Matrix3D actuel.

Copie un objet Vector3D dans la colonne spécifique de l’objet Matrix3D appelant.

Paramètres

Copie la colonne spécifique de l’objet Matrix3D appelant dans l’objet Vector3D.

Paramètres

Copie toutes les données de matrice de l’objet Matrix3D source dans l’objet Matrix3D appelant.

Paramètres

Copie toutes les données vectorielles de l’objet vectoriel source dans l’objet Matrix3D appelant. Le paramètre d’index facultatif permet de sélectionner n’importe quel logement de départ dans le vecteur.

Paramètres

Copie toutes les données de matrice de l’objet Matrix3D appelant dans le vecteur fourni. Le paramètre d’index facultatif permet de sélectionner n’importe quel logement de départ cible dans le vecteur.

Paramètres

Copie un objet Vector3D dans la ligne correspondante de l’objet Matrix3D appelant.

Paramètres

Copie la ligne correspondante de l’objet Matrix3D appelant dans l’objet Vector3D.

Paramètres

Paramètres

Renvoie les paramètres de translation, de rotation et d’échelle de la matrice de transformation, sous forme de vecteur de trois objets Vector3D. Le premier objet Vector3D détient les éléments de translation. Le deuxième objet Vector3D détient les éléments de rotation. Le troisième objet Vector3D détient les éléments d’échelle.

Certaines méthodes Matrix3D, par exemple interpolateTo(), décomposent et recomposent automatiquement la matrice pour effectuer leur transformation.

Pour modifier la transformation de la matrice avec une image de référence de parent absolu, récupérez les paramètres avec la méthode decompose() et apportez les modifications appropriées. Vous pouvez alors définir l’objet Matrix3D sur la transformation modifiée à l’aide de la méthode recompose().

Le paramètre de la méthode decompose() définit le style d’orientation à utiliser pour la transformation. L’orientation par défaut est eulerAngles, qui définit l’orientation avec trois angles de rotation distincts pour chaque axe. Les rotations s’effectuent consécutivement et ne modifient pas l’axe des autres rotations. Les propriétés de rotation de l’axe de l’objet d’affichage effectuent une transformation de style d’orientation Angles d’Euler. Les autres options de style d’orientation sont axisAngle et quaternion. L’orientation Angle des axes utilise une combinaison d’un axe et d’un angle pour déterminer l’orientation. L’axe autour duquel l’objet pivote est un vecteur unitaire qui représente une direction. L’angle représente l’amplitude de la rotation autour du vecteur. La direction détermine également l’endroit qui fait face à l’objet d’affichage et l’angle détermine la direction du haut. Les méthodes appendRotation() et prependRotation() utilisent l’orientation Angle des axes. L’orientation quaternion utilise des nombres complexes et le quatrième élément d’un vecteur. Les trois axes de rotation (x,y,z) et un angle de rotation (w) représentent l’orientation. La méthode interpolate() utilise l’orientation quaternion.

Paramètres

Eléments de l’API associés

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

Utilise une matrice de transformation sans ses éléments de translation pour transformer un objet Vector3D d’une coordonnée spatiale en une autre. L’objet Vector3D renvoyé contient les nouvelles coordonnées après que les transformations de rotation et de mise à l’échelle aient été appliquées. Si la méthode deltaTransformVector() applique une matrice qui ne contient qu’une transformation de translation, l’objet Vector3D renvoyé correspond à l’objet Vector3D d’origine.

Vous pouvez utiliser la méthode deltaTransformVector() pour qu’un objet d’affichage d’un espace de coordonnées réponde à la transformation de rotation d’un deuxième objet d’affichage. L’objet ne copie pas la rotation, mais modifie sa position pour refléter les modifications de la rotation. Par exemple pour utiliser l’API display.Graphics en vue de dessiner un objet 3D en rotation, vous devez mapper les coordonnées de rotation de cet objet sur un point 2D. A l’aide de la méthode deltaTransformVector(), récupérez tout d’abord les coordonnées 3D de l’objet après chaque rotation. Ensuite, appliquez la méthode local3DToGlobal() de l’objet d’affichage pour convertir les coordonnées 3D en points 2D. Vous pouvez alors utiliser les points 2D pour dessiner l’objet 3D en rotation.

Remarque : cette méthode règle automatiquement le composant w de l’objet Vector3D transmis sur 0.0.

Paramètres

Eléments de l’API associés

Convertit la matrice actuelle en matrice d’identité ou unitaire. Une matrice d’identité a une valeur de un pour les éléments situés sur la diagonale principale et une valeur de zéro pour tous les autres éléments. Le résultat est une matrice dont la valeur rawData est 1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1 et le paramètre de rotation est défini sur Vector3D(0,0,0), le paramètre de position ou de translation est défini sur Vector3D(0,0,0) et l’échelle est définie sur Vector3D(1,1,1). Voici une représentation de matrice d’identité.

Un objet transformé par l’application d’une matrice d’identité n’effectue aucune transformation. En d’autres termes, lorsqu’une matrice est multipliée par une matrice d’identité, le résultat est une matrice identique à la matrice d’origine.

Interpole les transformations de translation, de rotation et d'échelle d'une seule matrice vers celles de la matrice cible.

La méthode interpolate() évite certains des résultats non désirés pouvant survenir avec l’utilisation de méthodes telles que les propriétés de rotation de l’axe de l’objet d’affichage. La méthode interpolate() invalide la valeur mise en cache de la propriété rotation de l’objet d’affichage et convertit les éléments de rotation de la matrice de l’objet d’affichage en quaternion avant l’interpolation. Un quaternion garantit le chemin le plus efficace et le plus court pour la rotation. Il permet également d’obtenir une rotation sans gimbal lock. Un gimbal lock peut se produire lorsque les angles d’Euler sont utilisés et que chaque axe est traité indépendamment. Lors d’une rotation autour de plusieurs axes, les axes peuvent s’aligner et entraîner des résultats inattendus. La rotation quaternion permet d’éviter le gimbal lock.

Les prochains appels à la méthode interpolate() peuvent produire un effet tel qu’un objet d’affichage démarrant rapidement, puis s’approchant lentement d’un autre objet d’affichage. Par exemple, si vous définissez le paramètre thisMat sur l’objet Matrix3D renvoyé, le paramètre toMat sur l’objet Matrix3D associé de l’objet d’affichage cible et le paramètre percent sur 0.1, l’objet d’affichage se déplace de dix pour-cent vers l’objet cible. Lors des prochains appels ou dans les images suivantes, l’objet parcourt dix pour cent des 90 pour cent restants, puis dix pour cent de la distance restante jusqu’à atteindre la cible.

Paramètres

Eléments de l’API associés

Interpole cette matrice vers les transformations de translation, de rotation et d'échelle de la matrice cible.

La méthode interpolateTo() permet d’éviter des résultats non désirés pouvant survenir lors de l’utilisation de méthodes telles que les propriétés de rotation de l’axe de l’objet d’affichage. La méthode interpolateTo() invalide la valeur mise en cache de la propriété rotation de l’objet d’affichage et convertit les éléments d’orientation de la matrice de l’objet d’affichage en quaternion avant l’interpolation. Un quaternion garantit le chemin le plus efficace et le plus court pour la rotation. Il permet également d’obtenir une rotation sans gimbal lock. Un gimbal lock peut se produire lorsque les angles d’Euler sont utilisés et que chaque axe est traité indépendamment. Lors d’une rotation autour de plusieurs axes, les axes peuvent s’aligner et entraîner des résultats inattendus. La rotation quaternion permet d’éviter le gimbal lock.

Remarque : Dans le cas d’une interpolation, la valeur de redimensionnement de la matrice est réinitialisée et cette dernière est normalisée.

Les prochains appels à la méthode interpolateTo() peuvent produire un effet tel qu’un objet d’affichage démarrant rapidement, puis s’approchant lentement d’un autre objet d’affichage. Par exemple, si le paramètre percent est défini sur 0.1, l’objet d’affichage se déplace de 10 % vers l’objet cible spécifié par le paramètre toMat. Lors des prochains appels ou dans les images suivantes, l’objet parcourt dix pour cent des 90 pour cent restants, puis dix pour cent de la distance restante jusqu’à atteindre la cible.

Paramètres

Eléments de l’API associés

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

Inverse la matrice actuelle. Une matrice inversée a la même taille que l’originale mais effectue la transformation opposée à la matrice originale. Par exemple, si un objet de la matrice d’origine pivote autour de l’axe x dans une direction, l’objet de la matrice inverse pivote autour de l’axe dans la direction opposée. L’application d’une matrice inversée à un objet annule la transformation effectuée par la matrice d’origine. Lorsqu’une matrice est multipliée par sa matrice inverse, le résultat est une matrice d’identité.

L’inverse d’une matrice peut être utilisé pour diviser une matrice par une autre. Une manière de diviser une matrice A par une matrice B consiste à multiplier la matrice A par l’inverse de la matrice B. La matrice inverse peut également être utilisée avec un espace de caméra. Lorsque la caméra se déplace dans l’espace monde, l’objet présent dans le monde doit se déplacer dans le sens opposé pour passer de l’espace monde à l’espace de la caméra ou à l’espace visuel. Par exemple, si la caméra se rapproche, les objets deviennent plus gros. En d’autres termes, si la caméra se déplace vers le bas de l’axe z du monde, l’objet se déplace vers le haut de ce même axe.

La méthode invert() remplace la matrice actuelle par une matrice inversée. Pour inverser une matrice sans modifier la matrice actuelle, commencez par copier la matrice actuelle à l’aide de la méthode clone(), puis appliquez la méthode invert() à la copie.

L’objet Matrix3D doit être réversible.

Eléments de l’API associés

Fait pivoter l’objet d’affichage de sorte qu’il fasse face à une position spécifiée. Cette méthode autorise une modification en place de l’orientation. Le vecteur de direction vers l’avant de l’objet d’affichage (objet Vector3D at) pointe vers la position relative au monde spécifiée. La direction vers le haut de l’objet d’affichage est spécifiée par l’objet Vector3D up.

La méthode pointAt() invalide la valeur mise en cache de la propriété rotation de l’objet d’affichage. La méthode décompose la matrice de l’objet d’affichage et modifie les éléments de rotation pour que l’objet tourne vers la position spécifiée. Elle recompose ensuite (met à jour) la matrice de l’objet d’affichage, qui effectue la transformation. Si l’objet pointe vers une cible en mouvement, par exemple vers la position d’un objet en mouvement, à chaque appel suivant, la méthode fait pivoter l’objet vers la cible en mouvement.

Remarque : si vous utilisez la méthode Matrix3D.pointAt() sans définir les paramètres facultatifs, un objet cible n’est pas face à la position par rapport au monde spécifiée par défaut. Vous devez définir les valeurs de at sur l’axe -y (0,-1,0) et up sur l’axe -z (0,0,-1).

Paramètres

Eléments de l’API associés

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

Ajoute une matrice au début en multipliant l’objet Matrix3D actuel par un autre objet Matrix3D. Le résultat combine les deux transformations de matrice.

Les multiplications de matrices diffèrent des additions de matrices. La multiplication de matrices n’est pas commutative. En d’autres termes, A fois B n’est pas égal à B fois A. Avec la méthode prepend(), la multiplication s’effectue à partir du côté droit, ce qui signifie que l’objet Matrix3D rhs est situé à droite de l’opérateur de la multiplication.

Les modifications apportées par la méthode prepend() sont relatives à l’espace de l’objet. En d’autres termes, elles sont toujours relatives à l’image de référence initiale de l’objet.

La méthode prepend() remplace la matrice actuelle par la matrice ajoutée. Si vous souhaitez ajouter deux matrices sans modifier la matrice actuelle, commencez par copier la matrice actuelle à l’aide de la méthode clone(), puis appliquez la méthode prepend() à la copie.

Paramètres

Eléments de l’API associés

Ajoute une rotation incrémentielle au début d’un objet Matrix3D. Lorsque l’objet Matrix3D est appliqué à un objet d’affichage, la matrice exécute la rotation avant les autres transformations dans l’objet Matrix3D.

La rotation de l’objet d’affichage est définie par un axe, un degré incrémentiel de rotation autour de l’axe et un point de pivot facultatif pour le centre de la rotation de l’objet. L’axe peut être toute direction générale. Les axes courants sont X_AXIS (Vector3D(1,0,0)), Y_AXIS (Vector3D(0,1,0)) et Z_AXIS (Vector3D(0,0,1)). Dans la terminologie de l’aviation, la rotation autour de l’axe y est appelée lacet. La rotation autour de l’axe x est appelée tangage ou pas. La rotation autour de l’axe z est appelée roulis.

L’ordre des transformations a son importance. Une rotation suivie d’une transformation de translation n’a pas le même effet qu’une translation suivie d’une rotation.

L’effet de la rotation n’est pas absolu. L’effet est relatif à l’objet, relatif à l’image de référence de la position et de l’orientation d’origine. Pour apporter une modification absolue à la transformation, utilisez la méthode recompose().

Lorsque la transformation de la méthode prependRotation() est appliquée à un objet Matrix3D, les valeurs mises en cache de la propriété rotation de l’objet d’affichage sont invalidées.

Pour qu’un objet d’affichage pivote autour d’un point spécifique par rapport à son emplacement, une méthode consiste à définir la translation de l’objet sur le point spécifié, à faire pivoter l’objet avec la méthode prependRotation() et à lui appliquer une translation pour le ramener dans sa position d’origine. Dans l’exemple suivant, l’objet d’affichage 3D myObject effectue une rotation sur l’axe y autour de la coordonnée (10,10,0).

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

Paramètres

Eléments de l’API associés

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

Ajoute une modification d’échelle incrémentielle le long des axes x, y et z au début d’un objet Matrix3D. Lorsque l’objet Matrix3D est appliqué à un objet d’affichage, la matrice exécute les changements d’échelle avant les autres transformations dans l’objet Matrix3D. Les changements sont relatifs à l’objet, relatifs à l’image de référence de la position et de l’orientation d’origine. Le facteur d’échelle par défaut est (1.0, 1.0, 1.0).

L’échelle est définie comme un ensemble de trois modifications incrémentielles le long des trois axes (x,y,z). Vous pouvez multiplier chaque axe par un nombre différent. Lorsque des modifications d’échelle sont appliquées à un objet d’affichage, la taille de l’objet augmente ou diminue. Par exemple, définir les axes x, y et z sur deux double la taille de l’objet, alors que définir les axes sur 0.5 réduit la taille de moitié. Pour être certain que la transformation d’échelle n’affecte qu’un axe spécifique, définissez les autres paramètres sur un. Un paramètre de un signifie qu’aucune modification d’échelle n’est apportée le long de l’axe spécifique.

La méthode prependScale() peut être utilisée pour un redimensionnement mais aussi pour la gestion des distorsions, par exemple pour étirer ou compacter un objet d’affichage. Elle peut également être utilisée pour faire un zoom avant et arrière sur un emplacement. Les transformations d’échelle sont exécutées automatiquement pendant la rotation et la translation d’un objet d’affichage.

L’ordre des transformations a son importance. Un redimensionnement suivi d’une transformation de translation n’a pas le même effet qu’une translation suivie d’une transformation de redimensionnement.

Paramètres

Eléments de l’API associés

Ajoute une translation incrémentielle, repositionnement le long des axes x, y et z, au début d’un objet Matrix3D. Lorsque l’objet Matrix3D est appliqué à un objet d’affichage, la matrice exécute les modifications de translation avant les autres transformations dans l’objet Matrix3D.

La translation définit la distance sur laquelle l’objet d’affichage se déplace, depuis son emplacement actuel le long des axes x, y et z. La méthode prependTranslation() définit la translation comme un ensemble de trois modifications incrémentielles le long des trois axes (x,y,z). Pour que la translation n’affecte qu’un axe spécifique, définissez les autres paramètres sur zéro. Un paramètre de valeur zéro signifie qu’aucune modification n’a lieu le long de l’axe spécifique.

Les modifications de translation ne sont pas absolues. L’effet est relatif à l’objet, relatif à l’image de référence de la position et de l’orientation d’origine. Pour apporter une modification absolue à la matrice de transformation, utilisez la méthode recompose(). L’ordre des transformations a aussi son importance. Une translation suivie d’une transformation de rotation n’a pas le même effet qu’une rotation suivie d’une transformation de translation. Lorsque la méthode prependTranslation() est utilisée, l’objet d’affichage poursuit son déplacement dans la direction à laquelle il fait face, quelles que soient les autres transformations. Par exemple, si un objet d’affichage faisait face à l’axe x positif, il poursuit son déplacement dans le sens spécifié par la méthode prependTranslation(), quelle que soit la rotation ayant été appliquée à l’objet. Pour que les modifications de translation se produisent après les autres transformations, utilisez la méthode appendTranslation().

Paramètres

Eléments de l’API associés

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

Définit les paramètres de translation, de rotation et d’échelle de la matrice de transformation. Contrairement aux modifications incrémentielles apportées par les propriétés de rotation de l’objet d’affichage ou les méthodes de rotation de l’objet Matrix3D, les modifications apportées par la méthode recompose() sont des modifications absolues. La méthode recompose() remplace la transformation de la matrice.

Pour modifier la transformation de la matrice avec une image de référence de parent absolu, récupérez les paramètres avec la méthode decompose() et apportez les modifications appropriées. Vous pouvez alors définir l’objet Matrix3D sur la transformation modifiée à l’aide de la méthode recompose().

Le paramètre de la méthode recompose() spécifie le style d’orientation utilisé pour la transformation. L’orientation par défaut est eulerAngles, qui définit l’orientation avec trois angles de rotation distincts pour chaque axe. Les rotations s’effectuent consécutivement et ne modifient pas l’axe des autres rotations. Les propriétés de rotation de l’axe de l’objet d’affichage effectuent une transformation de style d’orientation Angles d’Euler. Les autres options de style d’orientation sont axisAngle et quaternion. L’orientation Angle des axes détermine l’orientation en combinant un axe et un angle. L’axe autour duquel l’objet pivote est un vecteur unitaire qui représente une direction. L’angle représente l’amplitude de la rotation autour du vecteur. La direction détermine également l’endroit qui fait face à l’objet d’affichage et l’angle détermine la direction du haut. Les méthodes appendRotation() et prependRotation() utilisent l’orientation Angle des axes. L’orientation quaternion utilise des nombres complexes et le quatrième élément d’un vecteur. Une orientation est représentée par les trois axes de rotation (x,y,z) et un angle de rotation (w). La méthode interpolate() utilise l’orientation quaternion.

Paramètres

Eléments de l’API associés

Utilise la matrice de transformation pour transformer un objet Vector3D d’une coordonnée spatiale en une autre. L’objet Vector3D renvoyé contient les nouvelles coordonnées après transformation. Toutes les transformations matricielles, y compris la translation, s’appliquent à l’objet Vector3D.

Si le résultat de la méthode transformVector() a été appliqué à la position d’un objet d’affichage, seule la position de cet objet change. Les éléments de rotation et d’échelle de l’objet d’affichage demeurent les mêmes.

Remarque : cette méthode définit automatiquement le composant w de l’objet Vector3D transmis sur 1.0.

Paramètres

Eléments de l’API associés

Utilise la matrice de transformation pour transformer un vecteur de nombres d’une coordonnée spatiale en une autre. La méthode tranformVectors() lit chaque groupe de trois nombres dans l’objet Vector vin comme une coordonnée 3D (x,y,z) et place une coordonnée 3D transformée dans l’objet Vector vout. Toutes les transformations matricielles, y compris la translation, sont appliquées à l’objet Vector vin. Vous pouvez utiliser la méthode transformVectors() pour restituer et transformer un objet 3D en tant que maillage. Un maillage est un ensemble de sommets ou points qui définissent la forme de l’objet.

Paramètres

Eléments de l’API associés

Convertit l’objet Matrix3D en cours en une matrice dont les lignes et les colonnes sont permutées. Par exemple, si le paramètre rawData de l’objet Matrix3D actuel contient les 16 nombres suivants, 1,2,3,4,11,12,13,14,21,22,23,24,31,32,33,34, la méthode transpose() lit chaque ensemble de quatre éléments en tant que ligne et transforme ces lignes en colonnes. Le résultat est une matrice dont le paramètre rawData est : 1,11,21,31,2,12,22,32,3,13,23,33,4,14,24,34.

La méthode transpose() remplace la matrice actuelle par une matrice transposée. Pour transposer une matrice sans modifier la matrice actuelle, commencez par copier cette dernière à l’aide de la méthode clone(), puis appliquez la méthode transpose() à la copie.

Une matrice orthogonale est une matrice carrée dont la transposition est égale à son inverse.