GL4Dummies  0.1.7
Fonctions
Référence du fichier gl4dg.h

The GL4Dummies Geometry. Plus de détails...

#include "gl4dummies.h"
Graphe des dépendances par inclusion de gl4dg.h:
Ce graphe montre quels fichiers incluent directement ou indirectement ce fichier :

Aller au code source de ce fichier.

Fonctions

GL4DAPI void GL4DAPIENTRY gl4dgInit (void)
 Initialise les structures nécessaire au stockage des géométries proposées par GL4Dummies. Cette fonction est appelée par la fonction gl4duInit, utilisez donc cette dernière. Plus de détails...
 
GL4DAPI void GL4DAPIENTRY gl4dgClean (void)
 Libère les structures nécessaire au stockage des géométries proposées par GL4Dummies en supprimant aussi tous les objets produits. Cette fonction est appelée par la fonction gl4duClean avec l'argument GL4DU_GEOMETRY ou GL4DU_ALL, utilisez donc cette dernière. Plus de détails...
 
GL4DAPI void GL4DAPIENTRY gl4dgSetGeometryOptimizationLevel (GLuint level)
 Modifie le niveau d'optimisation de certaines des géométries à générer (exemple le torus, la grid et la sphère). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGetVAO (GLuint id)
 Renvoie l'identifiant du Vertex Array Object correspondant à l'objet-géométrie référencé par id. Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenQuadf (void)
 Génère un objet-géométrie de type Quad (plan vertical en z=0) et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenCubef (void)
 Génère un objet-géométrie de type cube et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenSpheref (GLuint slices, GLuint stacks)
 Génère un objet-géométrie de type sphère et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenConef (GLuint slices, GLboolean base)
 Génère un objet-géométrie de type cone et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenFanConef (GLuint slices, GLboolean base)
 Génère un objet-géométrie de type fan-cone et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenCylinderf (GLuint slices, GLboolean base)
 Génère un objet-géométrie de type cylindre et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenDiskf (GLuint slices)
 Génère un objet-géométrie de type disque et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenTorusf (GLuint slices, GLuint stacks, GLfloat radius)
 Génère un objet-géométrie de type tore et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenGrid2df (GLuint width, GLuint height)
 Génère un objet-géométrie de type grille de sommets et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenGrid2dFromHeightMapf (GLuint width, GLuint height, GLfloat *heightmap)
 Génère un objet-géométrie de type grille-heightmap et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI GLuint GL4DAPIENTRY gl4dgGenTeapotf (GLuint slices)
 Génère un objet-géométrie de type théière et renvoie son identifiant (référence). Plus de détails...
 
GL4DAPI void GL4DAPIENTRY gl4dgDraw (GLuint id)
 Dessine un objet-géométrie dont l'identifiant (référence) est passé en argument. Plus de détails...
 
GL4DAPI void GL4DAPIENTRY gl4dgDelete (GLuint id)
 Détruit un objet-géométrie dont l'identifiant (référence) est passé en argument. Plus de détails...
 

Description détaillée

The GL4Dummies Geometry.

Auteur
Fares BELHADJ amsi@.nosp@m.ai.u.nosp@m.niv-p.nosp@m.aris.nosp@m.8.fr
Date
February 22, 2016

Définition dans le fichier gl4dg.h.

Documentation des fonctions

◆ gl4dgClean()

GL4DAPI void GL4DAPIENTRY gl4dgClean ( void  )

Libère les structures nécessaire au stockage des géométries proposées par GL4Dummies en supprimant aussi tous les objets produits. Cette fonction est appelée par la fonction gl4duClean avec l'argument GL4DU_GEOMETRY ou GL4DU_ALL, utilisez donc cette dernière.

Voir également
gl4duClean avec l'argument GL4DU_GEOMETRY ou GL4DU_ALL
gl4dgInit
187  {
188  if(_glist) {
189  llFree(_glist, NULL);
190  _glist = NULL;
191  }
192  if(_garray) {
193  int i;
194  for(i = 0; i < _garray_size; ++i)
195  if(_garray[i].vao || _garray[i].geom)
196  freeGeom(&_garray[i]);
197  free(_garray);
198  _garray = NULL;
199  }
200  _garray_size = 256;
201  _hasInit = 0;
202 }

Références _garray, _garray_size, _glist, _hasInit, freeGeom(), et llFree().

Référencé par gl4duClean().

◆ gl4dgDelete()

GL4DAPI void GL4DAPIENTRY gl4dgDelete ( GLuint  id)

Détruit un objet-géométrie dont l'identifiant (référence) est passé en argument.

