gKit2 light
tuto6GL_buffer.cpp
1 
3 
4 #include <cstdlib>
5 
6 #include "vec.h"
7 #include "mat.h"
8 
9 #include "mesh.h"
10 #include "wavefront.h"
11 
12 #include "program.h"
13 #include "uniforms.h"
14 
15 #include "orbiter.h"
16 #include "app.h" // classe Application a deriver
17 
18 
19 class DrawInstanceBuffer : public App
20 {
21 public:
22  // constructeur : donner les dimensions de l'image, et eventuellement la version d'openGL.
23  DrawInstanceBuffer( ) : App(1024, 640) {}
24 
25  int init( )
26  {
27  // charge un mesh
28  Mesh mesh= read_mesh("data/cube.obj");
29  if(mesh == Mesh::error()) return -1;
30 
31  Point pmin, pmax;
32  mesh.bounds(pmin, pmax);
33  m_camera.lookat(pmin - Vector(40, 40, 40), pmax + Vector(40, 40, 40));
34 
35  m_vertex_count= mesh.vertex_count();
36 
37  // cree les buffers et le vao
38  glGenVertexArrays(1, &m_vao);
39  glBindVertexArray(m_vao);
40 
41  // buffer : positions + normals
42  glGenBuffers(1, &m_buffer);
43  glBindBuffer(GL_ARRAY_BUFFER, m_buffer);
44 
45  size_t size= mesh.vertex_buffer_size() + mesh.normal_buffer_size();
46  glBufferData(GL_ARRAY_BUFFER, size, nullptr, GL_STATIC_DRAW);
47 
48  // transfere les positions des sommets
49  size_t offset= 0;
50  size= mesh.vertex_buffer_size();
51  glBufferSubData(GL_ARRAY_BUFFER, offset, size, mesh.vertex_buffer());
52  // configure l'attribut 0, vec3 position
53  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset);
54  glEnableVertexAttribArray(0);
55 
56  // transfere les normales des sommets
57  offset= offset + size;
58  size= mesh.normal_buffer_size();
59  glBufferSubData(GL_ARRAY_BUFFER, offset, size, mesh.normal_buffer());
60  // configure l'attribut 2, vec3 normal
61  glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, (const GLvoid *) offset);
62  glEnableVertexAttribArray(2);
63 
64 
65  // instance buffer, position aleatoire des cubes...
66  srand(time(NULL));
67 
68  std::vector<vec3> positions;
69  for(int i= 0; i < 50; i++)
70  {
71  float x= rand() % 11 - 5;
72  float y= rand() % 11 - 5;
73  float z= rand() % 11 - 5;
74 
75  positions.push_back(vec3(x *4, y *4, z *4));
76  }
77 
78  m_instance_count= (int) positions.size();
79 
80  // cree et initialise le buffer d'instance
81  glGenBuffers(1, &m_instance_buffer);
82  glBindBuffer(GL_ARRAY_BUFFER, m_instance_buffer);
83  glBufferData(GL_ARRAY_BUFFER, sizeof(vec3) * positions.size(), &positions.front().x, GL_STATIC_DRAW);
84 
85  // configure le vao pour l'attribut d'instance
86  // configure l'attribut 1, vec3 instance_position
87  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, /* stride */ 0, /* offset */ 0);
88  glVertexAttribDivisor(1, 1); // !! c'est la seule difference entre un attribut de sommet et un attribut d'instance !!
89  glEnableVertexAttribArray(1);
90 
91  //
92  mesh.release();
93  glBindVertexArray(0);
94  glBindBuffer(GL_ARRAY_BUFFER, 0);
95 
96  // shaders
97  m_program= read_program("tutos/instance_buffer.glsl");
98  program_print_errors(m_program);
99 
100 
101  // etat openGL par defaut
102  glClearColor(0.2f, 0.2f, 0.2f, 1.f); // couleur par defaut de la fenetre
103 
104  glClearDepth(1.f); // profondeur par defaut
105  glDepthFunc(GL_LESS); // ztest, conserver l'intersection la plus proche de la camera
106  glEnable(GL_DEPTH_TEST); // activer le ztest
107 
108  return 0; // ras, pas d'erreur
109  }
110 
111  // destruction des objets de l'application
112  int quit( )
113  {
114  release_program(m_program);
115  glDeleteVertexArrays(1, &m_vao);
116  glDeleteBuffers(1, &m_buffer);
117  glDeleteBuffers(1, &m_instance_buffer);
118  return 0;
119  }
120 
121  int update( const float time, const float delta )
122  {
123  m_model= RotationY(time / 20);
124  return 0;
125  }
126 
127  // dessiner une nouvelle image
128  int render( )
129  {
130  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
131 
132  // deplace la camera
133  int mx, my;
134  unsigned int mb= SDL_GetRelativeMouseState(&mx, &my);
135  if(mb & SDL_BUTTON(1)) // le bouton gauche est enfonce
136  m_camera.rotation(mx, my);
137  else if(mb & SDL_BUTTON(3)) // le bouton droit est enfonce
138  m_camera.move(mx);
139  else if(mb & SDL_BUTTON(2)) // le bouton du milieu est enfonce
140  m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
141 
142  glBindVertexArray(m_vao);
143  glUseProgram(m_program);
144 
145  Transform m= m_model;
146  Transform v= m_camera.view();
147  Transform p= m_camera.projection(window_width(), window_height(), 45);
148  Transform mvp= p * v * m;
149  Transform mv= v * m;
150 
151  program_uniform(m_program, "mvpMatrix", mvp);
152  program_uniform(m_program, "normalMatrix", mv.normal());
153 
154  glDrawArraysInstanced(GL_TRIANGLES, 0, m_vertex_count, m_instance_count);
155 
156  return 1;
157  }
158 
159 protected:
160  Transform m_model;
161  Orbiter m_camera;
162  GLuint m_vao;
163  GLuint m_buffer;
164  GLuint m_instance_buffer;
165  GLuint m_program;
166  int m_vertex_count;
167  int m_instance_count;
168 };
169 
170 
171 int main( int argc, char **argv )
172 {
174  tp.run();
175 
176  return 0;
177 }
178 
const float * normal_buffer() const
renvoie l'adresse de la normale du premier sommet. par convention, la normale est un vec3...
Definition: mesh.h:200
representation de la camera, type orbiter, placee sur une sphere autour du centre de l'objet...
Definition: orbiter.h:16
int quit()
a deriver pour detruire les objets openGL.
const float * vertex_buffer() const
renvoie l'adresse de la position du premier sommet. permet de construire les vertex buffers openGL...
Definition: mesh.h:195
void bounds(Point &pmin, Point &pmax)
renvoie min et max les coordonnees des extremites des positions des sommets de l'objet (boite engloba...
Definition: mesh.cpp:153
vecteur generique, utilitaire.
Definition: vec.h:104
Transform normal() const
renvoie la transformation a appliquer aux normales d'un objet transforme par la matrice m...
Definition: mat.cpp:97
int init()
a deriver pour creer les objets openGL.
std::size_t normal_buffer_size() const
renvoie la longueur (en octets) du normal buffer.
Definition: mesh.h:202
representation d'un objet / maillage.
Definition: mesh.h:88
void move(const float z)
rapproche / eloigne la camera du centre.
Definition: orbiter.cpp:33
std::size_t vertex_buffer_size() const
renvoie la longueur (en octets) du vertex buffer.
Definition: mesh.h:197
int run()
execution de l'application.
Definition: app.cpp:21
void program_uniform(const GLuint program, const char *uniform, const unsigned int v)
affecte une valeur a un uniform du shader program. uint.
Definition: uniforms.cpp:68
Transform view() const
renvoie la transformation vue.
Definition: orbiter.cpp:40
int window_width()
renvoie la largeur de la fenetre de l'application.
Definition: window.cpp:14
representation d'un vecteur 3d.
Definition: vec.h:42
void release()
detruit les objets openGL.
Definition: mesh.cpp:19
Transform projection(const float width, const float height, const float fov) const
renvoie la projection reglee pour une image d'aspect width / height, et une ouverture de fov degres...
Definition: orbiter.cpp:47
int program_print_errors(const GLuint program)
affiche les erreurs de compilation.
Definition: program.cpp:330
void lookat(const Point &center, const float size)
observe le point center a une distance size.
Definition: orbiter.cpp:7
App(const int width, const int height, const int major=3, const int minor=3)
constructeur, dimensions de la fenetre et version d'openGL.
Definition: app.cpp:6
GLuint read_program(const char *filename, const char *definitions)
Definition: program.cpp:150
static Mesh & error()
Definition: mesh.h:250
int render()
a deriver pour afficher les objets.
void translation(const float x, const float y)
deplace le centre / le point observe.
Definition: orbiter.cpp:27
int update(const float time, const float delta)
a deriver et redefinir pour animer les objets en fonction du temps.
void rotation(const float x, const float y)
change le point de vue / la direction d'observation.
Definition: orbiter.cpp:21
int window_height()
renvoie la hauteur de la fenetre de l'application.
Definition: window.cpp:18
representation d'une transformation, une matrice 4x4, organisee par ligne / row major.
Definition: mat.h:20
int release_program(const GLuint program)
detruit les shaders et le program.
Definition: program.cpp:157
representation d'un point 3d.
Definition: vec.h:19
int vertex_count() const
renvoie le nombre de sommets.
Definition: mesh.h:190
Transform RotationY(const float a)
renvoie la matrice representation une rotation de a degree autour de l'axe Y.
Definition: mat.cpp:158
classe application.
Definition: app.h:20
Mesh read_mesh(const char *filename)
charge un fichier wavefront .obj et renvoie un mesh compose de triangles non indexes. utiliser glDrawArrays pour l'afficher. a detruire avec Mesh::release( ).
Definition: wavefront.cpp:8