GL4Dummies  0.1.7
Structures de données | Macros | Définitions de type | Énumérations | Fonctions | Variables
Référence du fichier gl4dg.c

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

#include <math.h>
#include "linked_list.h"
#include "gl4dg.h"
#include "gl4dm.h"
#include <stdlib.h>
#include <assert.h>
Graphe des dépendances par inclusion de gl4dg.c:

Aller au code source de ce fichier.

Structures de données

struct  geom_t
 
struct  gsphere_t
 
struct  gstatic_t
 
struct  gcone_t
 
struct  gcylinder_t
 
struct  gdisk_t
 
struct  gtorus_t
 
struct  ggrid2d_t
 
struct  gteapot_t
 

Macros

#define SELECT_GEOMETRY_OPTIMIZATION(index, geom, w, h)
 permet de sélectionner une topologie à utiliser selon le niveau d'optimisation géométrique choisie. Plus de détails...
 
#define DRAW_WITH_GEOMETRY_OPTIMIZATION(geom)
 dessine un element-array selon la topologie de l'objet. Plus de détails...
 
#define DISK_FAN(d, i, ym, ye, slices, normals)
 Macro servant à remplir des FANs, soit en disk soit en cone. d est data, i est indice à partir duquel remplir, ym est le y du point central, ye est le y du point extreme, slices est le nombre de longitudes et normals est la fonction calculant les normales. Plus de détails...
 

Définitions de type

typedef struct geom_t geom_t
 
typedef struct gsphere_t gsphere_t
 
typedef struct gstatic_t gstatic_t
 
typedef struct gcone_t gcone_t
 
typedef struct gcylinder_t gcylinder_t
 
typedef struct gdisk_t gdisk_t
 
typedef struct gtorus_t gtorus_t
 
typedef struct ggrid2d_t ggrid2d_t
 
typedef struct gteapot_t gteapot_t
 
typedef enum geom_e geom_e
 

Énumérations

enum  geom_e {
  GE_NONE = 0, GE_SPHERE, GE_QUAD, GE_CUBE,
  GE_CONE, GE_FAN_CONE, GE_CYLINDER, GE_DISK,
  GE_TORUS, GE_GRID2D, GE_TEAPOT
}
 

Fonctions

static void freeGeom (void *data)
 
static GLuint genId (void)
 
static GLuint mkStaticf (geom_e type)
 
static GLfloat * mkSphereVerticesf (GLuint slices, GLuint stacks)
 
static GL4Dvaoindex * mkRegularGridTriangleIndices (GLuint width, GLuint height)
 
static GL4Dvaoindex * mkRegularGridStripsIndices (GLuint width, GLuint height)
 
static GL4Dvaoindex * mkRegularGridStripIndices (GLuint width, GLuint height)
 
static GL4Dvaoindex * mkRegularGridTriangleAdjacencyIndices (GLuint width, GLuint height)
 
static GL4Dvaoindex * mkRegularGridStripsAdjacencyIndices (GLuint width, GLuint height)
 
static GLfloat * mkConeVerticesf (GLuint slices, GLboolean base)
 
static GLfloat * mkFanConeVerticesf (GLuint slices, GLboolean base)
 
static GLfloat * mkCylinderVerticesf (GLuint slices, GLboolean base)
 
static GLfloat * mkDiskVerticesf (GLuint slices)
 
static GLfloat * mkTorusVerticesf (GLuint slices, GLuint stacks, GLfloat radius)
 
static GLfloat * mkGrid2dVerticesf (GLuint width, GLuint height, GLfloat *heightmap)
 
static GLfloat * mkTeapotVerticesf (GLuint slices)
 
static void mkGrid2dNormalsf (GLuint width, GLuint height, GLfloat *data)
 
static void triangleNormalf (GLfloat *out, GLfloat *p0, GLfloat *p1, GLfloat *p2)
 
static int _maxi (int a, int b)
 
static int _mini (int a, int b)
 
void 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...
 
void 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...
 
void 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...
 
GLuint 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...
 
GLuint 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...
 
GLuint 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...
 
GLuint gl4dgGenCubef (void)
 Génère un objet-géométrie de type cube et renvoie son identifiant (référence). Plus de détails...
 
GLuint 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...
 
GLuint 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...
 
GLuint 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...
 
GLuint 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...
 
GLuint 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...
 
GLuint 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...
 
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). Plus de détails...
 
GLuint 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...
 
void gl4dgDraw (GLuint id)
 Dessine un objet-géométrie dont l'identifiant (référence) est passé en argument. Plus de détails...
 
void gl4dgDelete (GLuint id)
 Détruit un objet-géométrie dont l'identifiant (référence) est passé en argument. Plus de détails...
 
static void fcvNormals (GLfloat *p, GLfloat y, int i)
 
static void fcvbNormals (GLfloat *p, GLfloat y, int i)
 

Variables

static geom_t * _garray = NULL
 
static GLint _garray_size = 256
 
static linked_list_t * _glist = NULL
 
static int _hasInit = 0
 
static GLuint _geometry_optimization_level = 1
 

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.c.

Documentation des macros

◆ DISK_FAN

#define DISK_FAN (   d,
  i,
  ym,
  ye,
  slices,
  normals 
)
Valeur :
do { \
int j; \
const GLdouble _1pi_4 = M_PI / 4, _3pi_4 = 3 * M_PI / 4; \
const GLdouble _5pi_4 = 5 * M_PI / 4, _7pi_4 = 7 * M_PI / 4; \
GLdouble c2MPI_Long = 2 * M_PI / slices, sens = SIGN(ym), phi; \
(d)[(i)++] = 0; (d)[(i)++] = ym; (d)[(i)++] = 0; \
(d)[(i)++] = 0; (d)[(i)++] = sens; (d)[(i)++] = 0; \
(d)[(i)++] = 0.5; (d)[(i)++] = 0.5; \
for(j = 0; j <= (slices); ++j) { \
phi = j * c2MPI_Long; \
(d)[(i)++] = -cos(sens * phi); \
(d)[(i)++] = (ye); \
(d)[(i)++] = sin(sens * phi); \
(normals)((d), (ye), (i)); (i) += 3; \
if(phi < _1pi_4 || phi > _7pi_4) { \
(d)[(i)++] = 1.0; \
(d)[(i)++] = 0.5 + tan(phi) / 2.0; \
} else if(phi < _3pi_4) { \
(d)[(i)++] = 0.5 - tan(phi - GL4DM_PI_2) / 2.0; \
(d)[(i)++] = 1.0; \
} else if(phi < _5pi_4) { \
(d)[(i)++] = 0.0; \
(d)[(i)++] = 0.5 - tan(phi) / 2.0; \
} else { \
(d)[(i)++] = 0.5 + tan(phi - GL4DM_PI_2) / 2.0; \
(d)[(i)++] = 0.0; \
} \
} \
} while(0)

