[OpenGL 3.x] Gestion des matrices

Bonjour,

Dans le but de faire du code pour OpenGL 3.x, je dois moi même faire la gestion des matrices dans un but de comprehension (je connais sinon la très bonne glm).

Je teste mes matrices sous un prog' OpenGL 2.1 afin de faire des tests rapides en chargeant directement mes matrices avec glLoadMatrixf().

Seulement alors que je pensais avoir codé mes matrices en column-major comme OpenGL, je dois transposer mes matrices avant d'envoyer les données, preuves que je me suis trompé. Mais je n'arrive pas à trouver d'où vient l'erreur. :aie:

Ci-joint ma classe Matrix4 minimaliste. Le code est assez simple et parle de lui même. Je voudrais juste savoir où ce situe mon erreur : constructeur surchargé, opérateur*, les fonctions statiques, la façon de récupérer les données...

Merci d'avance si quelqu'un peut m'aider!

Code:

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
#ifndef PROTO_MATRIX4_HPP
#define PROTO_MATRIX4_HPP
 
class Matrix4
{
 
public:
    Matrix4();
 
    Matrix4(float a0, float a1, float a2, float a3,
            float a4, float a5, float a6, float a7, 
            float a8, float a9, float a10, float a11, 
            float a12, float a13, float a14, float a15);
 
    float& operator()(std::size_t Row, std::size_t Column); 
 
    const float& operator()(std::size_t Row, std::size_t Column) const;
 
    Matrix4 operator*(const Matrix4 &m) const;
 
    void identity();
 
    Matrix4& transpose();
 
    Matrix4 getTranspose() const;
 
    const float* getData() const;
 
    static Matrix4 GetPerspectiveMatrix(float Fovy, float Aspect, float zNear, float zFar);
 
    static Matrix4 GetLookAtMatrix(const Vector3 &Position, const Vector3 &Target, const Vector3 &Up);
 
private:
    float m_data[16]; 
 
};
 
#endif // PROTO_MATRIX4_HPP

Code:

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include "Matrix4.hpp"
 
Matrix4::Matrix4()
{
    m_data[0] = m_data[5] = m_data[10] = m_data[15] = 1.0f;    
m_data[1] = m_data[2] = m_data[3] = m_data[4] = m_data[6] = m_data[7] = m_data[8] = m_data[9] = m_data[11] = m_data[12] = m_data[13] = m_data[14] = 0.0f;
}
 
 
Matrix4::Matrix4(Real a0, Real a1, Real a2, Real a3,
                 Real a4, Real a5, Real a6, Real a7, 
                 Real a8, Real a9, Real a10, Real a11, 
                 Real a12, Real a13, Real a14, Real a15)
{
    m_data[0] = a0; m_data[4] = a4; m_data[8] = a8; m_data[12] = a12;
    m_data[1] = a1; m_data[5] = a5; m_data[9] = a9; m_data[13] = a13;
    m_data[2] = a2; m_data[6] = a6; m_data[10] = a10; m_data[14] = a14;
    m_data[3] = a3; m_data[7] = a7; m_data[11] = a11; m_data[15] = a15;
}
 
 
Real& Matrix4::operator()(std::size_t Row, std::size_t Column)
{
    return m_data[Row*4+ Column];
}
 
 
const Real& Matrix4::operator()(std::size_t Row, std::size_t Column) const
{
    return m_data[Row*4 + Column];
}
 
 
Matrix4 Matrix4::operator*(const Matrix4 &m) const
{
    return Matrix4(m_data[0] * m.m_data[0] + m_data[1] * m.m_data[4] + m_data[2] * m.m_data[8] + m_data[3] * m.m_data[12],
                   m_data[0] * m.m_data[1] + m_data[1] * m.m_data[5] + m_data[2] * m.m_data[9] + m_data[3] * m.m_data[13],
                   m_data[0] * m.m_data[2] + m_data[1] * m.m_data[6] + m_data[2] * m.m_data[10] + m_data[3] * m.m_data[14],
                   m_data[0] * m.m_data[3] + m_data[1] * m.m_data[7] + m_data[2] * m.m_data[11] + m_data[3] * m.m_data[15],
 
                   m_data[4] * m.m_data[0] + m_data[5] * m.m_data[4] + m_data[6] * m.m_data[8] + m_data[7] * m.m_data[12],
                   m_data[4] * m.m_data[1] + m_data[5] * m.m_data[5] + m_data[6] * m.m_data[9] + m_data[7] * m.m_data[13],
                   m_data[4] * m.m_data[2] + m_data[5] * m.m_data[6] + m_data[6] * m.m_data[10] + m_data[7] * m.m_data[14],
                   m_data[4] * m.m_data[3] + m_data[5] * m.m_data[7] + m_data[6] * m.m_data[11] + m_data[7] * m.m_data[15],
 
                   m_data[8] * m.m_data[0] + m_data[9] * m.m_data[4] + m_data[10] * m.m_data[8] + m_data[11] * m.m_data[12],
                   m_data[8] * m.m_data[1] + m_data[9] * m.m_data[5] + m_data[10] * m.m_data[9] + m_data[11] * m.m_data[13],
                   m_data[8] * m.m_data[2] + m_data[9] * m.m_data[6] + m_data[10] * m.m_data[10] + m_data[11] * m.m_data[14],
                   m_data[8] * m.m_data[3] + m_data[9] * m.m_data[7] + m_data[10] * m.m_data[11] + m_data[11] * m.m_data[15],
 
                   m_data[12] * m.m_data[0] + m_data[13] * m.m_data[4] + m_data[14] * m.m_data[8] + m_data[15] * m.m_data[12],
                   m_data[12] * m.m_data[1] + m_data[13] * m.m_data[5] + m_data[14] * m.m_data[9] + m_data[15] * m.m_data[13],
                   m_data[12] * m.m_data[2] + m_data[13] * m.m_data[6] + m_data[14] * m.m_data[10] + m_data[15] * m.m_data[14],
                   m_data[12] * m.m_data[3] + m_data[13] * m.m_data[7] + m_data[14] * m.m_data[11] + m_data[15] * m.m_data[15]);
 
}
 
 
void Matrix4::identity()
{
    m_data[0] = m_data[5] = m_data[10] = m_data[15] = 1.0f;
 
	m_data[1] = m_data[2] = m_data[3] = m_data[4] = m_data[6] = m_data[7] = m_data[8] = m_data[9] = m_data[11] = m_data[12] = m_data[13] = m_data[14] = 0.0f;
}
 
 
Matrix4& Matrix4::transpose()
{
    return ( *this = getTranspose() );
}
 
 
Matrix4 Matrix4::getTranspose() const
{
	return Matrix4(m_data[0], m_data[4], m_data[8], m_data[12], 
		       m_data[1], m_data[5], m_data[9], m_data[13], 
		       m_data[2], m_data[6], m_data[10], m_data[14], 
		       m_data[3], m_data[7], m_data[11], m_data[15]);
}
 
 
const Real* Matrix4::getData() const
{
	return m_data;
}
 
 
Matrix4 Matrix4::GetPerspectiveMatrix(Real Fovy, Real Aspect, Real zNear, Real zFar)
{
	const Real f = (std::cos(Fovy*0.5f/180.0f*3.141592654f) / std::sin(Fovy*0.5f/180.f*3.141592654f) );
 
	return Matrix4( (f/Aspect), 0.0f, 0.0f, 0.0f,
			 0.0f, f, 0.0f, 0.0f,
             		 0.0f, 0.0f, ((zFar+zNear)/(zNear-zFar)), ((2*zFar*zNear)/(zNear-zFar)),
			 0.0f, 0.0f, -1.0f, 0.0f );
}
 