Paramètres
ididentifiant de l'objet à supprimer.
523  {
524  --id;
525  freeGeom(&_garray[id]);
526  _garray[id].vao = 0;
527  _garray[id].type = 0;
528  llPush(_glist, &_garray[id]);
529 }

Références _garray, _glist, freeGeom(), llPush(), geom_t::type, et geom_t::vao.

Référencé par quit().

◆ gl4dgDraw()

GL4DAPI void GL4DAPIENTRY gl4dgDraw ( GLuint  id)

Dessine un objet-géométrie dont l'identifiant (référence) est passé en argument.

Paramètres
ididentifiant de l'objet à dessiner.
451  {
452  switch(_garray[--id].type) {
453  case GE_SPHERE:
454  glBindVertexArray(_garray[id].vao);
455  DRAW_WITH_GEOMETRY_OPTIMIZATION((gsphere_t *)(_garray[id].geom));
456  glBindVertexArray(0);
457  break;
458  case GE_TORUS:
459  glBindVertexArray(_garray[id].vao);
460  DRAW_WITH_GEOMETRY_OPTIMIZATION((gtorus_t *)(_garray[id].geom));
461  glBindVertexArray(0);
462  break;
463  case GE_GRID2D:
464  glBindVertexArray(_garray[id].vao);
465  DRAW_WITH_GEOMETRY_OPTIMIZATION((ggrid2d_t *)(_garray[id].geom));
466  glBindVertexArray(0);
467  break;
468  case GE_QUAD:
469  glBindVertexArray(_garray[id].vao);
470  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
471  glBindVertexArray(0);
472  break;
473  case GE_CUBE:
474  glBindVertexArray(_garray[id].vao);
475  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
476  glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);
477  glDrawArrays(GL_TRIANGLE_STRIP, 8, 4);
478  glDrawArrays(GL_TRIANGLE_STRIP, 12, 4);
479  glDrawArrays(GL_TRIANGLE_STRIP, 16, 4);
480  glDrawArrays(GL_TRIANGLE_STRIP, 20, 4);
481  glBindVertexArray(0);
482  break;
483  case GE_CONE:
484  case GE_FAN_CONE:
485  glBindVertexArray(_garray[id].vao);
486  if(_garray[id].type == GE_CONE)
487  glDrawArrays(GL_TRIANGLE_STRIP, 0, 2 * (((gcone_t *)(_garray[id].geom))->slices + 1));
488  else
489  glDrawArrays(GL_TRIANGLE_FAN, 0, ((gcone_t *)(_garray[id].geom))->slices + 2);
490  if(((gcone_t *)(_garray[id].geom))->base) {
491  if(_garray[id].type == GE_CONE)
492  glDrawArrays(GL_TRIANGLE_FAN, 2 * (((gcone_t *)(_garray[id].geom))->slices + 1), ((gcone_t *)(_garray[id].geom))->slices + 2);
493  else
494  glDrawArrays(GL_TRIANGLE_FAN, ((gcone_t *)(_garray[id].geom))->slices + 2, ((gcone_t *)(_garray[id].geom))->slices + 2);
495  }
496  glBindVertexArray(0);
497  break;
498  case GE_CYLINDER:
499  glBindVertexArray(_garray[id].vao);
500  glDrawArrays(GL_TRIANGLE_STRIP, 0, 2 * (((gcylinder_t *)(_garray[id].geom))->slices + 1));
501  if(((gcylinder_t *)(_garray[id].geom))->base) {
502  glDrawArrays(GL_TRIANGLE_FAN, 2 * (((gcylinder_t *)(_garray[id].geom))->slices + 1), ((gcylinder_t *)(_garray[id].geom))->slices + 2);
503  glDrawArrays(GL_TRIANGLE_FAN, 2 * (((gcylinder_t *)(_garray[id].geom))->slices + 1) + ((gcylinder_t *)(_garray[id].geom))->slices + 2,
504  ((gcylinder_t *)(_garray[id].geom))->slices + 2);
505  }
506  glBindVertexArray(0);
507  break;
508  case GE_DISK:
509  glBindVertexArray(_garray[id].vao);
510  glDrawArrays(GL_TRIANGLE_FAN, 0, ((gdisk_t *)(_garray[id].geom))->slices + 2);
511  glBindVertexArray(0);
512  break;
513  case GE_TEAPOT:
514  glBindVertexArray(_garray[id].vao);
515  glDrawArrays(GL_TRIANGLE_STRIP, 0, 49 * (((gteapot_t *)(_garray[id].geom))->slices )+1);
516  glBindVertexArray(0);
517  break;
518  default:
519  break;
520  }
521 }

Références _garray, DRAW_WITH_GEOMETRY_OPTIMIZATION, GE_CONE, GE_CUBE, GE_CYLINDER, GE_DISK, GE_FAN_CONE, GE_GRID2D, GE_QUAD, GE_SPHERE, GE_TEAPOT, et GE_TORUS.

Référencé par blurffunc(), cannyffunc(), drawTex(), fractalPaintingffunc(), medianffunc(), opffunc(), scatteringffunc(), et sobelffunc().

◆ gl4dgGenConef()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenConef ( GLuint  slices,
GLboolean  base 
)

Génère un objet-géométrie de type cone et renvoie son identifiant (référence).

Le cone est meshé à l'aide d'un triangle_strip, sa base est faite d'un triangle_fan.

Paramètres
slicesle nombre de longitudes du cone.
baseindique s'il y a ou pas une base au cone.
Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
252  {
253  GLfloat * data = NULL;
254  GLuint i = genId();
255  gcone_t * c = malloc(sizeof *c);
256  assert(c);
257  _garray[i].geom = c;
258  _garray[i].type = GE_CONE;
259  c->slices = slices; c->base = base;
260  data = mkConeVerticesf(slices, base);
261  glGenVertexArrays(1, &_garray[i].vao);
262  glBindVertexArray(_garray[i].vao);
263  glEnableVertexAttribArray(0);
264  glEnableVertexAttribArray(1);
265  glEnableVertexAttribArray(2);
266  glGenBuffers(1, &(c->buffer));
267  glBindBuffer(GL_ARRAY_BUFFER, c->buffer);
268  glBufferData(GL_ARRAY_BUFFER, (16 * (slices + 1) + (base ? 8 : 0) * (slices + 2)) * sizeof *data, data, GL_STATIC_DRAW);
269  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)0);
270  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(3 * sizeof *data));
271  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(6 * sizeof *data));
272  free(data);
273  glBindVertexArray(0);
274  glBindBuffer(GL_ARRAY_BUFFER, 0);
275  return ++i;
276 }

Références _garray, gcone_t::base, gcone_t::buffer, GE_CONE, genId(), geom_t::geom, mkConeVerticesf(), gcone_t::slices, et geom_t::type.

◆ gl4dgGenCubef()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenCubef ( void  )

Génère un objet-géométrie de type cube et renvoie son identifiant (référence).

Ce cube est composé de 6 plans meshés par des triangle_strips. Le normales sont aux plans.

Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
248  {
249  return mkStaticf(GE_CUBE);
250 }

Références GE_CUBE, et mkStaticf().

◆ gl4dgGenCylinderf()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenCylinderf ( GLuint  slices,
GLboolean  base 
)

Génère un objet-géométrie de type cylindre et renvoie son identifiant (référence).

Le cylindre est meshé à l'aide d'un triangle_strip, ses bases sont faites de triangle_fans.

Paramètres
slicesle nombre de longitudes du cylindre.
baseindique s'il y a ou pas deux bases au cylindre (top et bas).
Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
304  {
305  GLfloat * data = NULL;
306  GLuint i = genId();
307  gcylinder_t * c = malloc(sizeof *c);
308  assert(c);
309  _garray[i].geom = c;
310  _garray[i].type = GE_CYLINDER;
311  c->slices = slices; c->base = base;
312  data = mkCylinderVerticesf(slices, base);
313  glGenVertexArrays(1, &_garray[i].vao);
314  glBindVertexArray(_garray[i].vao);
315  glEnableVertexAttribArray(0);
316  glEnableVertexAttribArray(1);
317  glEnableVertexAttribArray(2);
318  glGenBuffers(1, &(c->buffer));
319  glBindBuffer(GL_ARRAY_BUFFER, c->buffer);
320  glBufferData(GL_ARRAY_BUFFER, (16 * (slices + 1) + (base ? 16 : 0) * (slices + 2)) * sizeof *data, data, GL_STATIC_DRAW);
321  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)0);
322  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(3 * sizeof *data));
323  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(6 * sizeof *data));
324  free(data);
325  glBindVertexArray(0);
326  glBindBuffer(GL_ARRAY_BUFFER, 0);
327  return ++i;
328 }

Références _garray, gcylinder_t::base, gcylinder_t::buffer, GE_CYLINDER, genId(), geom_t::geom, mkCylinderVerticesf(), gcylinder_t::slices, et geom_t::type.

◆ gl4dgGenDiskf()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenDiskf ( GLuint  slices)

Génère un objet-géométrie de type disque et renvoie son identifiant (référence).

Le disque est composé d'un triangle_fan, il est en y=0 et est tourné vers le haut.

Paramètres
slicesle nombre de longitudes du disque.
Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
330  {
331  GLfloat * data = NULL;
332  GLuint i = genId();
333  gdisk_t * c = malloc(sizeof *c);
334  assert(c);
335  _garray[i].geom = c;
336  _garray[i].type = GE_DISK;
337  c->slices = slices;
338  data = mkDiskVerticesf(slices);
339  glGenVertexArrays(1, &_garray[i].vao);
340  glBindVertexArray(_garray[i].vao);
341  glEnableVertexAttribArray(0);
342  glEnableVertexAttribArray(1);
343  glEnableVertexAttribArray(2);
344  glGenBuffers(1, &(c->buffer));
345  glBindBuffer(GL_ARRAY_BUFFER, c->buffer);
346  glBufferData(GL_ARRAY_BUFFER, 8 * (slices + 1 + /* le centre du disk */ 1) * sizeof *data, data, GL_STATIC_DRAW);
347  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)0);
348  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(3 * sizeof *data));
349  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(6 * sizeof *data));
350  free(data);
351  glBindVertexArray(0);
352  glBindBuffer(GL_ARRAY_BUFFER, 0);
353  return ++i;
354 }

Références _garray, gdisk_t::buffer, GE_DISK, genId(), geom_t::geom, mkDiskVerticesf(), gdisk_t::slices, et geom_t::type.

◆ gl4dgGenFanConef()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenFanConef ( GLuint  slices,
GLboolean  base 
)

Génère un objet-géométrie de type fan-cone et renvoie son identifiant (référence).

Le cone et sa base sont meshés par triangle_fan.

Paramètres
slicesle nombre de longitudes du cone.
baseindique s'il y a ou pas une base au cone.
Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
278  {
279  GLfloat * data = NULL;
280  GLuint i = genId();
281  gcone_t * c = malloc(sizeof *c);
282  assert(c);
283  _garray[i].geom = c;
284  _garray[i].type = GE_FAN_CONE;
285  c->slices = slices; c->base = base;
286  data = mkFanConeVerticesf(slices, base);
287  glGenVertexArrays(1, &_garray[i].vao);
288  glBindVertexArray(_garray[i].vao);
289  glEnableVertexAttribArray(0);
290  glEnableVertexAttribArray(1);
291  glEnableVertexAttribArray(2);
292  glGenBuffers(1, &(c->buffer));
293  glBindBuffer(GL_ARRAY_BUFFER, c->buffer);
294  glBufferData(GL_ARRAY_BUFFER, (base ? 16 : 8) * (slices + 1 + /* le sommet ou le centre de la base */ 1) * sizeof *data, data, GL_STATIC_DRAW);
295  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)0);
296  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(3 * sizeof *data));
297  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(6 * sizeof *data));
298  free(data);
299  glBindVertexArray(0);
300  glBindBuffer(GL_ARRAY_BUFFER, 0);
301  return ++i;
302 }

Références _garray, gcone_t::base, gcone_t::buffer, GE_FAN_CONE, genId(), geom_t::geom, mkFanConeVerticesf(), gcone_t::slices, et geom_t::type.

◆ gl4dgGenGrid2df()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenGrid2df ( GLuint  width,
GLuint  height 
)

Génère un objet-géométrie de type grille de sommets et renvoie son identifiant (référence).

La grille est couchée en y=0 et est orientée vers le haut

Paramètres
widthla largeur de la grille.
heightla hauteur de la grille.
Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
gl4dgSetGeometryOptimizationLevel
389  {
390  return gl4dgGenGrid2dFromHeightMapf(width, height, NULL);
391 }

Références gl4dgGenGrid2dFromHeightMapf().

◆ gl4dgGenGrid2dFromHeightMapf()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenGrid2dFromHeightMapf ( GLuint  width,
GLuint  height,
GLfloat *  heightmap 
)

Génère un objet-géométrie de type grille-heightmap et renvoie son identifiant (référence).

La grille est couchée en y=0 et est orientée vers le haut

