VBO: au secours, ecran noir!

**warenbe** · 14/12/2008, 17h54

bonjour à tous

je veux afficher en utilisant openGL (en C) un triangle en utilisant les VBO
apres avoir farfouillé un peu partout sur le net et lu quelques tutoriels, j'ai un peu compris le fonctionnement

seulement malgré cela j'ai un simple ecran noir au lieu de voir mon magnifique objet!
pourquoi?
je veux pas forcement une solution codée (donc je veux pas que quelqu'un fasse le boulot à ma place) mais plutot des pistes, explications, pointer les erreurs du doigts...

voici ma solution:

Fichier main.cpp:

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
 
#include <stdlib.h>
#include <iostream>
#include <string.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <GL/glx.h>
 
using namespace std;
 
#include "Fenetre.h"
#include "Objets.h"
 
T_MESH* monMesh;
 
 
void afficherMeshs()
{
    afficherObjet(monMesh);
}
 
 
int main(int argc, char** argv)
{
    creerFenetre(640,480,"Moteur!", argc, argv, afficherMeshs);
 
    monMesh = chargerObjetFichier("triangle");
 
    glutMainLoop();
 
    return (EXIT_SUCCESS);
}

fichier Fenetre.cpp: (ici j'ai voulu regrouper tout ce qui est initialisations d'opengl)

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
 
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <GL/glx.h>
 
 
int G_width;
int G_height;
 
void (*fonctionAffichage)();
 
 
GLuint* CubeBuffers = new GLuint[2];
 
///gère le redimensionnement de notre fenetre dans le cas ou nous ne somme pas en plein écran
void redimensionner(int P_width, int P_height)
{
    if (P_height>0)
    {
        //évite la division par 0
        glViewport(0,0,P_width,P_height);
        glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
	// Calcul du ratio de notre fenetre!
	gluPerspective(45.0f,(GLfloat)P_width/(GLfloat)P_height,0.1f,100.0f);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
    }
}
 
 
///initialise OpenGL
void initialiser()
{
    glShadeModel(GL_FLAT);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glClearDepth(1.0f);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}
 
 
///Boucle d'affichage
void afficher()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    fonctionAffichage();
    glFlush();
    glutSwapBuffers();
}
 
 
 
 
///cette methode créé notre fenetre d'application et initialise OpenGL
int creerFenetre(int P_width, int P_height, char* P_titre, int argc, char** argv, void (*func)())
{
    G_width = P_width;
    G_height = P_height;
 
    fonctionAffichage = func;
 
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_ALPHA | GLUT_DEPTH);
    glutInitWindowSize (G_width, G_height);
    glutInitWindowPosition (100, 100);
    glutCreateWindow (P_titre);
 
    initialiser();
 
    glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
 
    glutDisplayFunc(afficher);
    glutReshapeFunc(redimensionner);
 
    return 0;
}

et enfin le plus important je pense ici:
Fichier objets.cpp (est censé me permettre de lire les coordonées d'un objet dans un fichier et l'afficher)

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
 
#include "glext.h"
#include "Objets.h"
#include <GL/glx.h>
#include <stdio.h>
 
 
PFNGLGENBUFFERSARBPROC glGenBuffers = NULL;
PFNGLBINDBUFFERARBPROC glBindBuffer = NULL;
PFNGLBUFFERDATAARBPROC glBufferData = NULL;
PFNGLBUFFERDATAARBPROC glBufferSubData = NULL;
PFNGLDELETEBUFFERSARBPROC glDeleteBuffers = NULL;
    //retrouve les pointeurs vers les fonctions d'opengl
   /*glGenBuffers = (PFNGLGENBUFFERSARBPROC) glXGetProcAddress((const unsigned char*)"glGenBuffersARB");
    glBindBuffer = (PFNGLBINDBUFFERARBPROC) glXGetProcAddress((const unsigned char*)"glBindBufferARB");
    glBufferData = (PFNGLBUFFERDATAARBPROC) glXGetProcAddress((const unsigned char*)"glBufferDataARB");
    glBufferSubData = (PFNGLBUFFERDATAARBPROC) glXGetProcAddress((const unsigned char*)"glBufferSubDataARB");
    glDeleteBuffers = (PFNGLDELETEBUFFERSARBPROC) glXGetProcAddress((const unsigned char*)"glDeleteBuffersARB");*/
 
 
 
 