Matrix4 Matrix4::GetLookAtMatrix(const Vector3 &Position, const Vector3 &Target, const Vector3 &Up)
{
 
    Vector3 zaxis = (Position - Target).normalize();
    Vector3 xaxis = (cross(Up, zaxis)).normalize();
    Vector3 yaxis = cross(zaxis, xaxis);
 
    return Matrix4(xaxis.x, xaxis.y, xaxis.z, -dot(xaxis, Position),
                   yaxis.x, yaxis.y, yaxis.z, -dot(yaxis, Position),
                   zaxis.x, zaxis.y, zaxis.z, -dot(zaxis, Position),
                   0, 0, 0, 1);
}

Tout ton code est raw major. Tu dois inverser ta convention. Si tu pensais faire du column major, dis-toi simplement que c'est l'inverse :).

Mais ici on voit bien que c'est du column-major non?

Code:

1
2
3
4
5
6
7
8
9
10
Matrix4::Matrix4(Real a0, Real a1, Real a2, Real a3,
                 Real a4, Real a5, Real a6, Real a7, 
                 Real a8, Real a9, Real a10, Real a11, 
                 Real a12, Real a13, Real a14, Real a15)
{
    m_data[0] = a0; m_data[4] = a4; m_data[8] = a8; m_data[12] = a12;
    m_data[1] = a1; m_data[5] = a5; m_data[9] = a9; m_data[13] = a13;
    m_data[2] = a2; m_data[6] = a6; m_data[10] = a10; m_data[14] = a14;
    m_data[3] = a3; m_data[7] = a7; m_data[11] = a11; m_data[15] = a15;
}

Où alors j'ai rien compris :aie: Et si tu peux me dire ce que je dois changer car je suis perdu là. Merci :)

Le raw major veut dire que tu sauvegardes tes donnees lignes par lignes. C'est bien le cas ici. Je suppose que a0, a1, a2, a3 est la premiere ligne de ta matrice ? Et ton tableau, les premiers elements c'est quoi ? La premiere ligne de ta matrice :
Code:

1 2 3 4 5 m_data[0] = a0; m_data[4] = a4; m_data[8] = a8; m_data[12] = a12; m_data[1] = a1; m_data[5] = a5; m_data[9] = a9; m_data[13] = a13; m_data[2] = a2; m_data[6] = a6; m_data[10] = a10; m_data[14] = a14; m_data[3] = a3; m_data[7] = a7; m_data[11] = a11; m_data[15] = a15;
Alors que ca devrait stocker la premiere colonne de ta matrice qui est :
Code:

1 2 3 4 5 m_data[0] = a0; m_data[1] = a4; m_data[2] = a8; m_data[3] = a12;
Apres je suis d'accord que la premiere ligne de ton code enregistres d'abord la premiere colonne de ta matrice mais cela n'a aucune importance. L'important est ou (avec un accent... clavier anglais...) est-ce que tu le sauvegardes et pas quand tu le sauvegardes.

Si tu es debutant en programmation, je te conseille d'utiliser quelques abstractions style glm avant d'aller dans les details. Apres si tu es force... Tu peux aussi voir comment est le code de glm :D (c'est code en column major).

D'accord. Je vais bien finir par trouvé ;)