Macro servant à remplir des FANs, soit en disk soit en cone. d est data, i est indice à partir duquel remplir, ym est le y du point central, ye est le y du point extreme, slices est le nombre de longitudes et normals est la fonction calculant les normales.

◆ DRAW_WITH_GEOMETRY_OPTIMIZATION

#define DRAW_WITH_GEOMETRY_OPTIMIZATION (   geom)
Valeur :
do { \
int i, d; \
for(i = 0, d = 0; i < (geom)->index_nb_rows; ++i) { \
glDrawElements((geom)->index_mode, (geom)->index_row_count, GL4D_VAO_INDEX, (const GLvoid *)(intptr_t)d); \
d += (geom)->index_row_count * sizeof(GL4Dvaoindex); \
} \
} while(0)

dessine un element-array selon la topologie de l'objet.

◆ 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.

Documentation des définitions de type

◆ gcone_t

typedef struct gcone_t gcone_t

◆ gcylinder_t

typedef struct gcylinder_t gcylinder_t

◆ gdisk_t

typedef struct gdisk_t gdisk_t

◆ geom_e

typedef enum geom_e geom_e

◆ geom_t

typedef struct geom_t geom_t

◆ ggrid2d_t

typedef struct ggrid2d_t ggrid2d_t

◆ gsphere_t

typedef struct gsphere_t gsphere_t

◆ gstatic_t

typedef struct gstatic_t gstatic_t

◆ gteapot_t

typedef struct gteapot_t gteapot_t

◆ gtorus_t

typedef struct gtorus_t gtorus_t

Documentation du type de l'énumération

◆ geom_e

enum geom_e
Valeurs énumérées
GE_NONE 
GE_SPHERE 
GE_QUAD 
GE_CUBE 
GE_CONE 
GE_FAN_CONE 
GE_CYLINDER 
GE_DISK 
GE_TORUS 
GE_GRID2D 
GE_TEAPOT 
76  {
77  GE_NONE = 0,
78  GE_SPHERE,
79  GE_QUAD,
80  GE_CUBE,
81  GE_CONE,
82  GE_FAN_CONE,
83  GE_CYLINDER,
84  GE_DISK,
85  GE_TORUS,
86  GE_GRID2D,
87  GE_TEAPOT
88 };

Documentation des fonctions

◆ _maxi()

static int _maxi ( int  a,
int  b 
)
inlinestatic
1203  {
1204  return a > b ? a : b;
1205 }

Référencé par mkRegularGridStripsAdjacencyIndices(), et mkRegularGridTriangleAdjacencyIndices().

◆ _mini()

static int _mini ( int  a,
int  b 
)
inlinestatic
1207  {
1208  return a < b ? a : b;
1209 }

Référencé par mkRegularGridTriangleAdjacencyIndices().

◆ fcvbNormals()

static void fcvbNormals ( GLfloat *  p,
GLfloat  y,
int  i 
)
inlinestatic
825  {
826  p[i] = 0;
827  p[i + 1] = y;
828  p[i + 2] = 0;
829 }

Référencé par mkConeVerticesf(), mkCylinderVerticesf(), mkDiskVerticesf(), et mkFanConeVerticesf().

◆ fcvNormals()

static void fcvNormals ( GLfloat *  p,
GLfloat  y,
int  i 
)
inlinestatic
818  {
819  (void)y; /* warning silenced */
820  p[i] = 2.0f * p[i - 3] / sqrt(5.0);
821  p[i + 1] = 1.0f / sqrt(5.0);
822  p[i + 2] = 2.0f * p[i - 1] / sqrt(5.0);
823 }

Référencé par mkConeVerticesf(), mkCylinderVerticesf(), et mkFanConeVerticesf().

◆ freeGeom()

static void freeGeom ( void *  data)
static
531  {
532  geom_t * geom = (geom_t *)data;
533  switch(geom->type) {
534  case GE_SPHERE:
535  glDeleteVertexArrays(1, &(geom->vao));
536  glDeleteBuffers(2, ((gsphere_t *)(geom->geom))->buffers);
537  break;
538  case GE_TORUS:
539  glDeleteVertexArrays(1, &(geom->vao));
540  glDeleteBuffers(2, ((gtorus_t *)(geom->geom))->buffers);
541  break;
542  case GE_GRID2D:
543  glDeleteVertexArrays(1, &(geom->vao));
544  glDeleteBuffers(2, ((ggrid2d_t *)(geom->geom))->buffers);
545  break;
546  case GE_QUAD:
547  case GE_CUBE:
548  glDeleteVertexArrays(1, &(geom->vao));
549  glDeleteBuffers(1, &(((gstatic_t *)(geom->geom))->buffer));
550  break;
551  case GE_CONE:
552  case GE_FAN_CONE:
553  glDeleteVertexArrays(1, &(geom->vao));
554  glDeleteBuffers(1, &(((gcone_t *)(geom->geom))->buffer));
555  break;
556  case GE_CYLINDER:
557  glDeleteVertexArrays(1, &(geom->vao));
558  glDeleteBuffers(1, &(((gcylinder_t *)(geom->geom))->buffer));
559  break;
560  case GE_DISK:
561  glDeleteVertexArrays(1, &(geom->vao));
562  glDeleteBuffers(1, &(((gdisk_t *)(geom->geom))->buffer));
563  break;
564  case GE_TEAPOT:
565  glDeleteVertexArrays(1, &(geom->vao));
566  glDeleteBuffers(1, &(((gteapot_t *)(geom->geom))->buffer));
567  break;
568  default:
569  break;
570  }
571  if(geom->geom)
572  free(geom->geom);
573  geom->geom = NULL;
574 }

Références GE_CONE, GE_CUBE, GE_CYLINDER, GE_DISK, GE_FAN_CONE, GE_GRID2D, GE_QUAD, GE_SPHERE, GE_TEAPOT, GE_TORUS, geom_t::geom, geom_t::type, et geom_t::vao.

Référencé par gl4dgClean(), et gl4dgDelete().

◆ genId()

static GLuint genId ( void  )
static
576  {
577  int i;
578  if(llEmpty(_glist)) {
579  int s = _garray_size;
580  _garray = realloc(_garray, (_garray_size *= 2) * sizeof *_garray);
581  assert(_garray);
582  for(i = _garray_size - 1 ; i >= s; i--) {
583  _garray[i].id = i;
584  _garray[i].vao = 0;
585  _garray[i].type = 0;
586  _garray[i].geom = NULL;
587  llPush(_glist, &_garray[i]);
588  }
589  }
590  return ((geom_t *)llPop(_glist))->id;
591 }

Références _garray, _garray_size, _glist, geom_t::geom, geom_t::id, llEmpty(), llPop(), llPush(), geom_t::type, et geom_t::vao.

Référencé par gl4dgGenConef(), gl4dgGenCylinderf(), gl4dgGenDiskf(), gl4dgGenFanConef(), gl4dgGenGrid2dFromHeightMapf(), gl4dgGenSpheref(), gl4dgGenTeapotf(), gl4dgGenTorusf(), et mkStaticf().

◆ gl4dgClean()

void 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()

void 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()

void 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()

GLuint 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()

GLuint 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()

GLuint 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()

GLuint 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()

GLuint 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()

GLuint 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()

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).

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()

GLuint 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()

GLuint 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()

GLuint 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()

GLuint 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()

GLuint 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()

void 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()

void 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.

◆ mkConeVerticesf()

static GLfloat * mkConeVerticesf ( GLuint  slices,
GLboolean  base 
)
static
867  {
868  int j, k = 0;
869  GLdouble phi;
870  GLfloat * data;
871  GLdouble c2MPI_Long = 2.0 * M_PI / slices, s;
872  data = malloc((16 * (slices + 1) + (base ? 8 : 0) * (slices + 2)) * sizeof *data);
873  assert(data);
874  for(j = 0; j <= (int)slices; ++j) {
875  data[k++] = 0; data[k++] = 1; data[k++] = 0;
876  data[k++] = 0; data[k++] = 1; data[k++] = 0;
877  data[k++] = (s = j / (GLdouble)slices); data[k++] = 1;
878  phi = j * c2MPI_Long;
879  data[k++] = -cos(phi);
880  data[k++] = -1;
881  data[k++] = sin(phi);
882  fcvNormals(data, 0, k); k += 3;
883  data[k++] = s; data[k++] = 0;
884  }
885  if(base)
886  DISK_FAN(data, k, -1, -1, (int)slices, fcvbNormals);
887  return data;
888 }

Références DISK_FAN, fcvbNormals(), et fcvNormals().

Référencé par gl4dgGenConef().

◆ mkCylinderVerticesf()

static GLfloat * mkCylinderVerticesf ( GLuint  slices,
GLboolean  base 
)
static
901  {
902  int j, k = 0;
903  GLdouble phi;
904  GLfloat * data;
905  GLdouble c2MPI_Long = 2.0 * M_PI / slices, s;
906  data = malloc((16 * (slices + 1) + (base ? 16 : 0) * (slices + 2)) * sizeof *data);
907  assert(data);
908  for(j = 0; j <= (int)slices; ++j) {
909  phi = j * c2MPI_Long;
910  data[k++] = -cos(phi);
911  data[k++] = 1;
912  data[k++] = sin(phi);
913  fcvNormals(data, 0, k); k += 3;
914  data[k++] = (s = j / (GLdouble)slices); data[k++] = 1;
915  data[k] = data[k - 8]; k++;
916  data[k++] = -1;
917  data[k] = data[k - 8]; k++;
918  fcvNormals(data, 0, k); k += 3;
919  data[k++] = s; data[k++] = 0;
920  }
921  if(base) {
922  DISK_FAN(data, k, 1, 1, (int)slices, fcvbNormals);
923  DISK_FAN(data, k, -1, -1, (int)slices, fcvbNormals);
924  }
925  return data;
926 }

Références DISK_FAN, fcvbNormals(), et fcvNormals().

Référencé par gl4dgGenCylinderf().

◆ mkDiskVerticesf()

static GLfloat * mkDiskVerticesf ( GLuint  slices)
static
928  {
929  int k = 0;
930  GLfloat * data;
931  data = malloc(8 * (slices + 2) * sizeof *data);
932  assert(data);
933  DISK_FAN(data, k, 0, 0, (int)slices, fcvbNormals);
934  return data;
935 }

Références DISK_FAN, et fcvbNormals().

Référencé par gl4dgGenDiskf().

◆ mkFanConeVerticesf()

static GLfloat * mkFanConeVerticesf ( GLuint  slices,
GLboolean  base 
)
static
890  {
891  int k = 0;
892  GLfloat * data;
893  data = malloc((base ? 16 : 8) * (slices + 2) * sizeof *data);
894  assert(data);
895  DISK_FAN(data, k, 1, -1, (int)slices, fcvNormals);
896  if(base)
897  DISK_FAN(data, k, -1, -1, (int)slices, fcvbNormals);
898  return data;
899 }

Références DISK_FAN, fcvbNormals(), et fcvNormals().

Référencé par gl4dgGenFanConef().

◆ mkGrid2dNormalsf()