Paramètres
widthla largeur de la grille.
heightla hauteur de la grille.
heightmapmatrice de mêmes dimensions que la grille et servant de carte de hauteurs permettant de déplacer les sommets de la grille (les normales sont calculées et lissées en fonction de la heightmap). Les valeurs doivent être données entre 0 et 1 afin d'obtenir une grille dont les y varient entre -1 et +1.
Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
gl4dgSetGeometryOptimizationLevel
393  {
394  GLfloat * idata = NULL;
395  GL4Dvaoindex * index = NULL;
396  GLuint i = genId();
397  ggrid2d_t * s = malloc(sizeof *s);
398  assert(s);
399  _garray[i].geom = s;
400  _garray[i].type = GE_GRID2D;
401  s->width = width; s->height = height;
402  idata = mkGrid2dVerticesf(width, height, heightmap);
403  SELECT_GEOMETRY_OPTIMIZATION(index, s, width, height);
404  glGenVertexArrays(1, &_garray[i].vao);
405  glBindVertexArray(_garray[i].vao);
406  glEnableVertexAttribArray(0);
407  glEnableVertexAttribArray(1);
408  glEnableVertexAttribArray(2);
409  glGenBuffers(2, s->buffers);
410  glBindBuffer(GL_ARRAY_BUFFER, s->buffers[0]);
411  glBufferData(GL_ARRAY_BUFFER, 8 * width * height * sizeof *idata, idata, GL_STATIC_DRAW);
412  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *idata), (const void *)0);
413  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *idata), (const void *)(3 * sizeof *idata));
414  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, (8 * sizeof *idata), (const void *)(6 * sizeof *idata));
415  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s->buffers[1]);
416  glBufferData(GL_ELEMENT_ARRAY_BUFFER, s->index_row_count * s->index_nb_rows * sizeof *index, index, GL_STATIC_DRAW);
417  free(idata);
418  free(index);
419  glBindVertexArray(0);
420  glBindBuffer(GL_ARRAY_BUFFER, 0);
421  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
422  return ++i;
423 }

Références _garray, ggrid2d_t::buffers, GE_GRID2D, genId(), geom_t::geom, ggrid2d_t::height, ggrid2d_t::index_nb_rows, ggrid2d_t::index_row_count, mkGrid2dVerticesf(), SELECT_GEOMETRY_OPTIMIZATION, geom_t::type, et ggrid2d_t::width.

Référencé par gl4dgGenGrid2df().

◆ gl4dgGenQuadf()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenQuadf ( void  )

Génère un objet-géométrie de type Quad (plan vertical en z=0) et renvoie son identifiant (référence).

La géométrie est décrite par 4 sommets reliés par un triangle_strip.

Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
244  {
245  return mkStaticf(GE_QUAD);
246 }

Références GE_QUAD, et mkStaticf().

Référencé par gl4dpInitScreenWithDimensions(), et init().

◆ gl4dgGenSpheref()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenSpheref ( GLuint  slices,
GLuint  stacks 
)

Génère un objet-géométrie de type sphère et renvoie son identifiant (référence).

Cette sphère est obtenue par transformation des coordonnées polaires en coordonnées cartésiennes.

Paramètres
slicesle nombre de longitudes de la sphère.
stacksle nombre de latitudes de la sphère.
Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
gl4dgSetGeometryOptimizationLevel
212  {
213  GLfloat * idata = NULL;
214  GL4Dvaoindex * index = NULL;
215  GLuint i = genId();
216  gsphere_t * s = malloc(sizeof *s);
217  assert(s);
218  _garray[i].geom = s;
219  _garray[i].type = GE_SPHERE;
220  s->slices = slices; s->stacks = stacks;
221  idata = mkSphereVerticesf(slices, stacks);
222  SELECT_GEOMETRY_OPTIMIZATION(index, s, slices + 1, stacks + 1);
223  glGenVertexArrays(1, &_garray[i].vao);
224  glBindVertexArray(_garray[i].vao);
225  glEnableVertexAttribArray(0);
226  glEnableVertexAttribArray(1);
227  glEnableVertexAttribArray(2);
228  glGenBuffers(2, s->buffers);
229  glBindBuffer(GL_ARRAY_BUFFER, s->buffers[0]);
230  glBufferData(GL_ARRAY_BUFFER, 5 * (slices + 1) * (stacks + 1) * sizeof *idata, idata, GL_STATIC_DRAW);
231  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (5 * sizeof *idata), (const void *)0);
232  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (5 * sizeof *idata), (const void *)0);
233  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, (5 * sizeof *idata), (const void *)(3 * sizeof *idata));
234  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s->buffers[1]);
235  glBufferData(GL_ELEMENT_ARRAY_BUFFER, s->index_row_count * s->index_nb_rows * sizeof *index, index, GL_STATIC_DRAW);
236  free(idata);
237  free(index);
238  glBindVertexArray(0);
239  glBindBuffer(GL_ARRAY_BUFFER, 0);
240  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
241  return ++i;
242 }

