gKit2 light
tuto_storage_buffer.cpp
Go to the documentation of this file.
1 
3 
4 #include "app.h"
5 
6 #include "vec.h"
7 #include "mat.h"
8 
9 #include "program.h"
10 #include "uniforms.h"
11 #include "texture.h"
12 
13 #include "mesh.h"
14 #include "wavefront.h"
15 
16 #include "orbiter.h"
17 
18 
19 // cf tuto_storage
20 namespace glsl
21 {
22  template < typename T >
23  struct alignas(8) gvec2
24  {
25  alignas(4) T x, y;
26 
27  gvec2( ) {}
28  gvec2( const ::vec2& v ) : x(v.x), y(v.y) {}
29  };
30 
31  typedef gvec2<float> vec2;
32  typedef gvec2<int> ivec2;
33  typedef gvec2<unsigned int> uvec2;
34  typedef gvec2<int> bvec2;
35 
36  template < typename T >
37  struct alignas(16) gvec3
38  {
39  alignas(4) T x, y, z;
40 
41  gvec3( ) {}
42  gvec3( const ::vec3& v ) : x(v.x), y(v.y), z(v.z) {}
43  gvec3( const Point& v ) : x(v.x), y(v.y), z(v.z) {}
44  gvec3( const Vector& v ) : x(v.x), y(v.y), z(v.z) {}
45  };
46 
47  typedef gvec3<float> vec3;
48  typedef gvec3<int> ivec3;
49  typedef gvec3<unsigned int> uvec3;
50  typedef gvec3<int> bvec3;
51 
52  template < typename T >
53  struct alignas(16) gvec4
54  {
55  alignas(4) T x, y, z, w;
56 
57  gvec4( ) {}
58  gvec4( const ::vec4& v ) : x(v.x), y(v.y), z(v.z), w(v.w) {}
59  };
60 
61  typedef gvec4<float> vec4;
62  typedef gvec4<int> ivec4;
63  typedef gvec4<unsigned int> uvec4;
64  typedef gvec4<int> bvec4;
65 }
66 
67 
68 class StorageBuffer : public App
69 {
70 public:
71  // application openGL 4.3
72  StorageBuffer( ) : App(1024, 640, 4, 3) {}
73 
74  int init( )
75  {
76  m_mesh= read_mesh("data/cube.obj");
77 
78  #if 1
79  // construit le storage buffer contenant les positions, les normales et les texcoords, en utilisant les types alignes
80  struct vertex
81  {
82  glsl::vec3 position;
83  glsl::vec3 normal;
84  glsl::vec2 texcoord;
85 
86  vertex( ) : position(), normal(), texcoord() {}
87  };
88 
89  #else
90  // ou a la main
91  struct vertex
92  {
93  vec3 position; // vec3 aligne sur 4 float
94  float pad0;
95  vec3 normal;
96  float pad1;
97  vec2 texcoord; // vec2 aligne sur 2 float
98 
99  float pad2;
100  float pad3; // donc la taille totale de la structure doit etre un mulitple de 4 floats
101 
102  vertex( ) : position(), normal(), texcoord() {}
103  };
104  #endif
105 
106 
107  // recupere les attributs du mesh
108  std::vector<vertex> data(m_mesh.vertex_count());
109  for(int i= 0; i < m_mesh.vertex_count(); i++)
110  {
111  data[i].position= m_mesh.positions().at(i);
112  data[i].normal= m_mesh.normals().at(i);
113  data[i].texcoord= m_mesh.texcoords().at(i);
114  }
115 
116  // vao par defaut
117  glGenVertexArrays(1, &m_vao);
118  glBindVertexArray(m_vao);
119 
120  // storage buffer
121  glGenBuffers(1, &m_buffer);
122 
123  glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_buffer);
124  glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vertex) * data.size(), data.data(), GL_STREAM_READ);
125 
126  //
127  m_program= read_program("tutos/tuto_storage_buffer.glsl");
128  program_print_errors(m_program);
129 
130  //
131  Point pmin, pmax;
132  m_mesh.bounds(pmin, pmax);
133  m_camera.lookat(pmin, pmax);
134 
135  m_texture= read_texture(0, "data/debug2x2red.png");
136 
137  // etat openGL par defaut
138  glClearColor(0.2f, 0.2f, 0.2f, 1.f); // couleur par defaut de la fenetre
139 
140  glClearDepth(1.f); // profondeur par defaut
141  glDepthFunc(GL_LESS); // ztest, conserver l'intersection la plus proche de la camera
142  glEnable(GL_DEPTH_TEST); // activer le ztest
143 
144  return 0; // ras, pas d'erreur
145  }
146 
147  // destruction des objets de l'application
148  int quit( )
149  {
150  m_mesh.release();
151  release_program(m_program);
152  glDeleteTextures(1, &m_texture);
153  glDeleteBuffers(1, &m_buffer);
154  glDeleteVertexArrays(1, &m_vao);
155  return 0;
156  }
157 
158  // dessiner une nouvelle image
159  int render( )
160  {
161  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
162 
163  // deplace la camera
164  int mx, my;
165  unsigned int mb= SDL_GetRelativeMouseState(&mx, &my);
166  if(mb & SDL_BUTTON(1)) // le bouton gauche est enfonce
167  m_camera.rotation(mx, my);
168  else if(mb & SDL_BUTTON(3)) // le bouton droit est enfonce
169  m_camera.move(mx);
170  else if(mb & SDL_BUTTON(2)) // le bouton du milieu est enfonce
171  m_camera.translation((float) mx / (float) window_width(), (float) my / (float) window_height());
172 
173  glBindVertexArray(m_vao);
174  glUseProgram(m_program);
175 
176  Transform model= RotationY(global_time() / 20);
177  Transform view= m_camera.view();
178  Transform projection= m_camera.projection(window_width(), window_height(), 45);
179  Transform mv= view * model;
180  Transform mvp= projection * mv;
181 
182  program_uniform(m_program, "mvMatrix", mv);
183  program_uniform(m_program, "normalMatrix", mv.normal());
184  program_uniform(m_program, "mvpMatrix", mvp);
185 
186  program_use_texture(m_program, "diffuse_color", 0, m_texture, 0);
187 
188  // selectionne le buffer comme storage buffer, numero 0
189  glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffer);
190 
191  glDrawArrays(GL_TRIANGLES, 0, m_mesh.vertex_count());
192 
193  return 1;
194  }
195 
196 protected:
197  Mesh m_mesh;
198  Orbiter m_camera;
199 
200  GLuint m_vao;
201  GLuint m_buffer;
202  GLuint m_program;
203  GLuint m_texture;
204 };
205 
206 
207 int main( int argc, char **argv )
208 {
209  StorageBuffer app;
210  app.run();
211 
212  return 0;
213 }
classe application.
Definition: app.h:20
App(const int width, const int height, const int major=3, const int minor=3, const int samples=0)
constructeur, dimensions de la fenetre et version d'openGL.
Definition: app.cpp:11
int run()
execution de l'application.
Definition: app.cpp:36
representation d'un objet / maillage.
Definition: mesh.h:112
void bounds(Point &pmin, Point &pmax) const
renvoie min et max les coordonnees des extremites des positions des sommets de l'objet (boite engloba...
Definition: mesh.cpp:503
int vertex_count() const
renvoie le nombre de sommets.
Definition: mesh.h:291
void release()
detruit les objets openGL.
Definition: mesh.cpp:64
representation de la camera, type orbiter, placee sur une sphere autour du centre de l'objet.
Definition: orbiter.h:17
void lookat(const Point &center, const float size)
observe le point center a une distance size.
Definition: orbiter.cpp:7
void move(const float z)
rapproche / eloigne la camera du centre.
Definition: orbiter.cpp:33
Transform projection(const int width, const int height, const float fov)
fixe la projection reglee pour une image d'aspect width / height, et une demi ouverture de fov degres...
Definition: orbiter.cpp:47
void translation(const float x, const float y)
deplace le centre / le point observe.
Definition: orbiter.cpp:27
void rotation(const float x, const float y)
change le point de vue / la direction d'observation.
Definition: orbiter.cpp:21
Transform view() const
renvoie la transformation vue.
Definition: orbiter.cpp:40
int quit()
a deriver pour detruire les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon.
int render()
a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application.
int init()
a deriver pour creer les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon.
int window_height()
renvoie la hauteur de la fenetre de l'application.
Definition: window.cpp:29
int window_width()
renvoie la largeur de la fenetre de l'application.
Definition: window.cpp:25
float global_time()
renvoie le temps ecoule depuis le lancement de l'application, en millisecondes.
Definition: window.cpp:128
Transform RotationY(const float a)
renvoie la matrice representation une rotation de a degree autour de l'axe Y.
Definition: mat.cpp:242
Mesh read_mesh(const char *filename)
charge un fichier wavefront .obj et renvoie un mesh compose de triangles non indexes....
Definition: wavefront.cpp:14
GLuint read_program(const char *filename, const char *definitions)
Definition: program.cpp:204
void program_uniform(const GLuint program, const char *uniform, const std::vector< unsigned > &v)
affecte un tableau de valeurs a un uniform du shader program.
Definition: uniforms.cpp:94
int program_print_errors(const GLuint program)
affiche les erreurs de compilation.
Definition: program.cpp:432
int release_program(const GLuint program)
detruit les shaders et le program.
Definition: program.cpp:211
void program_use_texture(const GLuint program, const char *uniform, const int unit, const GLuint texture, const GLuint sampler)
configure le pipeline et le shader program pour utiliser une texture, et des parametres de filtrage,...
Definition: uniforms.cpp:198
GLuint read_texture(const int unit, const char *filename, const GLenum texel_type)
Definition: texture.cpp:148
representation d'un point 3d.
Definition: vec.h:21
representation d'une transformation, une matrice 4x4, organisee par ligne / row major.
Definition: mat.h:21
Transform normal() const
renvoie la transformation a appliquer aux normales d'un objet transforme par la matrice m.
Definition: mat.cpp:181
representation d'un vecteur 3d.
Definition: vec.h:59
vecteur generique, utilitaire.
Definition: vec.h:131
vecteur generique, utilitaire.
Definition: vec.h:146
vecteur generique 4d, ou 3d homogene, utilitaire.
Definition: vec.h:168
representation de l'indexation complete d'un sommet
Definition: wavefront.cpp:176