class sphere en openGL 3-4 [Résolu]

[rAyyy]

Mon but est de creer une class me permettant d'afficher une sphere.
Mais le constructeur me pose problème. Il n'y a pas de problème lors du build, le problème survient lors du deguger.

J'y comprend pas grand chose au debugeur et j’espère que quelqu’un pourra m'aider sur ce point là, il me sort

Unhandled exception at 0x77CC016E (ntdll.dll) in gravitation.exe: 0x00000000: L’opération a réussi.

et il me "relie" à mlock.c (qqch lier au multi-thread locking) et dbgheap.c (qui semble lier au debugeur).

Je suis débutant en openGL donc si vous trouvez que je fait n'importe quoi hésiter pas à me le dire ^^

le header

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
#include <GL/glew.h>
 
#include "Matrice.h"
#include "Shader.h"
 
class Sphere
{
    public:
 
    Sphere(float rayon, int precision_horizon, int precision_verticale);
    ~Sphere();
 
    void afficher(Matrice &projection, Matrice &modelview);
 
 
    private:
 
    Shader m_shaderCouleur;
    float *m_vertices;
    unsigned int *m_indices;
	unsigned int *indices_size;
 
    float *m_rouge;
    float *m_vert;
    float *m_bleu;
};

le constructeur du cpp

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
Sphere::Sphere( float rayon, int precision_horizon, int precision_verticale) : m_shaderCouleur("Shaders/couleurs.vert", "Shaders/couleurs.frag"), m_vertices(0), m_indices(0), m_rouge(0), m_vert(0), m_bleu(0), indices_size(0)
{
    // Initialisation du shader
 
    m_shaderCouleur.initialiser();
 
	int r , s;
	float const R = 1./(float)(precision_verticale-1);
    float const S = 1./(float)(precision_horizon-1);
 
	float *vertices=new float[precision_horizon*precision_verticale*3];
 
	 for(r = 0; r < precision_verticale; r++) for(s = 0; s < precision_horizon; s++) {
                float const z = sin( -(M_PI/2) + M_PI * r * R );
                float const x = cos(2*M_PI * s * S) * sin( 2*M_PI * r * R );
                float const y = sin(2*M_PI * s * S) * sin( 2*M_PI * r * R );
 
				*vertices++=x*rayon;
				*vertices++=y*rayon;
				*vertices++=z*rayon;
	 }
 
	 // Indices
 
	 int *indices= new int[precision_horizon*precision_verticale*4];
 
 
	         for(r = 0; r < precision_verticale-1; r++) for(s = 0; s < precision_horizon-1; s++) {
                *indices++ = r * precision_horizon + s;
                *indices++ = r * precision_horizon + (s+1);
                *indices++ = (r+1) * precision_horizon + (s+1);
                *indices++ = (r+1) * precision_horizon + s;
                 }
 
			 int *indices_size= new int[1];
			 indices_size[0]=precision_horizon*precision_verticale*4;
 
    // Taille des différents tableaux
 
    unsigned int const tailleTabVertices(precision_horizon*precision_verticale*3);
    unsigned int const tailleTabIndices(precision_horizon*precision_verticale*4);
 
    // Allocation des différents attributs
 
    m_vertices = new float[tailleTabVertices];
    m_indices = new unsigned int[tailleTabIndices];
 
    // Copie des vertices
 
    for(int i(0); i < tailleTabVertices; i++)
        m_vertices[i] = vertices[i];
 
    // Copie des indices
 
    for(int i(0); i < tailleTabIndices; i++)
        m_indices[i] = indices[i];
}

[3DArchi]

Salut,
Utilises des std::vector à la place des allocations dynamiques à la main. Rien n'empêche de passer ensuite ceux-ci à openGL via un &var[0], std::vector te garantissant la continuité des éléments du tableau.
Une fois que tu as ces tableaux, à mon avis, penses en terme d'algorithme autant se peut plutôt qu'en boucle for (ça évitera le bug ci-dessous).

Ton bug peut venir du fait que lorsque tu initialises tes tableaux, tu incrémentes directement le pointeur obtenu à l'allocation (*indices++ = blabla;). Lorsque tu copies ensuite ce tableau vers celui de ta classe (m_indices[i] = indices[i];), le pointeur (indices) part de la dernière case allouée du tableau et va donc adresser une zone mémoire invalide.

[rAyyy]

Merci 3DArchi pour ta réponse.

J'ai modifié le code à partir de ce que tu ma dit:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Sphere
{
    public:
 
    Sphere(float rayon, int precision_horizon, int precision_verticale);
    ~Sphere();
 
    void afficher(Matrice &projection, Matrice &modelview);
 
 
    private:
 
    Shader m_shaderCouleur;
    std::vector<GLfloat> m_vertices;
    std::vector<GLushort> m_indices;
 
 
    float *m_rouge;
    float *m_vert;
    float *m_bleu;
};
 
#endif

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
Sphere::Sphere( float rayon, int precision_horizon, int precision_verticale) : m_shaderCouleur("Shaders/couleurs.vert", "Shaders/couleurs.frag"), m_vertices(0), m_indices(0), m_rouge(0), m_vert(0), m_bleu(0)
{
    // Initialisation du shader
 
    m_shaderCouleur.initialiser();
 
	int r , s;
	float const R = 1./(float)(precision_verticale-1);
        float const S = 1./(float)(precision_horizon-1);
 
 
 
     m_vertices.resize(precision_verticale*precision_horizon*3);
	 std::vector<GLfloat>::iterator v = m_vertices.begin();
	 for(r = 0; r < precision_verticale; r++) for(s = 0; s < precision_horizon; s++) {
 
		 //for(p = 0; p < precision_horizon*precision_verticale*3-1; p++){
                float const z = sin( -(M_PI/2) + M_PI * r * R );
                float const x = cos(2*M_PI * s * S) * sin( 2*M_PI * r * R );
                float const y = sin(2*M_PI * s * S) * sin( 2*M_PI * r * R );
 
				*v++=x*rayon;
				*v++=y*rayon;
				*v++=z*rayon;
 
	 }
 
	 // Indices
 
	 m_indices.resize(precision_verticale*precision_horizon*4);
     std::vector<GLushort>::iterator i = m_indices.begin();
	         for(r = 0; r < precision_verticale-1; r++) for(s = 0; s < precision_horizon-1; s++) {
                *i++ = r * precision_horizon + s;
                *i++ = r * precision_horizon + (s+1);
                *i++ = (r+1) * precision_horizon + (s+1);
                *i++ = (r+1) * precision_horizon + s;
                 }
 
}

Telle qu'elle je n'ai plus de problème avec le constructeur, merci

Mais je n'ai pas compris ce que tu endentai par le pensé en algorithme et ne pas utiliser les boucle for. Peut tu donner un petit exemple?


Puis j'ai tester l'affichage et il plante encore dans le debugeur :/

voila la methode:

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
void Sphere::afficher(Matrice &projection, Matrice &modelview)
{
    // Sauvegarde de la matrice modelview
 
    modelview.push();
 
 
    // Activation du shader et des tableaux Vertex Attrib
 
    glUseProgram(m_shaderCouleur.getProgramID());
    glEnableVertexAttribArray(0);
   // glEnableVertexAttribArray(1);
 
 
 
    // Envoi des vertices et des matrices
 
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, &m_vertices[0]);
    glUniformMatrix4fv(glGetUniformLocation(m_shaderCouleur.getProgramID(), "projection"), 1, GL_TRUE, projection.getValeurs());
    glUniformMatrix4fv(glGetUniformLocation(m_shaderCouleur.getProgramID(), "modelview"), 1, GL_TRUE, modelview.getValeurs());
 
 
 
 
    /* ***** La sphere ***** */
 
   // glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, m_rouge);
   glDrawElements(GL_QUADS,m_indices.size(), GL_UNSIGNED_INT, &m_indices[0]);
 
 
 
 
 
 
 
    // Désactivation des tableaux Vertex Attrib et du shader
 
   // glDisableVertexAttribArray(1);
    glDisableVertexAttribArray(0);
    glUseProgram(0);
 
 
    // Restauration de la matrice modelview
 
    modelview.pop();
}

Je sais que le problème viens de glDrawElements mais pourquoi je sais pas :/

Voila ce que le debugeur me dit :

Unhandled exception at 0x568D3AA6 (atioglxx.dll) in gravitation.exe: 0xC0000005: Access violation reading location 0x00507AC4.

J'imagine que je n'ai pas encore tout compris des vector

[3DArchi]

Salut,

Envoyé par rAyyy

Mais je n'ai pas compris ce que tu endentai par le pensé en algorithme et ne pas utiliser les boucle for. Peut tu donner un petit exemple?

J'essaie de te préparer un exemple un peu plus tard et je te le poste.

Envoyé par rAyyy

Puis j'ai tester l'affichage et il plante encore dans le debugeur :/

Je ne me souviens plus très bien de OpenGL mais n'y a-t-il pas une incompatibilité à passer GL_UNSIGNED_INT alors que ton vecteur est, si j'ai bien compris, std::vector<unsigned short>. Ce devrait plutôt être std::vector<unsigned int> ou sinon GL_UNSIGNED_INT ?

[Bousk]

Par contre, si tu affiches un cercle, c'est sûrement du GL_LINES et non GL_QUADS qu'il faudra utiliser.
Enfin je n'ai pas touché ces constantes depuis un moment maintenant :/
Peut-être que ton erreur vient du glsl et non du C++ ?

[rAyyy]

Encore une fois tu avait raison 3DArchi merci pour ton aide.

Par contre, si tu affiches un cercle, c'est sûrement du GL_LINES et non GL_QUADS qu'il faudra utiliser.

C'est bien une sphère que je veut faire et pas des cercles empiler donc je pense que c'est bien GL_QUADS qu'il faut utiliser.


Mais bon jamais 2 sans 3 j'ai un nouveau problème xD
Je n'ai plus de plantage lors du débogage, mais je n'ai pas non plus de sphère qui apparait. Je me dit peut être qu'elle y est mais en noir, je n'ai pas mit de couleur(et je n'ai aucune idée en quelle couleur ça dessine de base). Donc je vais essayer de colorer.

[rAyyy]

C'est bon j'ai réussi c’était bien la couleur qui manquai
Donc j'ai bien ma sphère maintenant