Références _garray, gsphere_t::buffers, GE_SPHERE, genId(), geom_t::geom, gsphere_t::index_nb_rows, gsphere_t::index_row_count, mkSphereVerticesf(), SELECT_GEOMETRY_OPTIMIZATION, gsphere_t::slices, gsphere_t::stacks, et geom_t::type.

◆ gl4dgGenTeapotf()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenTeapotf ( GLuint  slices)

Génère un objet-géométrie de type théière et renvoie son identifiant (référence).

La théière est meshée à l'aide d'un triangle_strip.

Paramètres
slicesle nombre de longitudes de la théière.
Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
425  {
426  GLfloat * data = NULL;
427  GLuint i = genId();
428  gteapot_t * c = malloc(sizeof *c);
429  assert(c);
430  _garray[i].geom = c;
431  _garray[i].type = GE_TEAPOT;
432  c->slices = slices;
433  data = mkTeapotVerticesf(slices);
434  glGenVertexArrays(1, &_garray[i].vao);
435  glBindVertexArray(_garray[i].vao);
436  glEnableVertexAttribArray(0);
437  glEnableVertexAttribArray(1);
438  glEnableVertexAttribArray(2);
439  glGenBuffers(1, &(c->buffer));
440  glBindBuffer(GL_ARRAY_BUFFER, c->buffer);
441  glBufferData(GL_ARRAY_BUFFER,(392 * slices + 8) * sizeof *data, data, GL_STATIC_DRAW);
442  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)0);
443  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(3 * sizeof *data));
444  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, (8 * sizeof *data), (const void *)(6 * sizeof *data));
445  free(data);
446  glBindVertexArray(0);
447  glBindBuffer(GL_ARRAY_BUFFER, 0);
448  return ++i;
449 }

Références _garray, gteapot_t::buffer, GE_TEAPOT, genId(), geom_t::geom, mkTeapotVerticesf(), gteapot_t::slices, et geom_t::type.

◆ gl4dgGenTorusf()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGenTorusf ( GLuint  slices,
GLuint  stacks,
GLfloat  radius 
)

Génère un objet-géométrie de type tore et renvoie son identifiant (référence).

Paramètres
slicesle nombre de longitudes du tore.
stacksle nombre de "latitudes" (subdivisions en coupe verticale) du tore.
radiusle rayon d'une section verticale du tore (eq. rayon du pneu).
Renvoie
l'identifiant (référence) de l'objet-géométrie généré.
Voir également
gl4dgDraw pour le dessiner.
gl4dgDelete pour le détruire.
gl4dgSetGeometryOptimizationLevel
356  {
357  GLfloat * idata = NULL;
358  GL4Dvaoindex * index = NULL;
359  GLuint i = genId();
360  gtorus_t * s = malloc(sizeof *s);
361  assert(s);
362  _garray[i].geom = s;
363  _garray[i].type = GE_TORUS;
364  s->slices = slices; s->stacks = stacks;
365  s->radius = radius;
366  idata = mkTorusVerticesf(slices, stacks, radius);
367  SELECT_GEOMETRY_OPTIMIZATION(index, s, slices + 1, stacks + 1);
368  glGenVertexArrays(1, &_garray[i].vao);
369  glBindVertexArray(_garray[i].vao);
370  glEnableVertexAttribArray(0);
371  glEnableVertexAttribArray(1);
372  glEnableVertexAttribArray(2);
373  glGenBuffers(2, s->buffers);
374  glBindBuffer(GL_ARRAY_BUFFER, s->buffers[0]);
375  glBufferData(GL_ARRAY_BUFFER, 8 * (slices + 1) * (stacks + 1) * sizeof *idata, idata, GL_STATIC_DRAW);
376  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *idata), (const void *)0);
377  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *idata), (const void *)(3 * sizeof *idata));
378  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, (8 * sizeof *idata), (const void *)(6 * sizeof *idata));
379  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s->buffers[1]);
380  glBufferData(GL_ELEMENT_ARRAY_BUFFER, s->index_row_count * s->index_nb_rows * sizeof *index, index, GL_STATIC_DRAW);
381  free(idata);
382  free(index);
383  glBindVertexArray(0);
384  glBindBuffer(GL_ARRAY_BUFFER, 0);
385  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
386  return ++i;
387 }

Références _garray, gtorus_t::buffers, GE_TORUS, genId(), geom_t::geom, gtorus_t::index_nb_rows, gtorus_t::index_row_count, mkTorusVerticesf(), gtorus_t::radius, SELECT_GEOMETRY_OPTIMIZATION, gtorus_t::slices, gtorus_t::stacks, et geom_t::type.

◆ gl4dgGetVAO()

GL4DAPI GLuint GL4DAPIENTRY gl4dgGetVAO ( GLuint  id)

Renvoie l'identifiant du Vertex Array Object correspondant à l'objet-géométrie référencé par id.

Paramètres
idla référence de l'objet-géométrie généré par cette bibliothèque.
Renvoie
l'identifiant du Vertex Array Object correspondant à l'objet-géométrie référencé par id.
208  {
209  return _garray[--id].vao;
210 }

Références _garray, et geom_t::vao.

◆ gl4dgInit()

GL4DAPI void GL4DAPIENTRY gl4dgInit ( void  )

Initialise les structures nécessaire au stockage des géométries proposées par GL4Dummies. Cette fonction est appelée par la fonction gl4duInit, utilisez donc cette dernière.

Chaque géométrie générée via les fonctions gl4dgGenXXXXXX peut être libérée si nécessaire par gl4dgDelete en lui passant l'identifiant de l'objet-géométrie obtenu. Sinon utiliser, en fin de programme, gl4dgClean ou gl4duClean avec l'argument GL4DU_GEOMETRY ou GL4DU_ALL.

Voir également
gl4duInit
gl4duClean avec l'argument GL4DU_GEOMETRY ou GL4DU_ALL
gl4dgClean
174  {
175  int i;
176  if(_hasInit) return;
177  _glist = llNew();
178  _garray = calloc(_garray_size, sizeof *_garray);
179  assert(_garray);
180  for(i = _garray_size - 1 ; i >= 0; i--) {
181  _garray[i].id = i;
182  llPush(_glist, &_garray[i]);
183  }
184  _hasInit = 1;
185 }

Références _garray, _garray_size, _glist, _hasInit, geom_t::id, llNew(), et llPush().

Référencé par gl4duInit().

◆ gl4dgSetGeometryOptimizationLevel()

GL4DAPI void GL4DAPIENTRY gl4dgSetGeometryOptimizationLevel ( GLuint  level)

Modifie le niveau d'optimisation de certaines des géométries à générer (exemple le torus, la grid et la sphère).

Paramètres
leveltrois niveaux sont possibles : 0 fabriquer surtout des triangles, 1 (par défaut) tenter de faire des triangle_strips, 2 essayer de tout faire en une seule strip.
204  {
205  _geometry_optimization_level = level;
206 }

Références _geometry_optimization_level.