static void mkGrid2dNormalsf ( GLuint  width,
GLuint  height,
GLfloat *  data 
)
static
999  {
1000  int x, z, zw, i, wm1 = width - 1, hm1 = height - 1;
1001  GLfloat n[18];
1002  /* pour les sommets ayant 8 voisins */
1003  for(z = 1; z < hm1; ++z) {
1004  zw = z * width;
1005  for(x = 1; x < wm1; ++x) {
1006  triangleNormalf(&n[0], &data[8 * (x + zw)], &data[8 * (x + 1 + zw)], &data[8 * (x + 1 + (z - 1) * width)]);
1007  triangleNormalf(&n[3], &data[8 * (x + zw)], &data[8 * (x + 1 + (z - 1) * width)], &data[8 * (x + (z - 1) * width)]);
1008  triangleNormalf(&n[6], &data[8 * (x + zw)], &data[8 * (x + (z - 1) * width)], &data[8 * (x - 1 + zw)]);
1009  triangleNormalf(&n[9], &data[8 * (x + zw)], &data[8 * (x - 1 + zw)], &data[8 * (x - 1 + (z + 1) * width)]);
1010  triangleNormalf(&n[12], &data[8 * (x + zw)], &data[8 * (x - 1 + (z + 1) * width)], &data[8 * (x + (z + 1) * width)]);
1011  triangleNormalf(&n[15], &data[8 * (x + zw)], &data[8 * (x + (z + 1) * width)], &data[8 * (x + 1 + zw)]);
1012  data[8 * (x + zw) + 3] = 0.0f;
1013  data[8 * (x + zw) + 4] = 0.0f;
1014  data[8 * (x + zw) + 5] = 0.0f;
1015  for(i = 0; i < 6; ++i) {
1016  data[8 * (x + zw) + 3] += n[3 * i + 0];
1017  data[8 * (x + zw) + 4] += n[3 * i + 1];
1018  data[8 * (x + zw) + 5] += n[3 * i + 2];
1019  }
1020  data[8 * (x + zw) + 3] /= 6.0f;
1021  data[8 * (x + zw) + 4] /= 6.0f;
1022  data[8 * (x + zw) + 5] /= 6.0f;
1023  }
1024  }
1025  /* pour les 4 coins */
1026  /* haut-gauche (x = 0, z = 0) */
1027  triangleNormalf(&data[3], &data[0], &data[8 * width], &data[8]);
1028  /* bas-droite (x = w - 1, z = h - 1) */
1029  triangleNormalf(&data[8 * (wm1 + hm1 * width) + 3], &data[8 * (wm1 + hm1 * width)], &data[8 * (wm1 + (height - 2) * width)], &data[8 * (width - 2 + hm1 * width)]);
1030  /* haut-droite (x = w - 1, z = 0) */
1031  triangleNormalf(&n[0], &data[8 * wm1], &data[8 * (wm1 - 1)], &data[8 * (wm1 - 1 + width)]);
1032  triangleNormalf(&n[3], &data[8 * wm1], &data[8 * (wm1 - 1 + width)], &data[8 * (wm1 + width)]);
1033  for(i = 0; i < 3; ++i)
1034  data[8 * wm1 + 3 + i] = (n[i] + n[3 + i]) / 2.0f;
1035  /* bas-gauche (x = 0, z = hm1) */
1036  zw = hm1 * width;
1037  triangleNormalf(&n[0], &data[8 * zw], &data[8 * (1 + zw)], &data[8 * (1 + (hm1 - 1) * width)]);
1038  triangleNormalf(&n[3], &data[8 * zw], &data[8 * (1 + (hm1 - 1) * width)], &data[8 * ((hm1 - 1) * width)]);
1039  for(i = 0; i < 3; ++i)
1040  data[8 * zw + 3 + i] = (n[i] + n[3 + i]) / 2.0f;
1041  /* le bord gauche et droit */
1042  for(z = 1; z < hm1; ++z) {
1043  zw = z * width;
1044  /* gauche */
1045  x = 0;
1046  triangleNormalf(&n[0], &data[8 * (x + zw)], &data[8 * (x + 1 + zw)], &data[8 * (x + 1 + (z - 1) * width)]);
1047  triangleNormalf(&n[3], &data[8 * (x + zw)], &data[8 * (x + 1 + (z - 1) * width)], &data[8 * (x + (z - 1) * width)]);
1048  triangleNormalf(&n[6], &data[8 * (x + zw)], &data[8 * (x + (z + 1) * width)], &data[8 * (x + 1 + zw)]);
1049  for(i = 0; i < 3; ++i)
1050  data[8 * (x + zw) + 3 + i] = (n[i] + n[3 + i] + n[6 + i]) / 3.0f;
1051  /* droit */
1052  x = wm1;
1053  triangleNormalf(&n[0], &data[8 * (x + zw)], &data[8 * (x + (z - 1) * width)], &data[8 * (x - 1 + zw)]);
1054  triangleNormalf(&n[3], &data[8 * (x + zw)], &data[8 * (x - 1 + zw)], &data[8 * (x - 1 + (z + 1) * width)]);
1055  triangleNormalf(&n[6], &data[8 * (x + zw)], &data[8 * (x - 1 + (z + 1) * width)], &data[8 * (x + (z + 1) * width)]);
1056  for(i = 0; i < 3; ++i)
1057  data[8 * (x + zw) + 3 + i] = (n[i] + n[3 + i] + n[6 + i]) / 3.0f;
1058  }
1059  /* le bord haut et bas */
1060  for(x = 1; x < wm1; ++x) {
1061  /* haut */
1062  z = 0; zw = 0;
1063  triangleNormalf(&n[0], &data[8 * (x + zw)], &data[8 * (x - 1 + zw)], &data[8 * (x - 1 + (z + 1) * width)]);
1064  triangleNormalf(&n[3], &data[8 * (x + zw)], &data[8 * (x - 1 + (z + 1) * width)], &data[8 * (x + (z + 1) * width)]);
1065  triangleNormalf(&n[6], &data[8 * (x + zw)], &data[8 * (x + (z + 1) * width)], &data[8 * (x + 1 + zw)]);
1066  for(i = 0; i < 3; ++i)
1067  data[8 * (x + zw) + 3 + i] = (n[i] + n[3 + i] + n[6 + i]) / 3.0f;
1068  /* bas */
1069  z = hm1; zw = z * width;
1070  triangleNormalf(&n[0], &data[8 * (x + zw)], &data[8 * (x + 1 + zw)], &data[8 * (x + 1 + (z - 1) * width)]);
1071  triangleNormalf(&n[3], &data[8 * (x + zw)], &data[8 * (x + 1 + (z - 1) * width)], &data[8 * (x + (z - 1) * width)]);
1072  triangleNormalf(&n[6], &data[8 * (x + zw)], &data[8 * (x + (z - 1) * width)], &data[8 * (x - 1 + zw)]);
1073  for(i = 0; i < 3; ++i)
1074  data[8 * (x + zw) + 3 + i] = (n[i] + n[3 + i] + n[6 + i]) / 3.0f;
1075  }
1076 }

Références triangleNormalf().

Référencé par mkGrid2dVerticesf().

◆ mkGrid2dVerticesf()

static GLfloat * mkGrid2dVerticesf ( GLuint  width,
GLuint  height,
GLfloat *  heightmap 
)
static
967  {
968  int i, j, k, iw;
969  GLdouble x, z, tx, tz;
970  GLfloat * data;
971  data = malloc(8 * width * height * sizeof *data);
972  assert(data);
973  if(heightmap) {
974  for(i = 0, k = 0; i < (int)height; ++i) {
975  z = -1.0f + 2.0f * (tz = i / (height - 1.0f));
976  iw = i * width;
977  for(j = 0; j < (int)width; ++j) {
978  x = -1.0f + 2.0f * (tx = j / (width - 1.0f));
979  data[k++] = x; data[k++] = 2.0f * heightmap[iw + j] - 1.0f; data[k++] = z;
980  k += 3;
981  data[k++] = tx; data[k++] = tz;
982  }
983  }
984  mkGrid2dNormalsf(width, height, data);
985  } else {
986  for(i = 0, k = 0; i < (int)height; ++i) {
987  z = -1.0f + 2.0f * (tz = i / (height - 1.0f));
988  for(j = 0; j < (int)width; ++j) {
989  x = -1.0f + 2.0f * (tx = j / (width - 1.0f));
990  data[k++] = x; data[k++] = 0; data[k++] = z;
991  data[k++] = 0; data[k++] = 1; data[k++] = 0;
992  data[k++] = tx; data[k++] = tz;
993  }
994  }
995  }
996  return data;
997 }

Références mkGrid2dNormalsf().

Référencé par gl4dgGenGrid2dFromHeightMapf().

◆ mkRegularGridStripIndices()

static GL4Dvaoindex * mkRegularGridStripIndices ( GLuint  width,
GLuint  height 
)
static
729  {
730  int z, x, k, zw, nzw, nnzw, wm1 = width - 1, hm1 = height - 1, hi = hm1 - ((height&1) ? 0 : 1);
731  GLuint * index;
732  assert(height > 1 && width > 1);
733  index = malloc(2 * width * hm1 * sizeof *index);
734  assert(index);
735  for(z = 0, k = 0; z < hi; z += 2) {
736  zw = z * width;
737  nzw = zw + width;
738  nnzw = nzw + width;
739  for(x = 0; x < (int)width; ++x) {
740  index[k++] = zw + x;
741  index[k++] = nzw + x;
742  }
743  for(x = wm1; x >= 0; x--) {
744  index[k++] = nnzw + x;
745  index[k++] = nzw + x;
746  }
747  }
748  if(!(height&1)) {
749  zw = z * width;
750  nzw = zw + width;
751  for(x = 0; x < (int)width; ++x) {
752  index[k++] = zw + x;
753  index[k++] = nzw + x;
754  }
755  }
756  return index;
757 }

◆ mkRegularGridStripsAdjacencyIndices()

static GL4Dvaoindex * mkRegularGridStripsAdjacencyIndices ( GLuint  width,
GLuint  height 
)
static
793  {
794  int z, zw, pzw, nzw, nnzw, x, k, hm1 = height - 1;
795  GLuint * index;
796  assert(height > 1 && width > 1);
797  index = malloc(4 * width * hm1 * sizeof *index);
798  assert(index);
799  for(z = 0, k = 0; z < hm1; ++z) {
800  zw = z * width;
801  pzw = _maxi(z - 1, 0) * width;
802  nzw = zw + width;
803  nnzw = zw + 2 * width;
804  index[k++] = zw; /* (0, z) */
805  index[k++] = nzw; /* (-1, z + 1) -> (0, z + 1) */
806  index[k++] = nzw; /* (0, z + 1) */
807  for(x = 1; x < (int)width; ++x) {
808  index[k++] = pzw + x; /* (x, z - 1) */
809  index[k++] = zw + x; /* (x, z) */
810  index[k++] = nnzw + x - 1; /* (x - 1, z + 2) */
811  index[k++] = nzw + x; /* (x, z + 1) */
812  }
813  index[k++] = zw + width - 1; /* (w, z) -> (w - 1, z) */
814  }
815  return index;
816 }

Références _maxi().

◆ mkRegularGridStripsIndices()

static GL4Dvaoindex * mkRegularGridStripsIndices ( GLuint  width,
GLuint  height 
)
static
712  {
713  int z, x, k, zw, nzw, hm1 = height - 1;
714  GLuint * index;
715  assert(height > 1 && width > 1);
716  index = malloc(2 * width * hm1 * sizeof *index);
717  assert(index);
718  for(z = 0, k = 0; z < hm1; ++z) {
719  zw = z * width;
720  nzw = zw + width;
721  for(x = 0; x < (int)width; ++x) {
722  index[k++] = zw + x;
723  index[k++] = nzw + x;
724  }
725  }
726  return index;
727 }

◆ mkRegularGridTriangleAdjacencyIndices()

static GL4Dvaoindex * mkRegularGridTriangleAdjacencyIndices ( GLuint  width,
GLuint  height 
)
static
759  {
760  int z, zw, pzw, nzw, nnzw, x, px, nx, nnx, k, wm1 = width - 1, hm1 = height - 1;
761  GLuint * index;
762  assert(height > 1 && width > 1);
763  index = malloc(12 * wm1 * hm1 * sizeof *index);
764  assert(index);
765  for(z = 0, k = 0; z < hm1; ++z) {
766  zw = z * width;
767  pzw = _maxi(z - 1, 0) * width;
768  nzw = (z + 1) * width;
769  nnzw = _mini(z + 2, hm1) * width;
770  for(x = 0; x < wm1; ++x) {
771  px = _maxi(x - 1, 0);
772  nx = x + 1;
773  nnx = _mini(nx + 1, wm1);
774 
775  index[k++] = zw + x; /* (x, z) */
776  index[k++] = nzw + px; /* (x - 1, z + 1) */
777  index[k++] = nzw + x; /* (x, z + 1) */
778  index[k++] = nzw + nx; /* (x + 1, z + 1) */
779  index[k++] = zw + nx; /* (x + 1, z) */
780  index[k++] = pzw + nx; /* (x + 1, z - 1) */
781 
782  index[k++] = zw + nx; /* (x + 1, ) */
783  index[k++] = zw + x; /* (x, z) */
784  index[k++] = nzw + x; /* (x, z + 1) */
785  index[k++] = nnzw + x; /* (x, z + 2) */
786  index[k++] = nzw + nx; /* (x + 1, z + 1) */
787  index[k++] = zw + nnx; /* (x + 2, z) */
788  }
789  }
790  return index;
791 }

Références _maxi(), et _mini().

◆ mkRegularGridTriangleIndices()

static GL4Dvaoindex * mkRegularGridTriangleIndices ( GLuint  width,
GLuint  height 
)
static
687  {
688  int z, nz, x, nx, k, zw, nzw, wm1 = width - 1, hm1 = height - 1;
689  GLuint * index;
690  assert(height > 1 && width > 1);
691  index = malloc(6 * wm1 * hm1 * sizeof *index);
692  assert(index);
693  for(z = 0, k = 0; z < hm1; ++z) {
694  nz = z + 1;
695  zw = z * width;
696  nzw = nz * width;
697  for(x = 0; x < wm1; ++x) {
698  nx = x + 1;
699 
700  index[k++] = zw + x;
701  index[k++] = nzw + x;
702  index[k++] = zw + nx;
703 
704  index[k++] = zw + nx;
705  index[k++] = nzw + x;
706  index[k++] = nzw + nx;
707  }
708  }
709  return index;
710 }

◆ mkSphereVerticesf()

static GLfloat * mkSphereVerticesf ( GLuint  slices,
GLuint  stacks 
)
static
663  {
664  int i, j, k;
665  GLdouble phi, theta, r, y;
666  GLfloat * data;
667  GLdouble c2MPI_Long = 2.0 * M_PI / slices;
668  GLdouble cMPI_Lat = M_PI / stacks;
669  data = malloc(5 * (slices + 1) * (stacks + 1) * sizeof *data);
670  assert(data);
671  for(i = 0, k = 0; i <= (int)stacks; ++i) {
672  theta = -M_PI_2 + i * cMPI_Lat;
673  y = sin(theta);
674  r = cos(theta);
675  for(j = 0; j <= (int)slices; ++j) {
676  phi = j * c2MPI_Long;
677  data[k++] = r * cos(phi);
678  data[k++] = y;
679  data[k++] = r * sin(phi);
680  data[k++] = 1.0f - phi / (2.0 * M_PI);
681  data[k++] = (theta + M_PI_2) / M_PI;
682  }
683  }
684  return data;
685 }

Référencé par gl4dgGenSpheref().

◆ mkStaticf()

static GLuint mkStaticf ( geom_e  type)
static
593  {
594  static GLfloat quad_data[] = {
595  -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
596  1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
597  -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
598  1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f
599  };
600  static GLfloat cube_data[] = {
601  /* front */
602  -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
603  1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
604  -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
605  1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
606  /* back */
607  1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
608  -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f,
609  1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f,
610  -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
611  /* right */
612  1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
613  1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
614  1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
615  1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
616  /* left */
617  -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
618  -1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
619  -1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
620  -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
621  /* top */
622  -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
623  1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
624  -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
625  1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
626  /* bottom */
627  -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
628  1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
629  -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
630  1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f
631  };
632  GLuint i = genId();
633  gstatic_t * q = malloc(sizeof *q);
634  assert(q);
635  _garray[i].geom = q;
636  _garray[i].type = type;
637  glGenVertexArrays(1, &_garray[i].vao);
638  glBindVertexArray(_garray[i].vao);
639  glEnableVertexAttribArray(0);
640  glEnableVertexAttribArray(1);
641  glEnableVertexAttribArray(2);
642  glGenBuffers(1, &(q->buffer));
643  glBindBuffer(GL_ARRAY_BUFFER, q->buffer);
644  switch(type) {
645  case GE_QUAD:
646  glBufferData(GL_ARRAY_BUFFER, sizeof quad_data, quad_data, GL_STATIC_DRAW);
647  break;
648  case GE_CUBE:
649  glBufferData(GL_ARRAY_BUFFER, sizeof cube_data, cube_data, GL_STATIC_DRAW);
650  break;
651  default:
652  assert(0);
653  break;
654  }
655  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *quad_data), (const void *)0);
656  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, (8 * sizeof *quad_data), (const void *)(3 * sizeof *quad_data));
657  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, (8 * sizeof *quad_data), (const void *)(6 * sizeof *quad_data));
658  glBindVertexArray(0);
659  glBindBuffer(GL_ARRAY_BUFFER, 0);
660  return ++i;
661 }

Références _garray, gstatic_t::buffer, GE_CUBE, GE_QUAD, genId(), geom_t::geom, et geom_t::type.

Référencé par gl4dgGenCubef(), et gl4dgGenQuadf().

◆ mkTeapotVerticesf()

static GLfloat * mkTeapotVerticesf ( GLuint  slices)
static
1078  {
1079  /* Vertices data */
1080  static GLfloat teapot_data[][5] = {
1081  /*vertx verty normx normy texCoord lid*/
1082  { 0.000, 0.394, 0.000, 1.000, 0.000000 },
1083  { 0.085, 0.382, 0.825, 0.565, 0.055058 },
1084  { 0.081, 0.352, 0.940,-0.335, 0.074406 },
1085  { 0.049, 0.315, 0.960,-0.285, 0.105557 },
1086  { 0.050, 0.281, 0.845, 0.530, 0.126978 },
1087  { 0.114, 0.259, 0.260, 0.965, 0.170294 },
1088  { 0.206, 0.244, 0.180, 0.985, 0.230067 },
1089  { 0.289, 0.229, 0.380, 0.925, 0.283858 },
1090  { 0.325, 0.206, 0.170, 0.985, 0.310912 },
1091  /*vertx verty normx normy texCoord rim*/
1092  { 0.350, 0.206,-0.970,-0.255, 0.310912 },
1093  { 0.345, 0.225,-0.970, 0.255, 0.323163 },
1094  { 0.351, 0.231,-0.090, 1.000, 0.328592 },
1095  { 0.362, 0.225, 0.680, 0.730, 0.336960 },
1096  /*vertx verty normx normy texCoord body*/
1097  { 0.489,-0.081, 0.870, 0.495, 0.351323 },
1098  { 0.421, 0.108, 0.915, 0.405, 0.420675 },
1099  { 0.461, 0.012, 0.940, 0.335, 0.487306 },
1100  { 0.489,-0.081, 0.980, 0.205, 0.549441 },
1101  { 0.500,-0.169, 1.000,-0.065, 0.605798 },
1102  { 0.481,-0.243, 0.900,-0.435, 0.654719 },
1103  { 0.438,-0.298, 0.730,-0.685, 0.699350 },
1104  { 0.395,-0.335, 0.695,-0.720, 0.735718 },
1105  /*vertx verty normx normy texCoord bottom*/
1106  { 0.375,-0.356, 0.795,-0.610, 0.754156 },
1107  { 0.367,-0.370, 0.625,-0.780, 0.764490 },
1108  { 0.321,-0.382, 0.175,-0.985, 0.794571 },
1109  { 0.209,-0.391, 0.050,-1.000, 0.866376 },
1110  { 0.000,-0.394, 0.000,-1.000, 1.000000 }
1111  };
1112  /* Initialization of variables */
1113  int i, j, k = 0;
1114  GLfloat * data;
1115  GLdouble angle, theta = 2.0 * M_PI / slices;
1116  data = malloc((392 * slices + 8) * sizeof *data);
1117  assert(data);
1118  /* Filling the buffer */
1119  data[k++] = teapot_data[0][0];
1120  data[k++] = teapot_data[0][1];
1121  data[k++] = 0;
1122  data[k++] = teapot_data[0][2];
1123  data[k++] = teapot_data[0][3];
1124  data[k++] = 0;
1125  data[k++] = 0;
1126  data[k++] = teapot_data[0][4];
1127  for(i = 0; i < (int)slices; ++i) {
1128  angle = i*theta;
1129  if(i%2) {
1130  for(j = 24; j > 0; --j) {
1131  data[k++] = teapot_data[j][0]*cos(angle);
1132  data[k++] = teapot_data[j][1];
1133  data[k++] = teapot_data[j][0]*sin(angle);
1134  data[k++] = teapot_data[j][2]*cos(angle);
1135  data[k++] = teapot_data[j][3];
1136  data[k++] = teapot_data[j][2]*sin(angle);
1137  data[k++] = (angle)/(2.0*M_PI);
1138  data[k++] = teapot_data[j][4];
1139 
1140  data[k++] = teapot_data[j][0]*cos(angle+theta);
1141  data[k++] = teapot_data[j][1];
1142  data[k++] = teapot_data[j][0]*sin(angle+theta);
1143  data[k++] = teapot_data[j][2]*cos(angle+theta);
1144  data[k++] = teapot_data[j][3];
1145  data[k++] = teapot_data[j][2]*sin(angle+theta);
1146  data[k++] = (angle+theta)/(2.0*M_PI);
1147  data[k++] = teapot_data[j][4];
1148  }
1149  data[k++] = teapot_data[j][0];
1150  data[k++] = teapot_data[j][1];
1151  data[k++] = 0.0;
1152  data[k++] = teapot_data[j][2];
1153  data[k++] = teapot_data[j][3];
1154  data[k++] = 0.0;
1155  data[k++] = (angle)/(2.0*M_PI);
1156  data[k++] = teapot_data[j][4];
1157  }
1158  else {
1159  for(j = 1; j < 25; ++j) {
1160  data[k++] = teapot_data[j][0]*cos(angle);
1161  data[k++] = teapot_data[j][1];
1162  data[k++] = teapot_data[j][0]*sin(angle);
1163  data[k++] = teapot_data[j][2]*cos(angle);
1164  data[k++] = teapot_data[j][3];
1165  data[k++] = teapot_data[j][2]*sin(angle);
1166  data[k++] = (angle)/(2.0*M_PI);
1167  data[k++] = teapot_data[j][4];
1168 
1169  data[k++] = teapot_data[j][0]*cos(angle+theta);
1170  data[k++] = teapot_data[j][1];
1171  data[k++] = teapot_data[j][0]*sin(angle+theta);
1172  data[k++] = teapot_data[j][2]*cos(angle+theta);
1173  data[k++] = teapot_data[j][3];
1174  data[k++] = teapot_data[j][2]*sin(angle+theta);
1175  data[k++] = (angle+theta)/(2.0*M_PI);
1176  data[k++] = teapot_data[j][4];
1177  }
1178  data[k++] = teapot_data[25][0];
1179  data[k++] = teapot_data[25][1];
1180  data[k++] = 0.0;
1181  data[k++] = teapot_data[25][2];
1182  data[k++] = teapot_data[25][3];
1183  data[k++] = 0.0;
1184  data[k++] = (angle)/(2.0*M_PI);
1185  data[k++] = teapot_data[25][4];
1186  }
1187  }
1188  return data;
1189 }

