Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 7 sur 7
  1. #1
    Invité régulier
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2012
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2012
    Messages : 25
    Points : 6
    Points
    6

    Par défaut class sphere en openGL 3-4

    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];
    }

  2. #2
    Rédacteur/Modérateur
    Avatar de 3DArchi
    Inscrit en
    juin 2008
    Messages
    7 636
    Détails du profil
    Informations forums :
    Inscription : juin 2008
    Messages : 7 636
    Points : 11 688
    Points
    11 688

    Par défaut

    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.

  3. #3
    Invité régulier
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2012
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2012
    Messages : 25
    Points : 6
    Points
    6

    Par défaut

    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

  4. #4
    Rédacteur/Modérateur
    Avatar de 3DArchi
    Inscrit en
    juin 2008
    Messages
    7 636
    Détails du profil
    Informations forums :
    Inscription : juin 2008
    Messages : 7 636
    Points : 11 688
    Points
    11 688

    Par défaut

    Salut,

    Citation Envoyé par rAyyy Voir le message
    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.

    Citation Envoyé par rAyyy Voir le message
    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 ?

  5. #5
    Modérateur

    Homme Profil pro Cyrille
    Network programmer
    Inscrit en
    juin 2010
    Messages
    2 083
    Détails du profil
    Informations personnelles :
    Nom : Homme Cyrille
    Âge : 27
    Localisation : France

    Informations professionnelles :
    Activité : Network programmer

    Informations forums :
    Inscription : juin 2010
    Messages : 2 083
    Points : 4 905
    Points
    4 905

    Par défaut

    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++ ?

  6. #6
    Invité régulier
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2012
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2012
    Messages : 25
    Points : 6
    Points
    6

    Par défaut

    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.

  7. #7
    Invité régulier
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2012
    Messages
    25
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2012
    Messages : 25
    Points : 6
    Points
    6

    Par défaut

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

+ Répondre à la discussion
Cette discussion est résolue.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •