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.

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