Discussion :

[manrugby]

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