Questions sur les quaternions.

**Bakura** · 21/06/2007, 14h50

Bonjour,

Voilà j'apprends actuellement avec le livre 3d Math Primer for Graphics and Game Development les rudiments des mathématiques (matrices, vecteurs, quaternions...). Les vecteurs n'étaient pas nouveaux mais les matrices, quaternions et angles d'euler, si.

Mais j'ai un peu de soucis à comprendre quelques fonctions qu'ils incluent dans leur code. Par exemple, dans la classe d'une matrice de rotation, il y a deux fonctions pour créer une matrice de rotation à partir d'un quaternion : fromInertialToObjectQuaternion et fromObjectToInertialQuaternion, le suel changement étant certains signes. J'ai bien compris ce qu'était les coordonnées objet et inertial (comment on dit en français ?), mais je comprends pas l'intérêt de ces deux fonctions, alors que la FAQ n'en donne qu'une seule.

**Laurent Gomila** · 21/06/2007, 14h57

Je n'ai jamais vu une telle distinction dans les moteurs 3D que j'ai pu utiliser. C'est quoi la différence entre "object" et "inertial" ?

**Bakura** · 21/06/2007, 15h02

Moi aussi ça m'étonne, mais ils font cette distinction partout. Dans la classe EulerAngles tu as :

fromObjectToIntertialQuaternion
fromInertialToObjectQuaternion

fromObjectToWorldMatrix
fromWorldToObjectMatrix

Pour les quaternions !

setRotateObjectToInertial (const EulerAngles & orientation)
setRotateInertialToObject ("")

Et pour le cas précis que j'ai dit en premier message :

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
85
//---------------------------------------------------------------------------
// RotationMatrix::fromInertialToObjectQuaternion
//
// Setup the matrix, given a quaternion that performs an inertial->object
// rotation
//
// See 10.6.3
 
void	RotationMatrix::fromInertialToObjectQuaternion(const Quaternion &q) {
 
	// Fill in the matrix elements.  This could possibly be
	// optimized since there are many common subexpressions.
	// We'll leave that up to the compiler...
 
	m11 = 1.0f - 2.0f * (q.y*q.y + q.z*q.z);
	m12 = 2.0f * (q.x*q.y + q.w*q.z);
	m13 = 2.0f * (q.x*q.z - q.w*q.y);
 
	m21 = 2.0f * (q.x*q.y - q.w*q.z);
	m22 = 1.0f - 2.0f * (q.x*q.x + q.z*q.z);
	m23 = 2.0f * (q.y*q.z + q.w*q.x);
 
	m31 = 2.0f * (q.x*q.z + q.w*q.y);
	m32 = 2.0f * (q.y*q.z - q.w*q.x);
	m33 = 1.0f - 2.0f * (q.x*q.x + q.y*q.y);
 
}
 
//---------------------------------------------------------------------------
// RotationMatrix::fromObjectToInertialQuaternion
//
// Setup the matrix, given a quaternion that performs an object->inertial
// rotation
//
// See 10.6.3
 
void	RotationMatrix::fromObjectToInertialQuaternion(const Quaternion &q) {
 
	// Fill in the matrix elements.  This could possibly be
	// optimized since there are many common subexpressions.
	// We'll leave that up to the compiler...
 
	m11 = 1.0f - 2.0f * (q.y*q.y + q.z*q.z);
	m12 = 2.0f * (q.x*q.y - q.w*q.z);
	m13 = 2.0f * (q.x*q.z + q.w*q.y);
 
	m21 = 2.0f * (q.x*q.y + q.w*q.z);
	m22 = 1.0f - 2.0f * (q.x*q.x + q.z*q.z);
	m23 = 2.0f * (q.y*q.z - q.w*q.x);
 
	m31 = 2.0f * (q.x*q.z - q.w*q.y);
	m32 = 2.0f * (q.y*q.z + q.w*q.x);
	m33 = 1.0f - 2.0f * (q.x*q.x + q.y*q.y);
}
 
//---------------------------------------------------------------------------
// RotationMatrix::inertialToObject
//
// Rotate a vector from inertial to object space
 
Vector3	RotationMatrix::inertialToObject(const Vector3 &v) const {
 
	// Perform the matrix multiplication in the "standard" way.
 
	return Vector3(
		m11*v.x + m21*v.y + m31*v.z,
		m12*v.x + m22*v.y + m32*v.z,
		m13*v.x + m23*v.y + m33*v.z
	);
}
 
//---------------------------------------------------------------------------
// RotationMatrix::objectToInertial
//
// Rotate a vector from object to inertial space
 
Vector3	RotationMatrix::objectToInertial(const Vector3 &v) const {
 
	// Multiply by the transpose
 
	return Vector3(
		m11*v.x + m12*v.y + m13*v.z,
		m21*v.x + m22*v.y + m23*v.z,
		m31*v.x + m32*v.y + m33*v.z
	);

J'avoue être un petit peu perdu dans tout ça... Là je suis en train d'écrire mes classes, je ne sais pas du tout si je choisi les bonnes fonctions...

**Bakura** · 21/06/2007, 15h08

Et je rajoute aussi la fonction pour calculer la matrice de rotation à partir d'un triplet d'angle d'Euler. Je ne sais pas si elle est correct

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
// On initialise la matrice avec une orientation via un triplet d'angles d'Euler
			RotationMatrix & initFromEulerAngles (const EulerAngles<T> & euler)
			{
				// On commence par calculer les cosinus et sinus des angles, en radians
				T cHeading (cos (euler.heading)), sHeading (sin (euler.heading));
				T cPitch (cos (euler.pitch)), sPitch (sin (euler.pitch));
				T cBank (cos (euler.bank)), sBank (sin (euler.bank));
 
				// Puis on construit la matrice de rotation
				m00 = cHeading * cBank + sHeading * sPitch * sBank;
				m01 = -cHeading * sBank + sHeading * sPitch * cBank;
				m02 = sHeading * cPitch;
 
				m10 = sBank * cPitch;
				m11 = cBank * cPitch;
				m12 = -sPitch;
 
				m20 = -sHeading * cBank + cHeading * sPitch * sBank;
				m21 = sBank * sHeading + cHeading * sPitch * cBank;
				m22 = cHeading * cPitch;
 
				return *this;
			}

**Kurisu** · 21/06/2007, 15h15

Bah, WorldMatrix est la matrice du monde est ObjectMatrix est la matrice locale d'un objet. Un point défini localement sur un objet doit être transformé en point dans la matrice du monde avant d'être affiché.
Je suppose que c'est la même chose pour IntertialQuaternion et ObjectQuaternion (pour les rotations ou les points, dans ce cas).

**Bakura** · 21/06/2007, 18h32

Merci Kurisu pour ta réponse.

J'aurais une petite question supplémentaire : comment dit-on en français une matrice "column major" ou "row major" ? J'ai pensé à matrice à colonne mais ça me paraît étrange...