[3D] [Débutant] Matrices de ransformation

**Pedro** · 12/01/2006, 21h30

Salut à tous

J'ai un petit problème:
J'affiche un chtit vaisseau spatial qui a une matrice de transformation propre.
Je sais faire une transformation standard mais je ne sais pas faire des rotations dites "locales"...
En gros, mon vaisseau tourne quand j'utilise la manette dans les axes X et Y... Mais lorsqu'il tourne autour de X (ou de Y suivant l'odre dans lequel je fais la modification de la matrice) il ne tourne pas comme il faut

En gros ce que je voudrais:
Je fais tourner le vaisseau autour de sa longueur (roulis pour les conaisseurs) et après je le fais tourner autour de sa largeur (tangage). Je voudrais une méthode pour appliquer ces rotations de façon à ce que les rotations se fassent localement au vaisseau.
Je ne sais pas si j'ai bien expliqué ni si je suis sur le bon forum (j'utilise DirectX

) mais je sais que c'est une méthode que beaucoup d'entre vous utilisent pour afficher un objet dont l'orientation a été modifiée par la manette ou autre.
Merci d'avance

**mathk** · 12/01/2006, 21h35

tien ca peut ptêtre t'aider:
http://superbat2003.tripod.com/tut_19.htm

**Laurent Gomila** · 12/01/2006, 22h02

Personnellement je n'ai pas compris quel était précisément ce que tu n'arrivais pas à faire, ni ce que tu entendais par "local".

**Pedro** · 12/01/2006, 23h00

Salut

Envoyé par mathk

tien ca peut ptêtre t'aider:
http://superbat2003.tripod.com/tut_19.htm

Merci mais je savais déjà faire les rotations "globales"

Envoyé par Loulou24

Personnellement je n'ai pas compris quel était précisément ce que tu n'arrivais pas à faire, ni ce que tu entendais par "local".

Oui je me suis très mal expliqué, je vais essayer de mieux faire.
J'ai un vaisseau. Son axe des X est son envergure (ailes) et son Y, sa longueur (de la queue au nez).
Lorsque je tire sur le manche, il lève le nez, je pousse le manche, il baisse le nez: Rotation axe X positive et négative... Jusque là OK.
Lorsque je pousse le manche à gauche ou à droite, il tourne sur lui-même: rotation axe Y.
Seulement, lorsque j'agis sur les 2 en même temps, le second applique la rotation comme si elle était calculée depuis la position d'origine.
Donc, je voudrais faire en sorte que, quelque soit l'orientation du vaisseau, il tourne sur ses axes propres et non celui du monde (d'où le terme "local").
Je pense qu'il faut que jai un Vecteur qui représente l'orientation du vaisseau mais je ne sais pas comment m'y prendre...
Voila j'espère avoir mieux expliqué

merci pour vos réponses en tout cas

**Omeyocan** · 13/01/2006, 09h54

Envoyé par Pedro204

Salut à tous

J'ai un petit problème:
J'affiche un chtit vaisseau spatial qui a une matrice de transformation propre.
Je sais faire une transformation standard mais je ne sais pas faire des rotations dites "locales"...

Pré-multiplication des matrices ! Il faut (schématiquement, car c'est optimisable) que tu ai deux matrices de rotation (XYZ), une matrice représentant la rotation actuelle de ton objet, il faut ensuite construire une autre matrice de rotation qui correspond à la rotation que tu veux lui appliquer, et là, au lieu de remplacer ta matrice actuelle par ta nouvelle rotation, tu multiplie ta matrice d'ajout de rotation local, par la matrice de rotation global de ton object, le résultat te donne une matrice de rotation global, MAIS ayant subit une transformation en coordonnées locales

Par exemple, imaginons que tu ai ton vaisseau, avec une rotation quelconque dans le monde, sa matrice de rotation : WorldRotate
Tu veux lui appliquer une rotation en coordonné objet/relative/local quelconque RX, RY, RZ...
D'abord tu construit une nouvelle matrice de rotation à partir de RX, RY et RZ qu'on appellera AddLocalRotation
Tu prends ta matrice de rotation locale, et tu la multiplie par la matrice de rotations monde de ton objet : ResultMat = AddLocalRotation * WorldRotate
Finalement, tu put le résultat dans ta matrice de monde : WorldRotate = ResultMat

**Pedro** · 14/01/2006, 21h42

Salut

Super Omeyocan

Je te remercie je vais essayer

Je passe en résolu

**Pedro** · 16/01/2006, 13h35

Salut

Bon ben comme je n'y arrive pas, je dérésolute...

Bon, vous n'allez pas non plus me faire un cours de maths (quoique j'en aurais visiblement bien besoin

) mais si vous pouviez m'expliquer pas à pas comment faire parce que je n'y arrive pas du tout. J'ai beau tourner le problème dans tous les sens, rien ne marche

**Omeyocan** · 16/01/2006, 13h46

bon, je choperais mon code source ce soir et le collerait ici... ca sera sans doute plus simple...

**Pedro** · 16/01/2006, 13h51

Super merci encore une fois Omeyocan

Que ton chemin soit parfumé de pétales de roses et de jasmin, que ton nom soit vénéré pendant des siècles et des siècles, que ta famille etc... J'en fais trop là non?

**Laurent Gomila** · 16/01/2006, 13h52

Je déplace ton post vers le forum Algorithmes, car il s'agit d'un problème de maths plus que de DirectX.

**Omeyocan** · 16/01/2006, 14h14

en attendant :

World Space

This is the space that an object is in after having all of its transformations
applied to it. A world space transformation is the the very last
transformation that would be applied to the object.

Object Space

This is the space that an object is defined in. An object space transformation
would be the first transformation that was be applied to an object. This is
the same as pre-transform space.

Post Transform Space

This is the space in which the object lives after having the transformations of
its transform node applied. For example, when a primitive object is created in
Maya, there is a shape node which defined the geometry and a transform node
which positions/orients the geometry. The space that the geometry is in is
object space. After applying the transformations of the transform node to the
geometry, the transformed geometry is in post transform space.

Transform Space

This space depends on the type of transformation being applied. Transform nodes
define a fixed sequence of affine transformations. Basically, there is scale
followed by rotation and finally translation. There are four spaces here:

1) the space before applying the scale
2) the space after the scale but before the rotation
3) the space between the rotation and translation and
4) the space after the translation.

Space 1) is pre-transform space.
Space 4) is post-transform space.
Spaces 2) and 3) define transform spaces.

If applying a transform space scale, this transform will be applied after the
current scale but before the rotation (space 2). If applying a transform space
rotation, this transform will be applied after the current rotation but before
the translation. Applying a translation in transform space, the translation
will be applied after the current translation.

Traditionnellement, c'est un simple "Transform Space" qui est pratiqué... c'est de la transformation "world"

**Pedro** · 17/01/2006, 13h01

Salut

Merci Loulou d'avoir déplacé mon sujet

Pour Omeyocan: J'ai déjà esséy de faire la transformation locale avant la transformation globale... Mais (évidemment) ça ne marche pas...

J'attends donc ton code avec impatience

**Omeyocan** · 17/01/2006, 16h14

Envoyé par Pedro204

Salut

Merci Loulou d'avoir déplacé mon sujet

Pour Omeyocan: J'ai déjà esséy de faire la transformation locale avant la transformation globale... Mais (évidemment) ça ne marche pas...

J'attends donc ton code avec impatience

Explique comment tu as procédé pour faire ta transformation... en fait le sens de multiplication des matrices est déterminant...

**Omeyocan** · 17/01/2006, 20h29

Bon, voilà, alors attention, c'est brutale, il y'a l'algo des multiplications de matrices dirrectement codé dans la fonction. C'est une fonction qui sert à additionner une rotation quelconque, à un objet, on peut ajouter la rotation en coordonné monde, ou objet (local).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
//-------------------------------------------------------------
inline void OTransform::rotateEulerBy(const OVector& rotation, OSpace::space space)
{
 
	float cx = cos(-rotation.x);
	float sx = sin(-rotation.x);
 
	float cy = cos(rotation.y);
	float sy = sin(rotation.y);
 
	float cz = cos(-rotation.z);
	float sz = sin(-rotation.z);
 
	float cxsy = cx * sy; 
	float sxsy = sx * sy;
 
	float mat0 = cy * cz; 
	float mat1 = -cy * sz; 
	float mat2 = -sy;
 
	float mat4 = -sxsy * cz + cx * sz; 
	float mat5 = sxsy * sz + cx * cz; 
	float mat6 = -sx * cy;
 
	float mat8 = cxsy * cz + sx * sz; 
	float mat9 = -cxsy * sz + sx * cz; 
	float mat10 = cx * cy;
 
	float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
 
	switch (space)
	{
	case OSpace::cObject:
 
		tmp0 = mat0 * OTRANSFORMDATA->rotationMatrix[0] + mat1 * OTRANSFORMDATA->rotationMatrix[3] + mat2 * OTRANSFORMDATA->rotationMatrix[6];
		tmp1 = mat0 * OTRANSFORMDATA->rotationMatrix[1] + mat1 * OTRANSFORMDATA->rotationMatrix[4] + mat2 * OTRANSFORMDATA->rotationMatrix[7];
		tmp2 = mat0 * OTRANSFORMDATA->rotationMatrix[2] + mat1 * OTRANSFORMDATA->rotationMatrix[5] + mat2 * OTRANSFORMDATA->rotationMatrix[8];
 
		tmp3 = mat4 * OTRANSFORMDATA->rotationMatrix[0] + mat5 * OTRANSFORMDATA->rotationMatrix[3] + mat6 * OTRANSFORMDATA->rotationMatrix[6];
		tmp4 = mat4 * OTRANSFORMDATA->rotationMatrix[1] + mat5 * OTRANSFORMDATA->rotationMatrix[4] + mat6 * OTRANSFORMDATA->rotationMatrix[7];
		tmp5 = mat4 * OTRANSFORMDATA->rotationMatrix[2] + mat5 * OTRANSFORMDATA->rotationMatrix[5] + mat6 * OTRANSFORMDATA->rotationMatrix[8];
 
		tmp6 = mat8 * OTRANSFORMDATA->rotationMatrix[0] + mat9 * OTRANSFORMDATA->rotationMatrix[3] + mat10 * OTRANSFORMDATA->rotationMatrix[6];
		tmp7 = mat8 * OTRANSFORMDATA->rotationMatrix[1] + mat9 * OTRANSFORMDATA->rotationMatrix[4] + mat10 * OTRANSFORMDATA->rotationMatrix[7];
		tmp8 = mat8 * OTRANSFORMDATA->rotationMatrix[2] + mat9 * OTRANSFORMDATA->rotationMatrix[5] + mat10 * OTRANSFORMDATA->rotationMatrix[8];
 
		OTRANSFORMDATA->rotationMatrix[0] = tmp0;
		OTRANSFORMDATA->rotationMatrix[1] = tmp1;
		OTRANSFORMDATA->rotationMatrix[2] = tmp2;
		OTRANSFORMDATA->rotationMatrix[3] = tmp3;
		OTRANSFORMDATA->rotationMatrix[4] = tmp4;
		OTRANSFORMDATA->rotationMatrix[5] = tmp5;
		OTRANSFORMDATA->rotationMatrix[6] = tmp6;
		OTRANSFORMDATA->rotationMatrix[7] = tmp7;
		OTRANSFORMDATA->rotationMatrix[8] = tmp8;
		break;
	case OSpace::cWorld:
 
		tmp0 = OTRANSFORMDATA->rotationMatrix[0] * mat0 + OTRANSFORMDATA->rotationMatrix[1] * mat4 + OTRANSFORMDATA->rotationMatrix[2] * mat8;
		tmp1 = OTRANSFORMDATA->rotationMatrix[0] * mat1 + OTRANSFORMDATA->rotationMatrix[1] * mat5 + OTRANSFORMDATA->rotationMatrix[2] * mat9;
		tmp2 = OTRANSFORMDATA->rotationMatrix[0] * mat2 + OTRANSFORMDATA->rotationMatrix[1] * mat6 + OTRANSFORMDATA->rotationMatrix[2] * mat10;
 
		tmp3 = OTRANSFORMDATA->rotationMatrix[3] * mat0 + OTRANSFORMDATA->rotationMatrix[4] * mat4 + OTRANSFORMDATA->rotationMatrix[5] * mat8;
		tmp4 = OTRANSFORMDATA->rotationMatrix[3] * mat1 + OTRANSFORMDATA->rotationMatrix[4] * mat5 + OTRANSFORMDATA->rotationMatrix[5] * mat9;
		tmp5 = OTRANSFORMDATA->rotationMatrix[3] * mat2 + OTRANSFORMDATA->rotationMatrix[4] * mat6 + OTRANSFORMDATA->rotationMatrix[5] * mat10;
 
		tmp6 = OTRANSFORMDATA->rotationMatrix[6] * mat0 + OTRANSFORMDATA->rotationMatrix[7] * mat4 + OTRANSFORMDATA->rotationMatrix[8] * mat8;
		tmp7 = OTRANSFORMDATA->rotationMatrix[6] * mat1 + OTRANSFORMDATA->rotationMatrix[7] * mat5 + OTRANSFORMDATA->rotationMatrix[8] * mat9;
		tmp8 = OTRANSFORMDATA->rotationMatrix[6] * mat2 + OTRANSFORMDATA->rotationMatrix[7] * mat6 + OTRANSFORMDATA->rotationMatrix[8] * mat10;
 
		OTRANSFORMDATA->rotationMatrix[0] = tmp0;
		OTRANSFORMDATA->rotationMatrix[1] = tmp1;
		OTRANSFORMDATA->rotationMatrix[2] = tmp2;
		OTRANSFORMDATA->rotationMatrix[3] = tmp3;
		OTRANSFORMDATA->rotationMatrix[4] = tmp4;
		OTRANSFORMDATA->rotationMatrix[5] = tmp5;
		OTRANSFORMDATA->rotationMatrix[6] = tmp6;
		OTRANSFORMDATA->rotationMatrix[7] = tmp7;
		OTRANSFORMDATA->rotationMatrix[8] = tmp8;
		break;
	}
 
	setTransformCached(false);
}

