Ubuntu-fr

madmaxpt

OpenGL et erreurs de segmentation

Bonjour,

Je rencontre actuellement des problèmes avec OpenGL. A l'exécution du code suivant :

#include <GL/glew.h>
#include <GL/glut.h>
#include <iostream>

class Vec3{
public:
	float m_x;
	float m_y;
	float m_z;

	Vec3(){}
	Vec3(float x, float y, float z){
		m_x=x;
		m_y=y;
		m_z=z;
	}
};

GLuint VBO;

static void CreateVertexBuffer()
{
	Vec3 vertices[1];
	vertices[0] = Vec3(0.0f, 0.0f, 0.0f);

	glGenBuffersARB(1, &VBO);
	glBindBufferARB(GL_ARRAY_BUFFER, VBO);
	glBufferDataARB(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
}

static void renderScene(){
	glClear(GL_COLOR_BUFFER_BIT);
	glEnableVertexAttribArrayARB(0);
	glVertexAttribPointerARB(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glDrawArrays(GL_POINTS, 0, 1);
	glDisableVertexAttribArrayARB(0);
	glutSwapBuffers();

}
int main(int argc, char **argv) {
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowSize(400, 400);
	glutInitWindowPosition(50, 50);
	glutCreateWindow("Tutorial 2");
	glutDisplayFunc(renderScene);
	GLenum err = glewInit();
	if (err != GLEW_OK){
		std::cerr << "Error : " << glewGetErrorString(err) << std::endl;
		return -1;
	}

	glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
	CreateVertexBuffer();
	glutMainLoop();
	return 0;
}

J'obtiens une erreur de segmentation à la ligne     glDrawArrays(GL_POINTS, 0, 1);.

En tapant la commande glxinfo | grep version j'obtiens le résultat suivant :

server glx version string: 1.4
client glx version string: 1.4
GLX version: 1.4
OpenGL version string: 1.4 Mesa 8.0.2

Les fonctions comme glGenBuffers ne sont arrivées qu'avec GL 1.5, c'est pourquoi j'utilise glGenBuffersARB (qui est une extension implémentant les mêmes fonctionnalités pour les versions antérieures).
Mais la fonction glDrawArrays est apparue avec GL 1.1 donc il ne devrait pas y avoir de problèmes.

J'ai essayé le même code sur un ordinateur de mon université (sur lequel glxinfo renvoie OpenGL 2.2), il s'exécute sans problème et affiche bien ce que je veux (un écran rouge avec un point blanc au milieu).

Est ce que quelqu'un saurait expliquer pourquoi cela ne fonctionne pas ?

pingouinux

Re : OpenGL et erreurs de segmentation

Bonjour,
Je ne connais pas OpenGL, mais j'ai testé ton programme. J'obtiens un carré rouge (sans point blanc au milieu), et pas d'erreur de segmentation.
Voici comment j'ai compilé :

g++ -I/usr/include x.cpp -L/usr/lib -lglut -lGL -lGLU -lGLEW -o x

et des précisions sur mon environnement :

$ lsb_release -d
Description:    Ubuntu 12.04.1 LTS

$ uname -pr
3.2.0-32-generic x86_64

$ glxinfo | grep version
server glx version string: 1.4
client glx version string: 1.4
GLX version: 1.4
OpenGL version string: 2.1 Mesa 8.0.4
OpenGL shading language version string: 1.20

Si ça peut t'aider…

Eldermê

Re : OpenGL et erreurs de segmentation

Je ne peux pas tester ton programme maintenant, mais je vois une piste que tu pourrais regarder.

OpenGL version string: 1.4 Mesa 8.0.2

C'est vraiment une version en conserve, ça. Tu es sur une vieille config ?

Les fonctions comme glGenBuffers ne sont arrivées qu'avec GL 1.5, c'est pourquoi j'utilise glGenBuffersARB (qui est une extension implémentant les mêmes fonctionnalités pour les versions antérieures).

Mais rien ne garantit que ton implémentation d'OpenGL te permet de profiter de l'extension nécessaire pour les vertex buffer objects (celle qui te permet d'utliser glGenBuffers[ARB], glBindBuffer[ARB] et compagnie). As-tu vérifié qu'elle est disponible ? Comme tu utilises Glew, tu peux utliser la fonction glewIsSupported. Ou tu peux regarder simplement si tu as bien un GL_ARB_vertex_buffer_object (ou un GL_EXT_vertex_buffer_object) dans la liste de tes extensions quand tu fais glxinfo.
Si Mesa te dit que tu utilises de l'OpenGL 1.4 (et pas 1.5 ou supérieur), il y a sûrement une bonne raison. L'absence de support des VBO en serait une.

Si la création de ton VBO a échoué, cela expliquerait que ça plante à l'appel glDrawArrays.

---

Mon blog : petit projet de jeux en 3D (libres, bien sûr).

madmaxpt

Re : OpenGL et erreurs de segmentation

Je suis sur un Dell Inspiron Mini 10.

Sur le site de Mesa 3D, il est dit que Mesa 8.0.2 implémente l'API d'OpenGL 3.0 mais que la version utilisée dépend du driver.
Ma puce graphique est intégrée au CPU (Intel Corporation N10 Family Integrated Graphics Controller).
La commande lspci -v indique dans la section VGA compatible controller:

00:02.0 VGA compatible controller: Intel Corporation N10 Family Integrated Graphics Controller (prog-if 00 [VGA controller])
	Subsystem: Dell Device 048e
	Flags: bus master, fast devsel, latency 0, IRQ 44
	Memory at f0200000 (32-bit, non-prefetchable) [size=512K]
	I/O ports at 18d0 [size=8]
	Memory at d0000000 (32-bit, prefetchable) [size=256M]
	Memory at f0000000 (32-bit, non-prefetchable) [size=1M]
	Expansion ROM at <unassigned> [disabled]
	Capabilities: <access denied>
	Kernel driver in use: i915
	Kernel modules: i915

J'ai cherché sur internet s'il était possible de mettre les drivers à jour mais pour l'instant je n'ai rien trouvé.

glxinfo | grep GL_ARB_VERTEX renvoie ceci :

 GL_ARB_vertex_program, GL_ARB_vertex_shader, GL_ATI_draw_buffers, 
    GL_ARB_texture_non_power_of_two, GL_ARB_vertex_buffer_object, 
    GL_APPLE_object_purgeable, GL_ARB_vertex_array_object, 

Donc il semblerait que je dispose de l'extension permettant d'utiliser les VBO et VAO.

Eldermê

Re : OpenGL et erreurs de segmentation

Ok, donc a priori, la création de ton VBO a dû marcher. A tout hasard, peut-être vérifier que glIsBuffer (VBO) renvoie bien GL_TRUE pour être sûr que le glGenBuffers a fait son travail ? Et appeler glGetError() pour vérifier qu'il n'y ait pas eu de soucis ailleurs ?
Pour ton driver, je ne sais pas trop, n'ayant jamais utlisé de chipset intel.

L'utilisation de glVertexAttribPointer m'étonne : normalement, on passe par cette fonction pour envoyer des attributs de sommets qui peuvent être n'importe quoi (d'où son nom !) lorsqu'on utilise des shaders. Ce n'est pas ton cas ici, tu utilises le pipeline fixe. Il me semble que l'indice 0 est censé correspondre aux coordonnées de sommets, donc que ça devrait marcher en théorie, mais je trouverais plus logique et plus sain dans ton cas de passer par glVertexPointer. C'est une fonction obsolète à partir de OpenGL 3, mais vu que tu es en OpenGL1, ce n'est pas vraiment un soucis.

Au cas où le problème viendrait de là (je ne vois pas trop pourquoi ça serait une cause de plantage cela dit, mais autant essayer), tu pourrais essayer de remplacer :

glEnableVertexAttribArrayARB(0);
glVertexAttribPointerARB(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_POINTS, 0, 1);
glDisableVertexAttribArrayARB(0);

par :

glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_POINTS, 0, 1);
glDisableClientState(GL_VERTEX_ARRAY);

Sinon je ne vois pas trop. Je regarderai chez moi demain pour voir ce que ça donne.

---

Mon blog : petit projet de jeux en 3D (libres, bien sûr).

madmaxpt

Re : OpenGL et erreurs de segmentation

glIsBuffer(VBO) renvoie GL_TRUE et glGetError() renvoie GL_NO_ERROR.

Le code que tu m'as passé fonctionne (youpi ), mais j'aimerais bien que glVertexAttribPointerARB() fonctionne car j'aimerais bien pouvoir renseigner les normales, couleurs, ... de mes vertex avec un VAO et plusieurs VBO.

Déjà merci pour ton aide, au moins pour le moment je peux trafiquer mes programmes en utilisant un unique VBO et glVertexPointer()

Eldermê

Re : OpenGL et erreurs de segmentation

Tu n'as pas besoin de glVertexAttribPointerARB pour cela.

glVertexAttribPointerARB sert quand tu utilises des shaders pour un rendu plus avancé. Cette fonction te permet d'envoyer des données qui peuvent représenter ce que tu veux, et que tu vas exploiter dans un shader. Par exemple, si tu veux renseigner une tangente pour tes sommets.

Ton code utilise le pipeline fixe, donc tu ne peux utiliser que les attributs de sommets que connait OpenGL de base.
glVertexPointer permet d'envoyer les coordonnées de sommets. Pour les normales ou les couleurs, tu as ses amis glNormalPointer et glColorPointer. Tu as aussi glTexCoordPointer pour les coordonées de textures.

A noter que tu peux envoyer toutes ces données dans un unique VBO et appeler glVertexPointer, glNormalPointer et compagnie avec la valeur de décalage qui va bien (dernier paramètre de la fonction), ou utiliser un VBO pour chaque et appeler les glBidulePointer sans décalage. Les 2 solutions fonctionnent, la 1ere étant a priori un poil plus performante (moins d'activation/désactivation de VBO à faire) mais parfois moins pratique.

Et tu peux effectivement englober les appels aux glBidulePointer dans un VAO pour améliorer les performances.

Bonne continuation !

---

Mon blog : petit projet de jeux en 3D (libres, bien sûr).