void buildVBOs(T_MESH* P_mesh)
{
    glGenBuffers = (PFNGLGENBUFFERSARBPROC) glXGetProcAddress((const unsigned char*)"glGenBuffersARB");
    glBindBuffer = (PFNGLBINDBUFFERARBPROC) glXGetProcAddress((const unsigned char*)"glBindBufferARB");
    glBufferData = (PFNGLBUFFERDATAARBPROC) glXGetProcAddress((const unsigned char*)"glBufferDataARB");
    glBufferSubData = (PFNGLBUFFERDATAARBPROC) glXGetProcAddress((const unsigned char*)"glBufferSubDataARB");
    glDeleteBuffers = (PFNGLDELETEBUFFERSARBPROC) glXGetProcAddress((const unsigned char*)"glDeleteBuffersARB");
 
 
    //crée le buffer des vertexs
    glGenBuffers( 1, &P_mesh->VBOnameVertex );	
    glBindBuffer( GL_ARRAY_BUFFER_ARB, P_mesh->VBOnameVertex );
    // charge les données
    glBufferData( GL_ARRAY_BUFFER_ARB, P_mesh->vertexCount*3*sizeof(float), P_mesh->lesVertexs, GL_STATIC_DRAW_ARB );
 
    //créé le buffer des coordonés textures 
    glGenBuffers( 1, &P_mesh->VBOnameTexCoord );
    glBindBuffer( GL_ARRAY_BUFFER_ARB, P_mesh->VBOnameTexCoord );
    // charge les données
    glBufferData( GL_ARRAY_BUFFER_ARB, P_mesh->vertexCount*2*sizeof(float), P_mesh->lesTexCoord, GL_STATIC_DRAW_ARB );
 
    // efface les données puisqu'elles sont en memoire carte graphique
    delete [] P_mesh->lesVertexs;  P_mesh->lesVertexs = NULL;
    delete [] P_mesh->lesTexCoord; P_mesh->lesTexCoord = NULL;
}
 
 
 
void afficherObjet(T_MESH* P_mesh)
{
    glEnableClientState( GL_VERTEX_ARRAY );	
    glEnableClientState( GL_TEXTURE_COORD_ARRAY );
 
    glBindBuffer( GL_ARRAY_BUFFER_ARB, P_mesh->VBOnameVertex );
    glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL );	
    glBindBuffer( GL_ARRAY_BUFFER_ARB, P_mesh->VBOnameTexCoord );
    glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL );	
    glDrawArrays( GL_TRIANGLES, 0, P_mesh->vertexCount );
 
    glDisableClientState( GL_VERTEX_ARRAY );
    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
}
 
 
T_MESH* chargerObjetFichier(char* P_fichier)
{
    FILE* fHandle = fopen(P_fichier, "r");
    if (fHandle)
    {
        T_MESH* mesh = new T_MESH;
        //lit l'id de texture
        fscanf(fHandle, "%d", &mesh->idTexture);
        //lit le nombre de vertexs
        fscanf(fHandle, "%d", &mesh->vertexCount);
        //lis les coordonées
        mesh->lesVertexs = new T_VERTEX[mesh->vertexCount];
        mesh->lesTexCoord = new T_TEXCOORD[mesh->vertexCount];
        for (int i=0; i<mesh->vertexCount; i++)
        {
            fscanf(fHandle, "%f,%f,%f,%f,%f", &mesh->lesVertexs[i].x, &mesh->lesVertexs[i].y, &mesh->lesVertexs[i].z, &mesh->lesTexCoord[i].u, &mesh->lesTexCoord[i].v);
        }
        buildVBOs(mesh);
        fclose(fHandle);
        return mesh;
    }
    else
    {
        fclose(fHandle);
        return NULL;
    }
}

voila sachant que dans mon fichier triangle jai ça;

1
4
0.0,0.0,0.0,0.0,0.0
1.0,0.0,0.0,0.0,0.0
0.5,1.0,0.5,0.0,0.0
0.5,0.0,1.0,0.0,0.0

(dans l'ordre: id de texutre (non utilisé pour le moment puisque je ne charge aucune texture (sais pas encore faire)
nombre de vertex
coordonées vertex + coordonnés texture))

voila vraiment je comprend pas pourquoi j'ai cet ecran noir
(veuillez quand meme noter que j'ai AU MOINS un ecran noir, nan parce que jusqu'a maintenant j'avais plutot des crashs..)

je remercie d'avance l(es)(') ame(s) généreuse(s) qui m'aideront à y voir plus clair

VBO: au secours, ecran noir!

OpenGL

Mode arborescent

Discussions similaires

Partager

Partager