IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

OpenGL Discussion :

Problème texture normal vertex VBO gl3.3


Sujet :

OpenGL

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Inscrit en
    Mai 2009
    Messages
    62
    Détails du profil
    Informations forums :
    Inscription : Mai 2009
    Messages : 62
    Par défaut Problème texture normal vertex VBO gl3.3
    Bonsoir je viens de m'apercevoir d'un problème gênant concernant l'envoi des données dans un VBO (opengl3.3).
    Le problème c'est quand j'affiche un plan avec une texture, celle-ci ne s'affiche pas jusqu’à ce que j'ajoute les normal du plan mais pas n'importe quel normal!
    des normals avec les UV de la texture, j'avoue je n'y comprend plus rien ! pire encore pas la peine que j'upload les données UV il suffit de mettre que les normals et j'ai ma texturé sur mon plan...
    Voici un peux de code en espérant que vous trouveriez quelque chose j'ai passé toute la journée à essayer de trouver l'erreur mais rien a faire.

    Création du plan
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    mesh=MPGE_MeshNew(false);/* false= vbo non indexé*/
    MPGE_MeshBufferAllocData(mesh->mbuffer,12,0,12);/*12=3*4 vertices, 0= 0 texcoords, 12=3*4 normals*/
    MPGE_MeshBufferAddVertexData(mesh->mbuffer,MPGE_Vector3D(10,0,10));  MPGE_MeshBufferAddVertexData(mesh->mbuffer,MPGE_Vector3D(-10,0,10));  MPGE_MeshBufferAddVertexData(mesh->mbuffer,MPGE_Vector3D(-10,0,-10));
        MPGE_MeshBufferAddVertexData(mesh->mbuffer,MPGE_Vector3D(10,0,-10));
     
    /* aucun effet si je rajoute ce code la texture s'affiche malgré que je né pas envoyé de donneés UV
    MPGE_MeshBufferAddTexCoordData(mesh->mbuffer,MPGE_Vector3D(0,0,0));  MPGE_MeshBufferAddTexCoordData(mesh->mbuffer,MPGE_Vector3D(1,0,0));
    MPGE_MeshBufferAddTexCoordData(mesh->mbuffer,MPGE_Vector3D(1,1,0)); MPGE_MeshBufferAddTexCoordData(mesh->mbuffer,MPGE_Vector3D(0,1,0));
    */
    MPGE_MeshBufferAddNormalData(mesh->mbuffer,MPGE_Vector3D(0,0,0));
    MPGE_MeshBufferAddNormalData(mesh->mbuffer,MPGE_Vector3D(1,0,0));
    MPGE_MeshBufferAddNormalData(mesh->mbuffer,MPGE_Vector3D(1,1,0)); MPGE_MeshBufferAddNormalData(mesh->mbuffer,MPGE_Vector3D(0,1,0));
    ensuite je crée un draw buffer pour m'afficher mon mesh
    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
     
     db=MPGE_DrawBufferNew(3,false,MPGE_EDB_QUADS);
     MPGE_DrawBufferUploadGPU(db,mesh);
    /* ensuite je charge les shaders*/
    sh=MPGE_ResourceGetShader("defaultVertexShader_texture.h");
    fh=MPGE_ResourceGetShader("defaultFragmentShader_texture.h");
     
    MPGE_ShaderManagerBind(&sh,&fh);  MPGE_ShaderManagerSetAttributes(null,MPGE_EGL3VA_VERTEX,"inPosition",MPGE_EGL3VA_TEXTURE0,"inTexCoord");
    MPGE_ShaderManagerUnbind();
     
    /* ensuite affichage*/
     
    MPGE_ShaderUse(sh,true);
                MPGE_Matrix4Mul(&m,MPGE_MatrixModelViewProjectionGetProjection(mvp),MPGE_MatrixModelViewProjectionGetModelView(mvp));
                MPGE_ShaderSendMatrix4(sh,"mvpMatrix",&m);
                MPGE_ShaderSendInt(sh,"colorMap",0);
                glActiveTexture(GL_TEXTURE0);
                glBindTexture(GL_TEXTURE_2D,MPGE_ResourceGetTexture("box.jpg")->glID);
                MPGE_DrawBuffer(db);
                MPGE_ShaderUse(sh,false);
    Voila rien de méchant ici voici comment je créer mais vbo
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
      db->vao.mode=db->drawMode;
            db->vao.vbuffer=&db->vbo;
            if(db->indexed)
                db->vao.ibuffer=&db->ibo;
     
            glBindVertexArray(db->vao.id);
            MPGE_VertexBufferUploadToGPU(&db->vbo,mesh->mbuffer->vertexData,mesh->mbuffer->texcoordData,mesh->mbuffer->normalData);
     
     
            glBindVertexArray(0);
    Fonction MPGE_VertexBufferUploadToGPU:
    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
     
     
    void MPGE_OPENGL3_API MPGE_VertexBufferUploadToGPU(MPGEVertexBuffer* vb,MPGEArrayf vertexData,MPGEArrayf texcoordData,MPGEArrayf normalData)
    {
        if(vertexData)
            vb->vertexSize = vertexData->size  * sizeof(f32);
        if(texcoordData)
            vb->texcoordSize = texcoordData->size  * sizeof(f32);
        if(normalData)
            vb->normalSize =  normalData->size  * sizeof(f32);
     
        if(vb->vertexSize > 0)
        {
            glBindBuffer(GL_ARRAY_BUFFER,vb->id[VERTEX_BUFFER]);
            glBufferData(GL_ARRAY_BUFFER,vb->vertexSize,vertexData->array,vb->type);
            glVertexAttribPointer(0,vb->dimension, GL_FLOAT, GL_FALSE, 0, 0);
            vb->hasVertex=true;
     
            if(normalData)
            {
                glBindBuffer(GL_ARRAY_BUFFER,vb->id[NORMAL_BUFFER]);
                glBufferData(GL_ARRAY_BUFFER,vb->normalSize,normalData->array,vb->type);
                glVertexAttribPointer(1,3, GL_FLOAT, GL_FALSE, 0, 0);
                vb->hasNormal=true;
            }
     
            if(texcoordData)
            {
                glBindBuffer(GL_ARRAY_BUFFER,vb->id[TEXCOORD_BUFFER]);
                glBufferData(GL_ARRAY_BUFFER,vb->texcoordSize,texcoordData->array,vb->type);
                glVertexAttribPointer(2,2, GL_FLOAT, GL_FALSE, 0, 0);
                vb->hasTexcoord=true;
            }
     
     
        }
    }
    Et enfin le rendu;
    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
     
    void MPGE_OPENGL3_API MPGE_VertexArrayBindVertexBuffer(MPGEVertexArray* va)
    {
        glBindVertexArray(va->id);
        if(va->vbuffer->hasVertex)
        {
            glBindBuffer(GL_ARRAY_BUFFER, va->vbuffer->id[VERTEX_BUFFER]);
            glVertexAttribPointer(MPGE_EGL3VA_VERTEX,va->dimension, GL_FLOAT, GL_FALSE, 0, (const GLvoid*)0);
            glEnableVertexAttribArray(MPGE_EGL3VA_VERTEX);
     
            glBindBuffer(GL_ARRAY_BUFFER,0);
     
            if(va->vbuffer->hasNormal)
            {
                glBindBuffer(GL_ARRAY_BUFFER, va->vbuffer->id[NORMAL_BUFFER]);
                glEnableVertexAttribArray(MPGE_EGL3VA_NORMAL);
                glVertexAttribPointer(MPGE_EGL3VA_NORMAL, 3, GL_FLOAT, GL_FALSE, 0,(const GLvoid*)0);
     
                glBindBuffer(GL_ARRAY_BUFFER,0);
     
            }
            if(va->vbuffer->hasTexcoord)
            {
                glBindBuffer(GL_ARRAY_BUFFER, va->vbuffer->id[TEXCOORD_BUFFER]);
                glEnableVertexAttribArray(MPGE_EGL3VA_TEXTURE0);
                glVertexAttribPointer(MPGE_EGL3VA_TEXTURE0, 2, GL_FLOAT, GL_FALSE, 0,(const GLvoid*)0);
                glBindBuffer(GL_ARRAY_BUFFER,0);
     
            }
     
        }
    }
    void MPGE_OPENGL3_API MPGE_VertexArrayUnbind(MPGEVertexArray* va)
    {
        if(va->vbuffer->hasVertex)
            glDisableVertexAttribArray(MPGE_EGL3VA_VERTEX);
        if(va->vbuffer->hasNormal)
            glDisableVertexAttribArray(MPGE_EGL3VA_NORMAL);
        if(va->vbuffer->hasTexcoord)
            glDisableVertexAttribArray(MPGE_EGL3VA_TEXTURE0);
     
        glBindVertexArray(0);
    }
    void MPGE_OPENGL3_API MPGE_VertexArrayDraw(MPGEVertexArray* va)
    {
     
        if(va->vbuffer)
        {
     
            MPGE_VertexArrayBindVertexBuffer(va);
            if(va->ibuffer)
            {
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, va->ibuffer->id[VERTEX_BUFFER]);
                glDrawElements(va->mode,va->ivertices_size/sizeof(u32), GL_UNSIGNED_INT,(GLvoid*)0);
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, va->ibuffer->id[NORMAL_BUFFER]);
                glDrawElements(va->mode,va->inormals_size/sizeof(u32), GL_UNSIGNED_INT,(GLvoid*)0);
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, va->ibuffer->id[TEXCOORD_BUFFER]);
                glDrawElements(va->mode,va->itexcoords_size/sizeof(u32), GL_UNSIGNED_INT,(GLvoid*)0);
     
            }
            else
            {
                glDrawArrays(va->mode,0,(va->vertices_size/sizeof(f32))/va->dimension);
            }
            MPGE_VertexArrayUnbind(va);
     
        }
     
    }
    Merci d'avance...
    EDIT: j'ai oublier les shaders :
    vertex shader:
    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
     
    #version 330
     
    uniform mat4 mvpMatrix;
     
    in  vec3 inPosition;
    in  vec2 inTexCoord; 
     
    out vec2 outTexCoords;
     
    void main(void) 
    {
     
    	outTexCoords=inTexCoord;
        gl_Position = mvpMatrix * vec4(inPosition, 1.0);	
     
    }
    fragment shader;
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
     
    #version 330
     
    uniform sampler2D colorMap;
    in vec2 outTexCoords;
     
    out vec4 fragColor;
     
    void main(void) 
    { 
      fragColor = texture2D(colorMap,outTexCoords.st);
    }

  2. #2
    Membre confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2009
    Messages
    219
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2009
    Messages : 219
    Par défaut
    Bonsoir,

    Je n'ai trouvé aucune erreur dans tes shaders. Mais ajoute un fragColor.a = 1.0 ; a la fin de ton fragment shader dans un premier temps, ou même met une couleur fixe pour vérifié que çà te dessine quelque chose.

    Aussi, ce qui me parai bizar dans MPGE_VertexArrayBindVertexBuffer, c'est que tu fais des binds, mais après tu refait un glBindBuffer(GL_ARRAY_BUFFER,0) donc ta fonction ne rempli pas ton cahier des charge. Essaye en ayant retiré tous les glBindBuffer(GL_ARRAY_BUFFER,0) de MPGE_VertexArrayBindVertexBuffer, et tu vient en rajouté un à la fin de MPGE_VertexArrayUnbind

    Pour le reste, je ne connais pas MPGE, tu devrai poster sur un forum spécialisé dans cette librairie.

  3. #3
    Expert confirmé

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 034
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 034
    Billets dans le blog
    12
    Par défaut
    Pour ta fonction MPGE_VertexArrayBindVertexBuffer, je dirais que seul le nom n'est peut être pas approprié, sinon son travail m'a l'air correct.
    Par contre, tu devrais peut être vérifier les valeurs des constantes MPGE_EGL3VA_XXX, commence par les remplacer par les équivalents OpenGL (GL_XXX) car je me demande si ça ne viendrait pas de là.

    Je pense aussi qu'il y a un problème au niveau de la déclaration des vertex attribute pointers, tu ne lui déclares pas de 'normal' attribute, du coup je me demande s'il ne prendrait pas les 2 premieres coordonnées du 2eme buffer (celui qui contient les normales, justement) qui lui est passé lors de l'affichage (glDrawElements ou glDrawArrays)

    Sinon, quand tu ne mets pas ton buffer de normales (que tu le désactives partout, limite commente les lignes de code ou il apparait), quel est le rendu ?
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  4. #4
    Membre confirmé
    Inscrit en
    Mai 2009
    Messages
    62
    Détails du profil
    Informations forums :
    Inscription : Mai 2009
    Messages : 62
    Par défaut
    Salut, le problème est résolu,j'avais des erreurs au niveau des attributes,
    Merci

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

Discussions similaires

  1. [XNA] Problème textures objet DirectX
    Par Gurdil dans le forum XNA/Monogame
    Réponses: 1
    Dernier message: 25/05/2007, 13h37
  2. Normales et VBOs
    Par nicoenz dans le forum OpenGL
    Réponses: 4
    Dernier message: 30/01/2007, 10h47
  3. volume texture et vertex shader
    Par J&B dans le forum DirectX
    Réponses: 1
    Dernier message: 30/05/2006, 19h11
  4. Problème ou normal : Boolean / GetValue ?
    Par mchicoix dans le forum XMLRAD
    Réponses: 11
    Dernier message: 14/11/2005, 23h27

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo