[OpenGL 4.4] Erreur de segmentation avec des VBO
Bonjour tout le monde,
Je sollicite votre aide pour un problème assez particulier. Je veux intégrer une interface Qt à mon moteur OpenGL. Qt propose des classes toutes faites, mais j'ai déjà mes propres classes pour gérer des concepts OpenGL. J'utilise donc QOpenGLFunctions_4_4_Core pour ne rien changer. Le truc c'est qu'à un moment du programme, une erreur de segmentation liée à la librarie Nvidia survient. J'ai cherché pendant plusieurs jour, avec debugger mais je ne comprend pas l'erreur. Je vous poste un code simplifié et épuré pour vous montrer le problème. Le problème survient lors de l'appel de la fonction glGenBuffers dans le fichier bufferObject.cpp
Je précise que si je génère la VBO dans le fichier engine.cpp, cela ne plante pas. Avez vous une solution?
Partie IHM:
GLWidget.cpp
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#include "glwidget.hpp"
GLWidget::GLWidget(int framesPerSecond, QWidget *parent):QOpenGLWidget(parent)
{
QSurfaceFormat format;
format.setDepthBufferSize(24);
format.setStencilBufferSize(8);
format.setVersion(4, 4);
format.setProfile(QSurfaceFormat::CoreProfile);
setFormat(format);
create();
m_context = new QOpenGLContext();
m_context->setFormat(format);
m_context->create();
m_context->makeCurrent(0);
} |
GLWidget.hpp
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
|
#ifndef GLWIDGET_HPP
#define GLWIDGET_HPP
#include "definitions.hpp"
#include <QOpenGLWidget>
//#include <QWidget>
//#include <QWindow>
#include <QObject>
#include <QOpenGLContext>
class GLWidget : public QOpenGLWidget
{
Q_OBJECT
public:
explicit GLWidget(int framesPerSecond = 0, QWidget *parent = 0);
~GLWidget();
virtual void initializeGL() = 0;
virtual void resizeGL(int w, int h) = 0;
virtual void paintGL() = 0;
QOpenGLContext *m_context;
openGLFunctions *m_functions;
};
#endif |
myGLWidget.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
|
#include "graphics/engine.hpp"
#include "myglwidget.hpp"
#include <QObject>
using namespace std;
using glm::vec3;
using seed_graphics::Engine;
MyGLWidget::MyGLWidget(QStatusBar *qSB, QWidget *parent)
: GLWidget(60, parent)
{
m_engine = new Engine();
}
MyGLWidget::~MyGLWidget()
{
}
void MyGLWidget::initializeGL()
{
m_functions = m_context->versionFunctions<openGLFunctions>();
m_functions->initializeOpenGLFunctions();
m_engine->init();
}
void MyGLWidget::resizeGL(int width, int height)
{
if(height == 0)
height = 1;
m_functions->glViewport(0, 0, width, height);
}
void MyGLWidget::paintGL()
{
} |
myGLWidget.hpp
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
|
#ifndef MYGLWIDGET_HPP
#define MYGLWIDGET_HPP
#define GLM_FORCE_RADIANS
#include "glwidget.hpp"
#include <iostream>
#include <memory>
#include <glm/glm.hpp>
class Engine;
class MyGLWidget : public GLWidget
{
Q_OBJECT
public:
explicit MyGLWidget(QStatusBar *qSB, QWidget *parent = 0);
~MyGLWidget();
void initializeGL();
void resizeGL(int width, int height);
void paintGL();
private:
seed_graphics::Engine *m_engine;
};
#endif |
Partie Moteur graphique
engine.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
|
#include "engine.hpp"
#include "buffers/bufferObject.hpp"
#include <fstream>
#include <iostream>
#include <glm/glm.hpp>
using glm::vec3;
using std::cout;
using std::endl;
openGLFunctions* Engine::f = 0;
Engine::Engine()
{;
}
void Engine::init()
{
context = QOpenGLContext::currentContext();
Engine::f = context->versionFunctions<openGLFunctions>();
f->initializeOpenGLFunctions();
m_buf = new BufferObject();
m_buf->create();
}
void Engine::render()
{
f->glUseProgram(m_shaderProgram);
f->glBindVertexArray(m_vao);
f->glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
f->glBindVertexArray(0);
} |
engine.hpp
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
|
#ifndef ENGINE_HPP
#define ENGINE_HPP
#include "definitions.hpp"
class BufferObject;
class Engine
{
public:
explicit Engine();
~Engine();
void init();
void render();
static openGLFunctions *f;
private:
BufferObject *m_buf;
QOpenGLContext *context;
};
}
#endif // ENGINE_HPP |
objectBuffer.cpp
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#include "buffers/bufferObject.hpp"
#include <iostream>
BufferObject::BufferObject()
{
m_id = 0;
}
bool BufferObject::create()
{
openGLFunctions *f = Engine::f;
f->glEnable(GL_BLEND);
GLuint t = 0;
f->glGenBuffers(GL_ARRAY_BUFFER, &t);
f->glGenBuffers(GL_ARRAY_BUFFER, &m_id);
if(m_id)
return true;
return false;
} |
definitions.hpp
Code:
1
2
3
4
5
6
7
8
9
10
|
#ifndef DEFINITIONS_HPP
#define DEFINITIONS_HPP
#include <QOpenGLFunctions>
#include <QOpenGLFunctions_4_4_Core>
typedef QOpenGLFunctions_4_4_Core openGLFunctions;
#endif // DEFINITIONS_HPP |
ObjectBuffer.hpp
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#ifndef BUFFER_OBJECT_HPP
#define BUFFER_OBJECT_HPP
#include "definitions.hpp"
#include "buffer.hpp"
#include "engine.hpp"
class BufferObject
{
public:
explicit BufferObject();
~BufferObject();
bool create();
private:
GLuint m_id;
};
#endif // BUFFER_OBJECT_HPP |
Je vous remercie d'avance.