Référencé par gl4dgGenTeapotf().

◆ mkTorusVerticesf()

static GLfloat * mkTorusVerticesf ( GLuint  slices,
GLuint  stacks,
GLfloat  radius 
)
static
937  {
938  int i, j, k;
939  GLdouble phi, theta, r, x, y, z;
940  GLfloat * data;
941  GLdouble c2MPI_Long = 2.0 * M_PI / slices;
942  GLdouble c2MPI_Lat = 2.0 * M_PI / stacks;
943  data = malloc(8 * (slices + 1) * (stacks + 1) * sizeof *data);
944  assert(data);
945  for(i = 0, k = 0; i <= (int)stacks; ++i) {
946  theta = i * c2MPI_Lat;
947  y = radius * sin(theta);
948  r = radius * cos(theta);
949  for(j = 0; j <= (int)slices; ++j) {
950  phi = j * c2MPI_Long;
951  x = cos(phi);
952  z = sin(phi);
953  data[k++] = (1 - radius + r) * x;
954  data[k++] = y;
955  data[k++] = (1 - radius + r) * z;
956  data[k + 0] = data[k - 3] - (1 - radius) * x;
957  data[k + 1] = data[k - 2] - (1 - radius) * y;
958  data[k + 2] = data[k - 1] - (1 - radius) * z;
959  MVEC3NORMALIZE(&data[k]); k += 3;
960  data[k++] = phi / (2.0 * M_PI);
961  data[k++] = theta / (2.0 * M_PI);
962  }
963  }
964  return data;
965 }

Références MVEC3NORMALIZE.

Référencé par gl4dgGenTorusf().

◆ triangleNormalf()

static void triangleNormalf ( GLfloat *  out,
GLfloat *  p0,
GLfloat *  p1,
GLfloat *  p2 
)
inlinestatic
1191  {
1192  GLfloat v0[3], v1[3];
1193  v0[0] = p1[0] - p0[0];
1194  v0[1] = p1[1] - p0[1];
1195  v0[2] = p1[2] - p0[2];
1196  v1[0] = p2[0] - p1[0];
1197  v1[1] = p2[1] - p1[1];
1198  v1[2] = p2[2] - p1[2];
1199  MVEC3CROSS(out, v0, v1);
1200  MVEC3NORMALIZE(out);
1201 }

Références MVEC3CROSS, et MVEC3NORMALIZE.

Référencé par mkGrid2dNormalsf().

Documentation des variables

◆ _garray

geom_t* _garray = NULL
static

Référencé par genId(), gl4dgClean(), gl4dgDelete(), gl4dgDraw(), gl4dgGenConef(), gl4dgGenCylinderf(), gl4dgGenDiskf(), gl4dgGenFanConef(), gl4dgGenGrid2dFromHeightMapf(), gl4dgGenSpheref(), gl4dgGenTeapotf(), gl4dgGenTorusf(), gl4dgGetVAO(), gl4dgInit(), et mkStaticf().

◆ _garray_size

GLint _garray_size = 256
static

Référencé par genId(), gl4dgClean(), et gl4dgInit().

◆ _geometry_optimization_level

GLuint _geometry_optimization_level = 1
static

Référencé par gl4dgSetGeometryOptimizationLevel().

◆ _glist

linked_list_t* _glist = NULL
static

Référencé par genId(), gl4dgClean(), gl4dgDelete(), et gl4dgInit().

◆ _hasInit

int _hasInit = 0
static

Référencé par gl4dgClean(), et gl4dgInit().

GL4DM_PI_2
#define GL4DM_PI_2
Definition: gl4dm.h:29
geom_t
Definition: gl4dg.c:90
llEmpty
int llEmpty(linked_list_t *ll)
Definition: linked_list.c:44
gstatic_t
Definition: gl4dg.c:104
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
gstatic_t::buffer
GLuint buffer
Definition: gl4dg.c:105
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
fcvNormals
static void fcvNormals(GLfloat *p, GLfloat y, int i)
Definition: gl4dg.c:818
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
SIGN
#define SIGN(i)
Definition: gl4dm.h:59
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
fcvbNormals
static void fcvbNormals(GLfloat *p, GLfloat y, int i)
Definition: gl4dg.c:825
GE_CONE
@ GE_CONE
Definition: gl4dg.c:81
gtorus_t::buffers
GLuint buffers[2]
Definition: gl4dg.c:126
mkGrid2dNormalsf
static void mkGrid2dNormalsf(GLuint width, GLuint height, GLfloat *data)
Definition: gl4dg.c:999
_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
DISK_FAN
#define DISK_FAN(d, i, ym, ye, slices, normals)
Macro servant à remplir des FANs, soit en disk soit en cone. d est data, i est indice à partir duquel...
Definition: gl4dg.c:836
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
triangleNormalf
static void triangleNormalf(GLfloat *out, GLfloat *p0, GLfloat *p1, GLfloat *p2)
Definition: gl4dg.c:1191
gdisk_t
Definition: gl4dg.c:120
_maxi
static int _maxi(int a, int b)
Definition: gl4dg.c:1203
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
GE_NONE
@ GE_NONE
Definition: gl4dg.c:77
llPop
void * llPop(linked_list_t *ll)
Definition: linked_list.c:38
llNew
linked_list_t * llNew(void)
Definition: linked_list.c:12
_mini
static int _mini(int a, int b)
Definition: gl4dg.c:1207
MVEC3CROSS
#define MVEC3CROSS(r, u, v)
Produit vectoriel 3D entre u et v écrit dans r.
Definition: gl4dm.h:226
_glist
static linked_list_t * _glist
Definition: gl4dg.c:149
gtorus_t::radius
GLdouble radius
Definition: gl4dg.c:128
MVEC3NORMALIZE
#define MVEC3NORMALIZE(v)
Normalise le vecteur 3D v.
Definition: gl4dm.h:260
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
GL4D_VAO_INDEX
#define GL4D_VAO_INDEX
Definition: gl4dummies.h:133
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