gtorus_t::index_row_count
GLsizei index_row_count
Definition: gl4dg.c:130
_garray_size
static GLint _garray_size
Definition: gl4dg.c:148
gsphere_t
Definition: gl4dg.c:96
GE_GRID2D
@ GE_GRID2D
Definition: gl4dg.c:86
gteapot_t::buffer
GLuint buffer
Definition: gl4dg.c:143
mkConeVerticesf
static GLfloat * mkConeVerticesf(GLuint slices, GLboolean base)
Definition: gl4dg.c:867
ggrid2d_t::width
GLuint width
Definition: gl4dg.c:136
gteapot_t
Definition: gl4dg.c:142
gteapot_t::slices
GLuint slices
Definition: gl4dg.c:144
gcylinder_t::buffer
GLuint buffer
Definition: gl4dg.c:115
gsphere_t::index_row_count
GLsizei index_row_count
Definition: gl4dg.c:100
gcylinder_t
Definition: gl4dg.c:114
ggrid2d_t::buffers
GLuint buffers[2]
Definition: gl4dg.c:135
gsphere_t::buffers
GLuint buffers[2]
Definition: gl4dg.c:97
ggrid2d_t::index_nb_rows
GLsizei index_nb_rows
Definition: gl4dg.c:139
geom_t::type
geom_e type
Definition: gl4dg.c:92
mkTeapotVerticesf
static GLfloat * mkTeapotVerticesf(GLuint slices)
Definition: gl4dg.c:1078
llFree
static void llFree(ll_t **head)
Definition: gl4dfFractalPainting.c:770
ggrid2d_t::height
GLuint height
Definition: gl4dg.c:136
gdisk_t::buffer
GLuint buffer
Definition: gl4dg.c:121
GE_QUAD
@ GE_QUAD
Definition: gl4dg.c:79
freeGeom
static void freeGeom(void *data)
Definition: gl4dg.c:531
GE_FAN_CONE
@ GE_FAN_CONE
Definition: gl4dg.c:82
GE_SPHERE
@ GE_SPHERE
Definition: gl4dg.c:78
mkStaticf
static GLuint mkStaticf(geom_e type)
Definition: gl4dg.c:593
geom_t::vao
GLuint vao
Definition: gl4dg.c:91
mkTorusVerticesf
static GLfloat * mkTorusVerticesf(GLuint slices, GLuint stacks, GLfloat radius)
Definition: gl4dg.c:937
mkSphereVerticesf
static GLfloat * mkSphereVerticesf(GLuint slices, GLuint stacks)
Definition: gl4dg.c:663
gcone_t::base
GLboolean base
Definition: gl4dg.c:111
_hasInit
static int _hasInit
Definition: gl4dg.c:150
GE_CONE
@ GE_CONE
Definition: gl4dg.c:81
gtorus_t::buffers
GLuint buffers[2]
Definition: gl4dg.c:126
_garray
static geom_t * _garray
Definition: gl4dg.c:147
mkFanConeVerticesf
static GLfloat * mkFanConeVerticesf(GLuint slices, GLboolean base)
Definition: gl4dg.c:890
_geometry_optimization_level
static GLuint _geometry_optimization_level
Definition: gl4dg.c:151
genId
static GLuint genId(void)
Definition: gl4dg.c:576
mkGrid2dVerticesf
static GLfloat * mkGrid2dVerticesf(GLuint width, GLuint height, GLfloat *heightmap)
Definition: gl4dg.c:967
gsphere_t::slices
GLuint slices
Definition: gl4dg.c:98
gcone_t::slices
GLuint slices
Definition: gl4dg.c:110
gcylinder_t::slices
GLuint slices
Definition: gl4dg.c:116
gdisk_t::slices
GLuint slices
Definition: gl4dg.c:122
geom_t::id
GLuint id
Definition: gl4dg.c:91
ggrid2d_t::index_row_count
GLsizei index_row_count
Definition: gl4dg.c:138
DRAW_WITH_GEOMETRY_OPTIMIZATION
#define DRAW_WITH_GEOMETRY_OPTIMIZATION(geom)
dessine un element-array selon la topologie de l'objet.
Definition: gl4dg.c:57
SELECT_GEOMETRY_OPTIMIZATION
#define SELECT_GEOMETRY_OPTIMIZATION(index, geom, w, h)
permet de sélectionner une topologie à utiliser selon le niveau d'optimisation géométrique choisie.
Definition: gl4dg.c:21
gdisk_t
Definition: gl4dg.c:120
gcylinder_t::base
GLboolean base
Definition: gl4dg.c:117
ggrid2d_t
Definition: gl4dg.c:134
GE_DISK
@ GE_DISK
Definition: gl4dg.c:84
gcone_t::buffer
GLuint buffer
Definition: gl4dg.c:109
gtorus_t::stacks
GLuint stacks
Definition: gl4dg.c:127
GE_TORUS
@ GE_TORUS
Definition: gl4dg.c:85
gtorus_t
Definition: gl4dg.c:125
gsphere_t::index_nb_rows
GLsizei index_nb_rows
Definition: gl4dg.c:101
GE_TEAPOT
@ GE_TEAPOT
Definition: gl4dg.c:87
GE_CYLINDER
@ GE_CYLINDER
Definition: gl4dg.c:83
mkCylinderVerticesf
static GLfloat * mkCylinderVerticesf(GLuint slices, GLboolean base)
Definition: gl4dg.c:901
llPush
void llPush(linked_list_t *ll, void *data)
Definition: linked_list.c:28
gl4dgGenGrid2dFromHeightMapf
GLuint gl4dgGenGrid2dFromHeightMapf(GLuint width, GLuint height, GLfloat *heightmap)
Génère un objet-géométrie de type grille-heightmap et renvoie son identifiant (référence).
Definition: gl4dg.c:393
gtorus_t::index_nb_rows
GLsizei index_nb_rows
Definition: gl4dg.c:131
llNew
linked_list_t * llNew(void)
Definition: linked_list.c:12
_glist
static linked_list_t * _glist
Definition: gl4dg.c:149
gtorus_t::radius
GLdouble radius
Definition: gl4dg.c:128
GL4Dvaoindex
GLuint GL4Dvaoindex
Definition: gl4dummies.h:134
GE_CUBE
@ GE_CUBE
Definition: gl4dg.c:80
gcone_t
Definition: gl4dg.c:108
geom_t::geom
void * geom
Definition: gl4dg.c:93
gsphere_t::stacks
GLuint stacks
Definition: gl4dg.c:98
gtorus_t::slices
GLuint slices
Definition: gl4dg.c:127
mkDiskVerticesf
static GLfloat * mkDiskVerticesf(GLuint slices)
Definition: gl4dg.c:928