Donc :
OTRANSFORMDATA->rotationMatrix : c'est la matrice de rotation (float[9])de l'objet en question, cette matrice est sauvegardé, (elle n'est pas reconstruite à chaque appel) elle représente la rotation finale de l'objet

mat0-mat9 : c'est la matrice de rotation créée sur le champ à partir des valeurs de rotations qu'on veut additionner à notre objet

tmp0-tmp9 : c'est la matrice temporaire qui va contenire le résultat de la multiplication des deux matrices

(note, c'est un aglo de multuplication de matrice 3*3, ce qui est suffisant pour les rotations)

Comme tu le remarque, il y'a un switch pour définir quelle type de rotation on veut appliquer, dans le premier cas c'est l'addition en coordonnée Objet, c'est à dire local.

Tu remarque que c'est en fait la matrice d'addition (créé sur le champ) qui est multipliée par la matrice finale (finale pas pour longtemps puisque nous allons la transformer justement) le résultat de cette multiplication, donne une rotation en coordonnée locale... le resultat est finalement placer dans la matrice finale, pour la mettre à jour

en racourci ça donne :

matAddition = vector(x, y, z) // evaluation de la rotation à additionner
matTemp = matAddition * matRotation // construction de la composante
matRotation = matTemp // mise à jour de la matrice de rotation

Pour une addition en coordonnée monde, c'est exactement l'inverse, c'est la matrice de rotation résidente, qui est multiplié par la matrice d'addition

matRotation *= matAddition

Pour les translations ça marche de la même manière, le vecteur finale de la translation est soit prémultiplier, soit postmultiplier selon qu'on veut une translation en coordonné monde, ou objet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//-------------------------------------------------------------
inline void OTransform::addTranslation(const OVector& translate, OSpace::space space)
{
	switch (space)
	{
	case OSpace::cObject:
		OTRANSFORMDATA->translation.x += translate.x * OTRANSFORMDATA->rotationMatrix[0] + translate.y * OTRANSFORMDATA->rotationMatrix[3] + translate.z * OTRANSFORMDATA->rotationMatrix[6];
		OTRANSFORMDATA->translation.y += translate.x * OTRANSFORMDATA->rotationMatrix[1] + translate.y * OTRANSFORMDATA->rotationMatrix[4] + translate.z * OTRANSFORMDATA->rotationMatrix[7];
		OTRANSFORMDATA->translation.z += translate.x * OTRANSFORMDATA->rotationMatrix[2] + translate.y * OTRANSFORMDATA->rotationMatrix[5] + translate.z * OTRANSFORMDATA->rotationMatrix[8];
		break;
	case OSpace::cWorld:
		OTRANSFORMDATA->translation += translate;
		break;
	}	
	setTransformCached(false);
}

**Omeyocan** · 17/01/2006, 20h31

J'ai la meme avec une rotation par un quaternion si tu veux...

**Pedro** · 17/01/2006, 20h54

Envoyé par Omeyocan

J'ai la meme avec une rotation par un quaternion si tu veux...

Hohoho

C'est quoi un quaternion

J'ai bien fait d'ajouter le tag [Débutant]

En tout cas merci beaucoup Omeyocan

Il ne me reste plus qu'à... traduire tout ça en Delphi!!

**Omeyocan** · 18/01/2006, 00h29

Un quaternion c'est la contraction de quater moinion, ce sont des gens dont on a emputé les quatres membres...
Ok, un Quaternion c'est un "nombre complexe"... je te passe la théorie bizaroïde qu'il y'a derriere (avec le carré de machin qui est = a -1) en gros un quaternion est une sorte de vecteur de rotation (alors qu'un vecteur ne décrit jamais qu'une translation, vue ?), on aime dire que le quaternion est 4D plutot que 3D, mais je suis pas d'accord, mais c'est pas grave... un quaternion est composé d'une partie réelle et une partie imaginaire (jargon de matheu), la partie réelle, c'est un vecteur : x,y,z et la partie imaginaire, c'est un scalaire : w... bon ça a l'air tres chiadé et complexe comme ça, mais en fait c'est bête comme cul.
la partie scalaire décrite un ANGLE de rotation et la partie vecteur décrit un AXE de rotation autour duquel l'objet vat être tourné...
Donc, dans une rotation classique (euler) tu décrit en fait une rotation avec UN vecteur, selon TROIS axes : rotation sur l'axe X, sur l'axe Y et enfin Z... Avec un quaternion, tu va en fait positionner un axe de rotation arbitraire dont le vecteur sera X, Y, Z et tu fera tourner ta geométrie autour de cet axe selon un angle W...
Exemple, pour une rotation de 0.5 radian sur l'axe X :
en euler : 0.5, 0.0, 0.0
en quaternion : 1.0, 0.0, 0.0, 0.5

**Omeyocan** · 18/01/2006, 00h38

en bonus, un algo optimisé pour construire une matrice de transformation, ca évite de faire 5 multiplications de matrices à la suite avec BEAUCOUP de multiplications inutiles par 0 ( ONODEDATA->matrix.matrix c'est la matrice de transformation finale de l'objet) :

//-------------------------------------------------------------
inline void OTransform::updateTransform()
{
ONODEDATA->matrix.matrix[0] = OTRANSFORMDATA->rotationMatrix[0] * OTRANSFORMDATA->scale.x;
ONODEDATA->matrix.matrix[1] = OTRANSFORMDATA->rotationMatrix[1] * OTRANSFORMDATA->scale.x;
ONODEDATA->matrix.matrix[2] = OTRANSFORMDATA->rotationMatrix[2] * OTRANSFORMDATA->scale.x;

ONODEDATA->matrix.matrix[4] = OTRANSFORMDATA->rotationMatrix[3] * OTRANSFORMDATA->scale.y;
ONODEDATA->matrix.matrix[5] = OTRANSFORMDATA->rotationMatrix[4] * OTRANSFORMDATA->scale.y;
ONODEDATA->matrix.matrix[6] = OTRANSFORMDATA->rotationMatrix[5] * OTRANSFORMDATA->scale.y;

ONODEDATA->matrix.matrix[8] = OTRANSFORMDATA->rotationMatrix[6] * OTRANSFORMDATA->scale.z;
ONODEDATA->matrix.matrix[9] = OTRANSFORMDATA->rotationMatrix[7] * OTRANSFORMDATA->scale.z;
ONODEDATA->matrix.matrix[10] = OTRANSFORMDATA->rotationMatrix[8] * OTRANSFORMDATA->scale.z;

float A, B, C;
A = (((-OTRANSFORMDATA->scalePivot.x * OTRANSFORMDATA->scale.x) + OTRANSFORMDATA->scalePivot.x) -OTRANSFORMDATA->rotatePivot.x);
B = (((-OTRANSFORMDATA->scalePivot.y * OTRANSFORMDATA->scale.y) + OTRANSFORMDATA->scalePivot.y) -OTRANSFORMDATA->rotatePivot.y);
C = (((-OTRANSFORMDATA->scalePivot.z * OTRANSFORMDATA->scale.z) + OTRANSFORMDATA->scalePivot.z) -OTRANSFORMDATA->rotatePivot.z);

ONODEDATA->matrix.matrix[12] = ((A * OTRANSFORMDATA->rotationMatrix[0] + B * OTRANSFORMDATA->rotationMatrix[3] + C * OTRANSFORMDATA->rotationMatrix[6]) + OTRANSFORMDATA->rotatePivot.x) + OTRANSFORMDATA->translation.x;
ONODEDATA->matrix.matrix[13] = ((A * OTRANSFORMDATA->rotationMatrix[1] + B * OTRANSFORMDATA->rotationMatrix[4] + C * OTRANSFORMDATA->rotationMatrix[7]) + OTRANSFORMDATA->rotatePivot.y) + OTRANSFORMDATA->translation.y;
ONODEDATA->matrix.matrix[14] = ((A * OTRANSFORMDATA->rotationMatrix[2] + B * OTRANSFORMDATA->rotationMatrix[5] + C * OTRANSFORMDATA->rotationMatrix[8]) + OTRANSFORMDATA->rotatePivot.z) + OTRANSFORMDATA->translation.z;
}