Référence du fichier gl4du.h

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

#include "gl4dummies.h"
#include "gl4dm.h"
#include "gl4dg.h"

Graphe des dépendances par inclusion de gl4du.h:

Ce graphe montre quels fichiers incluent directement ou indirectement ce fichier :

Aller au code source de ce fichier.

Définitions de type
typedef enum GL4DUenum	GL4DUenum

Énumérations
enum	GL4DUenum {   GL4DU_VERTEX_SHADER = 1, GL4DU_FRAGMENT_SHADER = 2, GL4DU_GEOMETRY_SHADER = 4, GL4DU_MATRIX = 1024,   GL4DU_MATRIX_TYPE = 1025, GL4DU_SHADER = ((unsigned long long)1) << 32, GL4DU_PROGRAM = ((unsigned long long)1) << 33, GL4DU_MATRICES = ((unsigned long long)1) << 34,   GL4DU_GEOMETRY = ((unsigned long long)1) << 35, GL4DU_DEMO_HELPER = ((unsigned long long)1) << 36, GL4DU_AT_EXIT = ((unsigned long long)1) << 36, GL4DU_ALL = (unsigned long long)0xffffffffffffffffLL }

Fonctions
GL4DAPI void GL4DAPIENTRY	gl4duInit (int argc, char **argv)
	Initialise la bibliothèque. Plus de détails...
GL4DAPI int GL4DAPIENTRY	gl4duHasInit (void)
	indique si la bibliothèque a été initialisée Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duMakeBinRelativePath (char *dst, size_t dst_size, const char *filename)
	Ajoute _pathOfMe au chemin filename passé en argument et stocke l'ensemble dans dst. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duPrintShaderInfoLog (GLuint object, FILE *f)
	imprime s'il existe l'infoLog de la compilation du Shader object dans fp. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duPrintProgramInfoLog (GLuint object, FILE *f)
	imprime s'il existe l'infoLog de l'édition de liens pour le Program object dans fp. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duPrintFPS (FILE *fp)
	imprime dans le fichier pointé par fp le Frame-Per-Second. Plus de détails...
GL4DAPI GLuint GL4DAPIENTRY	gl4duCreateShader (GLenum shadertype, const char *filename)
	retourne l'identifiant du shader décrit dans filename. Plus de détails...
GL4DAPI GLuint GL4DAPIENTRY	gl4duCreateShaderIM (GLenum shadertype, const char *filename, const char *shadercode)
	retourne l'identifiant du shader dont le code source est shadercode et le nom de fichier est filename ; le nom de fichier est fictif et sert seulement d'identifiant. Plus de détails...
GL4DAPI GLuint GL4DAPIENTRY	gl4duCreateShaderFED (const char *decData, GLenum shadertype, const char *filename)
	retourne l'identifiant du shader décrit dans filename. Version FED de la précédente Plus de détails...
GL4DAPI GLuint GL4DAPIENTRY	gl4duFindShader (const char *filename)
	retourne l'identifiant du shader décrit dans filename. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duDeleteShader (GLuint id)
	supprime le shader dont l'identifiant openGL est id de la liste de shaders shaders_list. Plus de détails...
GL4DAPI GLuint GL4DAPIENTRY	gl4duCreateProgram (const char *firstone,...)
	créé un program à partir d'une liste (variable) de nom de fichiers shaders et renvoie l'identifiant openGL du program créé. Plus de détails...
GL4DAPI GLuint GL4DAPIENTRY	gl4duCreateProgramFED (const char *encData, const char *firstone,...)
	créé un program à partir d'une liste (variable) de nom de fichiers shaders encapsulés dans un fichier crypté préalablement décrypté en ram et renvoie l'identifiant openGL du program créé. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duDeleteProgram (GLuint id)
	supprime le program dont l'identifiant openGL est id de la liste de programs programs_list. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duCleanUnattached (GL4DUenum what)
	supprime programs et/ou shaders non liés. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duAtExit (void(*func)(void))
	ajoute func dans la liste des fonctions à appeler lors du gl4duClean avec l'argument GL4DU_AT_EXIT ou GL4DU_ALL. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duClean (GL4DUenum what)
	supprime tous les programs et/ou tous les shaders. Plus de détails...
GL4DAPI int GL4DAPIENTRY	gl4duUpdateShaders (void)
	parcours la liste des shaders shaders_list et vérifie s'il y a besoin de mettre à jour le shader (recompiler et relinker). Plus de détails...
GL4DAPI GLboolean GL4DAPIENTRY	gl4duGenMatrix (GLenum type, const char *name)
	génère et gère une matrice (pile de "une matrice 4x4") liée au nom name et de type type. Plus de détails...
GL4DAPI GLboolean GL4DAPIENTRY	gl4duIsMatrix (const char *name)
	indique s'il existe une matrice est liée au nom name passé en argument. Plus de détails...
GL4DAPI GLboolean GL4DAPIENTRY	gl4duBindMatrix (const char *name)
	active (met en current) la matrice liée au nom name passé en argument. Plus de détails...
GL4DAPI GLboolean GL4DAPIENTRY	gl4duDeleteMatrix (const char *name)
	supprime la matrice liée au nom name passé en argument. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duPushMatrix (void)
	empile (sauvegarde) la matrice courante et utilise une nouvelle matrice dont le contenu est le meme que celle empilée. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duPopMatrix (void)
	dépile la matrice courante en restaurant l'état précédemment sauvegardé à l'aide de gl4duPushMatrix. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duSendMatrix (void)
	envoie la matrice courante au program shader en cours et en utilisant le nom de la matrice pour obtenir le uniform location. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duSendMatrices (void)
	envoie toutes matrices au program shader en cours et en utilisant leurs noms pour obtenir le uniform location. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duFrustumf (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
	Création d'une matrice de projection perspective selon l'ancienne fonction glFrustum et la multiplie dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duFrustumd (GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f)
	Création d'une matrice de projection perspective selon l'ancienne fonction glFrustum et la multiplie dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duOrthof (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
	Création d'une matrice de projection orthogonale selon l'ancienne fonction glOrtho et la multiplie dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duOrthod (GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f)
	Création d'une matrice de projection orthogonale selon l'ancienne fonction glOrtho et la multiplie dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duPerspectivef (GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)
	Création d'une matrice de projection perspective selon l'ancienne fonction gluPerspective et la multiplie dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duPerspectived (GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)
	Création d'une matrice de projection perspective selon l'ancienne fonction gluPerspective et la multiplie dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duLoadIdentityf (void)
	Chargement d'une matrice identité dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duLoadIdentityd (void)
	Chargement d'une matrice identité dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duLoadMatrixf (const GLfloat *matrix)
	Chargement d'une matrice matrix dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duLoadMatrixd (const GLdouble *matrix)
	Chargement d'une matrice matrix dans la matrice en cours. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duMultMatrixf (const GLfloat *matrix)
	Multiplication de la matrice en cours par une matrice matrix. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duMultMatrixd (const GLdouble *matrix)
	Multiplication de la matrice en cours par une matrice matrix. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duMultMatrixByName (const char *name)
	Multiplication de la matrice en cours par une des matrices connues dans GL4Dummies. Cette fonction utilise le nom de la matrice name afin de la récupérer et réaliser la multiplication à droite, le tout dans la matrice courante : currentMatrix = currentMatrix x matrixBy(name) Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
	Multiplication de la matrice en cours par une matrice de rotation définie par un angle angle donné en degrés autour de l'axe (x, y, z). Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
	Multiplication de la matrice en cours par une matrice de rotation définie par un angle angle donné en degrés autour de l'axe (x, y, z). Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duTranslatef (GLfloat tx, GLfloat ty, GLfloat tz)
	Multiplication de la matrice en cours par une matrice de translation (tx, ty, tz). Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duTranslated (GLdouble tx, GLdouble ty, GLdouble tz)
	Multiplication de la matrice en cours par une matrice de translation (tx, ty, tz). Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duScalef (GLfloat sx, GLfloat sy, GLfloat sz)
	Multiplication de la matrice en cours par une matrice d'homothétie (sx, sy, sz). Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duScaled (GLdouble sx, GLdouble sy, GLdouble sz)
	Multiplication de la matrice en cours par une matrice d'homothétie (sx, sy, sz). Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duLookAtf (GLfloat eyeX, GLfloat eyeY, GLfloat eyeZ, GLfloat centerX, GLfloat centerY, GLfloat centerZ, GLfloat upX, GLfloat upY, GLfloat upZ)
	Définie des transformations pour simuler un point de vue avec direction de regard et orientation. Plus de détails...
GL4DAPI void GL4DAPIENTRY	gl4duLookAtd (GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, GLdouble centerX, GLdouble centerY, GLdouble centerZ, GLdouble upX, GLdouble upY, GLdouble upZ)
	Définie des transformations pour simuler un point de vue avec direction de regard et orientation. Plus de détails...
GL4DAPI void *GL4DAPIENTRY	gl4duGetMatrixData (void)
	retourne le pointeur vers les données de la matrice (pile de "une matrice 4x4") courante. Plus de détails...
GL4DAPI GLboolean GL4DAPIENTRY	gl4duGetIntegerv (GL4DUenum pname, GLint *params)
	Renseigne sur la valeur du paramètre demandé. Le paramètre est envoyé via pname et sera stocké dans params. Plus de détails...

Description détaillée

The GL4Dummies Utilities.

Auteur

Fares BELHADJ amsi@.nosp@m.graf.nosp@m.eet.f.nosp@m.r (ou amsi@.nosp@m.ai.u.nosp@m.niv-p.nosp@m.aris.nosp@m.8.fr)

Date

March 28, 2008

Définition dans le fichier gl4du.h.

Documentation des définitions de type

GL4DUenum

typedef enum GL4DUenum GL4DUenum

Documentation du type de l'énumération

GL4DUenum

enum GL4DUenum

Valeurs énumérées
GL4DU_VERTEX_SHADER
GL4DU_FRAGMENT_SHADER
GL4DU_GEOMETRY_SHADER
GL4DU_MATRIX
GL4DU_MATRIX_TYPE
GL4DU_SHADER
GL4DU_PROGRAM
GL4DU_MATRICES
GL4DU_GEOMETRY
GL4DU_DEMO_HELPER
GL4DU_AT_EXIT
GL4DU_ALL

                 {
    GL4DU_VERTEX_SHADER   = 1,
    GL4DU_FRAGMENT_SHADER = 2,
    GL4DU_GEOMETRY_SHADER = 4,
    GL4DU_MATRIX          = 1024, /* les data de la matrice */
    GL4DU_MATRIX_TYPE     = 1025,
#if defined(_MSC_VER) /* ENUM n'est que 32bits sous MSC !!! */
    GL4DU_SHADER          = 1 << 20,
    GL4DU_PROGRAM         = 1 << 21,
    GL4DU_MATRICES        = 1 << 22,
    GL4DU_GEOMETRY        = 1 << 23,
    GL4DU_DEMO_HELPER     = 1 << 24,
    GL4DU_AT_EXIT         = 1 << 25,
    GL4DU_ALL             = 0xffffffff
#else
    GL4DU_SHADER          = ((unsigned long long)1) << 32,
    GL4DU_PROGRAM         = ((unsigned long long)1) << 33,
    GL4DU_MATRICES        = ((unsigned long long)1) << 34,
    GL4DU_GEOMETRY        = ((unsigned long long)1) << 35,
    GL4DU_DEMO_HELPER     = ((unsigned long long)1) << 36,
    GL4DU_AT_EXIT         = ((unsigned long long)1) << 36,
    GL4DU_ALL             = (unsigned long long)0xffffffffffffffffLL
#endif
  };

Documentation des fonctions

gl4duAtExit()

GL4DAPI void GL4DAPIENTRY gl4duAtExit

(

void(*)(void)

func

)

ajoute func dans la liste des fonctions à appeler lors du gl4duClean avec l'argument GL4DU_AT_EXIT ou GL4DU_ALL.

Paramètres

func	la fonction à ajouter dans la liste.

                                     {
  if(_aelist == NULL) {
    _aelist = llNew();
  }
  llPush(_aelist, func);
}

Références _aelist, llNew(), et llPush().

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

gl4duBindMatrix()

GL4DAPI GLboolean GL4DAPIENTRY gl4duBindMatrix

(

const char *

name

)

active (met en current) la matrice liée au nom name passé en argument.

Si la matrice existe l'active et renvoie GL_TRUE, sinon renvoie GL_FALSE. Si le paramètre name est NULL, désactive toute matrice et renvoie GL_TRUE.

Paramètres

name	le nom de la matrice à rechercher pour activer. Si NULL désactive (dé-bind) tout.

Renvoie

GL_TRUE si la matrice existe (et elle est préalablement activée), GL_FALSE sinon. Si le paramètre name est NULL, désactive toute matrice et renvoie GL_TRUE.

                                             {
  bin_tree_t ** bt;
  if(!name) {
    _gl4dCurMatrix = NULL;
    return GL_TRUE;
  }
  bt = findMatrix(name);
  if(bt) {
    _gl4dCurMatrix = (_GL4DUMatrix *)((*bt)->data);
    return GL_TRUE;
  }
  return GL_FALSE;
}

Références _gl4dCurMatrix, et findMatrix().

gl4duClean()

GL4DAPI void GL4DAPIENTRY gl4duClean

(

GL4DUenum

what

)

supprime tous les programs et/ou tous les shaders.

                                {
  if(what & GL4DU_AT_EXIT) {
    if(_aelist) {
      while(!llEmpty(_aelist))
        ((void (*)(void))llPop(_aelist))();
      llFree(_aelist, NULL);
      _aelist = NULL;
    }
  }
  if(what & GL4DU_PROGRAM) {
    program_t ** ptr = &programs_list;
    while(*ptr)
      deleteFromProgramsList(ptr);
  }
  if(what & GL4DU_SHADER) {
    shader_t ** ptr = &shaders_list;
    while(*ptr)
      deleteFromShadersList(ptr);
  }
  if(what & GL4DU_MATRICES)
    btFree(&_gl4duMatrices, freeGL4DUMatrix);
  if(what & GL4DU_GEOMETRY)
    gl4dgClean();
#ifndef __GLES4D__
  if(what & GL4DU_DEMO_HELPER)
    gl4dhClean();
#endif
  _hasInit = 0;
}

Références _aelist, _gl4duMatrices, _hasInit, btFree(), deleteFromProgramsList(), deleteFromShadersList(), freeGL4DUMatrix(), gl4dgClean(), gl4dhClean(), GL4DU_AT_EXIT, GL4DU_DEMO_HELPER, GL4DU_GEOMETRY, GL4DU_MATRICES, GL4DU_PROGRAM, GL4DU_SHADER, llEmpty(), llFree(), llPop(), programs_list, et shaders_list.

gl4duCleanUnattached()

GL4DAPI void GL4DAPIENTRY gl4duCleanUnattached

(

GL4DUenum

what

)

supprime programs et/ou shaders non liés.

                                          {
  if(what & GL4DU_PROGRAM) {
    program_t ** ptr = &programs_list;
    while(*ptr) {
      if((*ptr)->nshaders <= 0) /* ne devrait pas être négatif */
    deleteFromProgramsList(ptr);
      else
    ptr = &((*ptr)->next);
    }
  }
  if(what & GL4DU_SHADER) {
    shader_t ** ptr = &shaders_list;
    while(*ptr) {
      if((*ptr)->nprograms <= 0) /* ne devrait pas être négatif */
    deleteFromShadersList(ptr);
      else
    ptr = &((*ptr)->next);
    }
  }
}

Références deleteFromProgramsList(), deleteFromShadersList(), GL4DU_PROGRAM, GL4DU_SHADER, programs_list, et shaders_list.

gl4duCreateProgram()

GL4DAPI GLuint GL4DAPIENTRY gl4duCreateProgram	(	const char *	firstone,
			...
	)

créé un program à partir d'une liste (variable) de nom de fichiers shaders et renvoie l'identifiant openGL du program créé.

Les arguments sont les noms des fichiers shaders précédés d'un tag indiquant le type de shader : <vs> pour un vertex shader, <tcs> pour un tessellation control shader, <tes> pour un tessellation evaluation shader, <gs> pour un geometry shader, <fs> pour un fragment shader et <cs> pour un compute shader.

Sur le même principe, au lieu d'avoir le tag suivi du nom de fichier shader correspondant, utiliser le tag ouvrant <im*> et fermant </im*> pour inclure directement le code du shader dans la chaîne en mémoire (im => in memory). Ce qui donne par exemple pour le vertex shader : "<imvs> ... le code du vertex shader ... </imvs>".

Renvoie

l'identifiant openGL du program créé sinon 0. Dans ce dernier cas les shaders créés (compilés) avant l'échec ne sont pas supprimés ; un appel à gl4duCleanUnattached peut s'en charger.

                                                      {
  va_list  pa;
  const char * filename;
  program_t ** prg;
  GLuint sId, pId = glCreateProgram();
  char fn[BUFSIZ], format[BUFSIZ];
  if(!pId) return pId;
  prg = addInProgramsList(pId);
 
  filename = firstone;
  va_start(pa, firstone);
  fprintf(stderr, "%s (%d): Creation du programme %d a l'aide des Shaders :\n", __FILE__, __LINE__, pId);
  do {
    if(!strncmp("<vs>", filename, 4)) { /* vertex shader */
      fprintf(stderr, "%s : vertex shader\n", &filename[4]);
      if(!(sId = gl4duCreateShader(GL_VERTEX_SHADER, &filename[4]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<imvs>", filename, 6)) { /* in memory vertex shader */
      fn[0] = 0;
      snprintf(format, sizeof format, "<imvs>%%%d[^\t\n<>$!:;,=\"|]</imvs>", BUFSIZ - 1);
      if(sscanf(filename, format, fn) != 1 || strncmp("</imvs>", &filename[6 + strlen(fn)], 7)) {
    fprintf(stderr, "%s (%d): %s: erreur lors du parsing de %s\n",
        __FILE__, __LINE__, __func__, filename);
    continue;
      }
      fprintf(stderr, "%s : vertex shader\n", fn);
      if(!(sId = gl4duCreateShaderIM(GL_VERTEX_SHADER, fn, &filename[13 + strlen(fn)]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<fs>", filename, 4)) { /* fragment shader */
      fprintf(stderr, "%s : fragment shader\n", &filename[4]);
      if(!(sId = gl4duCreateShader(GL_FRAGMENT_SHADER, &filename[4]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<imfs>", filename, 6)) { /* in memory fragment shader */
      fn[0] = 0;
      snprintf(format, sizeof format, "<imfs>%%%d[^\t\n<>$!:;,=\"|]</imfs>", BUFSIZ - 1);
      if(sscanf(filename, format, fn) != 1 || strncmp("</imfs>", &filename[6 + strlen(fn)], 7)) {
    fprintf(stderr, "%s (%d): %s: erreur lors du parsing de %s\n",
        __FILE__, __LINE__, __func__, filename);
    continue;
      }
      fprintf(stderr, "%s : fragment shader\n", fn);
      if(!(sId = gl4duCreateShaderIM(GL_FRAGMENT_SHADER, fn, &filename[13 + strlen(fn)]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    }
#ifndef __ANDROID__
    else if(!strncmp("<cs>", filename, 4)) { /* compute shader */
      fprintf(stderr, "%s : compute shader\n", &filename[4]);
      if(!(sId = gl4duCreateShader(GL_COMPUTE_SHADER, &filename[4]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<imcs>", filename, 6)) { /* in memory compute shader */
      fn[0] = 0;
      snprintf(format, sizeof format, "<imcs>%%%d[^\t\n<>$!:;,=\"|]</imcs>", BUFSIZ - 1);
      if(sscanf(filename, format, fn) != 1 || strncmp("</imcs>", &filename[6 + strlen(fn)], 7)) {
    fprintf(stderr, "%s (%d): %s: erreur lors du parsing de %s\n",
        __FILE__, __LINE__, __func__, filename);
    continue;
      }
      fprintf(stderr, "%s : compute shader\n", fn);
      if(!(sId = gl4duCreateShaderIM(GL_COMPUTE_SHADER, fn, &filename[13 + strlen(fn)]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<gs>", filename, 4)) { /* geometry shader */
      fprintf(stderr, "%s : geometry shader\n", &filename[4]);
      if(!(sId = gl4duCreateShader(GL_GEOMETRY_SHADER, &filename[4]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<imgs>", filename, 6)) { /* in memory geometry shader */
      fn[0] = 0;
      snprintf(format, sizeof format, "<imgs>%%%d[^\t\n<>$!:;,=\"|]</imgs>", BUFSIZ - 1);
      if(sscanf(filename, format, fn) != 1 || strncmp("</imgs>", &filename[6 + strlen(fn)], 7)) {
    fprintf(stderr, "%s (%d): %s: erreur lors du parsing de %s\n",
        __FILE__, __LINE__, __func__, filename);
    continue;
      }
      fprintf(stderr, "%s : geometry shader\n", fn);
      if(!(sId = gl4duCreateShaderIM(GL_GEOMETRY_SHADER, fn, &filename[13 + strlen(fn)]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<tcs>", filename, 5)) { /* tessellation control shader */
      fprintf(stderr, "%s : tessellation control shader\n", &filename[5]);
      if(!(sId = gl4duCreateShader(GL_TESS_CONTROL_SHADER, &filename[5]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<imtcs>", filename, 7)) { /* in memory tessellation control shader */
      fn[0] = 0;
      snprintf(format, sizeof format, "<imtcs>%%%d[^\t\n<>$!:;,=\"|]</imtcs>", BUFSIZ - 1);
      if(sscanf(filename, format, fn) != 1 || strncmp("</imtcs>", &filename[7 + strlen(fn)], 8)) {
    fprintf(stderr, "%s (%d): %s: erreur lors du parsing de %s\n",
        __FILE__, __LINE__, __func__, filename);
    continue;
      }
      fprintf(stderr, "%s : tessellation control shader\n", fn);
      if(!(sId = gl4duCreateShaderIM(GL_TESS_CONTROL_SHADER, fn, &filename[15 + strlen(fn)]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<tes>", filename, 5)) { /* tessellation evaluation shader */
      fprintf(stderr, "%s : tessellation evaluation shader\n", &filename[5]);
      if(!(sId = gl4duCreateShader(GL_TESS_EVALUATION_SHADER, &filename[5]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<imtes>", filename, 7)) { /* in memory tessellation evaluation shader */
      fn[0] = 0;
      snprintf(format, sizeof format, "<imtes>%%%d[^\t\n<>$!:;,=\"|]</imtes>", BUFSIZ - 1);
      if(sscanf(filename, format, fn) != 1 || strncmp("</imtes>", &filename[7 + strlen(fn)], 8)) {
    fprintf(stderr, "%s (%d): %s: erreur lors du parsing de %s\n",
        __FILE__, __LINE__, __func__, filename);
    continue;
      }
      fprintf(stderr, "%s : tessellation evaluation shader\n", fn);
      if(!(sId = gl4duCreateShaderIM(GL_TESS_EVALUATION_SHADER, fn, &filename[15 + strlen(fn)]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    }
#endif
    else { /* ??? shader */
      fprintf(stderr, "%s (%d): %s: erreur de syntaxe dans \"%s\"\n",
          __FILE__, __LINE__, __func__, filename);
    }
  } while((filename = va_arg(pa, const char *)) != NULL);
  va_end(pa);
  glLinkProgram(pId);
  gl4duPrintProgramInfoLog(pId, stderr);
  return pId;
 gl4duCreateProgram_ERROR:
  va_end(pa);
  deleteFromProgramsList(prg);
  return 0;
}

Références addInProgramsList(), attachShader(), deleteFromProgramsList(), findidInShadersList(), gl4duCreateShader(), gl4duCreateShaderIM(), et gl4duPrintProgramInfoLog().

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

gl4duCreateProgramFED()

GL4DAPI GLuint GL4DAPIENTRY gl4duCreateProgramFED	(	const char *	encData,
		const char *	firstone,
			...
	)

créé un program à partir d'une liste (variable) de nom de fichiers shaders encapsulés dans un fichier crypté préalablement décrypté en ram et renvoie l'identifiant openGL du program créé.

Paramètres

encData

fichier contenant un ensemble de shaders cryptés.

firstone

premier des n paramètres de la présente fonction à arguments variables ; ces arguments donnent les noms de fichiers contenus dans l'archive cryptée endCata. Ces noms de fichiers shaders sont précédés d'un tag indiquant le type de shader : <vs> pour un vertex shader, <tcs> pour un tessellation control shader, <tes> pour un tessellation evaluation shader, <gs> pour un geometry shader, <fs> pour un fragment shader et <cs> pour un compute shader.

Renvoie

l'identifiant openGL du program créé sinon 0. Dans ce dernier cas les shaders créés (compilés) avant l'échec ne sont pas supprimés ; un appel à gl4duCleanUnattached peut s'en charger.

                                                                               {
  static const char * prevEncData = NULL;
  static char * decData = NULL;
  va_list  pa;
  const char * filename;
  program_t ** prg;
  GLuint sId, pId = glCreateProgram();
  if(!pId) return pId;
  if(prevEncData != encData) {
    if(decData)
      free(decData);
    decData = aes_from_tar(prevEncData = encData);
  }
  prg = addInProgramsList(pId);
 
  filename = firstone;
  va_start(pa, firstone);
  fprintf(stderr, "%s (%d): Creation du programme %d a l'aide des Shaders :\n", __FILE__, __LINE__, pId);
  do {
    if(!strncmp("<vs>", filename, 4)) { /* vertex shader */
      fprintf(stderr, "%s : vertex shader\n", &filename[4]);
      if(!(sId = gl4duCreateShaderFED(decData, GL_VERTEX_SHADER, &filename[4]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<fs>", filename, 4)) { /* fragment shader */
      fprintf(stderr, "%s : fragment shader\n", &filename[4]);
      if(!(sId = gl4duCreateShaderFED(decData, GL_FRAGMENT_SHADER, &filename[4]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    }
#ifndef __ANDROID__
    else if(!strncmp("<cs>", filename, 4)) { /* compute shader */
      fprintf(stderr, "%s : compute shader\n", &filename[4]);
      if(!(sId = gl4duCreateShaderFED(decData, GL_COMPUTE_SHADER, &filename[4]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<gs>", filename, 4)) { /* geometry shader */
      fprintf(stderr, "%s : geometry shader\n", &filename[4]);
      if(!(sId = gl4duCreateShaderFED(decData, GL_GEOMETRY_SHADER, &filename[4]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<tcs>", filename, 5)) { /* tessellation control shader */
      fprintf(stderr, "%s : tessellation control shader\n", &filename[5]);
      if(!(sId = gl4duCreateShaderFED(decData, GL_TESS_CONTROL_SHADER, &filename[5]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    } else if(!strncmp("<tes>", filename, 5)) { /* tessellation evaluation shader */
      fprintf(stderr, "%s : tessellation evaluation shader\n", &filename[5]);
      if(!(sId = gl4duCreateShaderFED(decData, GL_TESS_EVALUATION_SHADER, &filename[5]))) goto gl4duCreateProgram_ERROR;
      attachShader(*prg, *findidInShadersList(sId));
    }
#endif
    else { /* ??? shader */
      fprintf(stderr, "%s (%d): %s: erreur de syntaxe dans \"%s\"\n",
          __FILE__, __LINE__, __func__, filename);
    }
  } while((filename = va_arg(pa, const char *)) != NULL);
  va_end(pa);
  glLinkProgram(pId);
  gl4duPrintProgramInfoLog(pId, stderr);
  return pId;
 gl4duCreateProgram_ERROR:
  va_end(pa);
  deleteFromProgramsList(prg);
  return 0;
}

Références addInProgramsList(), aes_from_tar(), attachShader(), deleteFromProgramsList(), findidInShadersList(), gl4duCreateShaderFED(), et gl4duPrintProgramInfoLog().

gl4duCreateShader()

GL4DAPI GLuint GL4DAPIENTRY gl4duCreateShader	(	GLenum	shadertype,
		const char *	filename
	)

retourne l'identifiant du shader décrit dans filename.

Soit le shader existe déjà et l'identifiant est juste retourné avec findfnInShadersList, soit il est créer en utilisant gl4duCreateShader, glShaderSource et glCompileShader. Il se peut que le shader soit mis à jour si la date de modification du fichier est differente de celle stoquée dans shaders_list. Dans ce cas le shader est détruit puis recréé et la modification doit être répercuté sur tous les PROGRAMs liés.

Renvoie

l'identifiant du shader décrit dans filename.

                                                                   {
  char temp[BUFSIZ << 1];
  shader_t ** sh = findfnInShadersList(filename);
  if(*sh) return (*sh)->id;
  gl4duMakeBinRelativePath(temp, sizeof temp, filename);
  // la ligne précédente fait ça snprintf(temp, sizeof temp, "%s/%s", _pathOfMe, filename);
  sh = findfnInShadersList(temp);
  if(*sh) return (*sh)->id;
  sh = addInShadersList(shadertype, filename, NULL);
  if(!sh) {
    fprintf(stderr, "trying with another path (%s)\n", temp);
    sh = addInShadersList(shadertype, temp, NULL);
  }
  return (sh) ? (*sh)->id : 0;
}

Références addInShadersList(), findfnInShadersList(), et gl4duMakeBinRelativePath().

Référencé par gl4duCreateProgram().

gl4duCreateShaderFED()

GL4DAPI GLuint GL4DAPIENTRY gl4duCreateShaderFED	(	const char *	decData,
		GLenum	shadertype,
		const char *	filename
	)

retourne l'identifiant du shader décrit dans filename. Version FED de la précédente

A faire:

commenter

ajouter la gestion des chemins relatifs à l'emplacement du binaire comme pour gl4duCreateShader.

                                                                                            {
  shader_t ** sh = findfnInShadersList(filename);
  if(*sh) return (*sh)->id;
  sh = addInShadersListFED(decData, shadertype, filename);
  return (sh) ? (*sh)->id : 0;
}

Références addInShadersListFED(), findfnInShadersList(), et shader_t::id.

Référencé par gl4duCreateProgramFED().

gl4duCreateShaderIM()

GL4DAPI GLuint GL4DAPIENTRY gl4duCreateShaderIM	(	GLenum	shadertype,
		const char *	filename,
		const char *	shadercode
	)

retourne l'identifiant du shader dont le code source est shadercode et le nom de fichier est filename ; le nom de fichier est fictif et sert seulement d'identifiant.

Soit le shader existe déjà et l'identifiant est juste retourné avec findfnInShadersList, soit il est créer en utilisant gl4duCreateShader, glShaderSource et glCompileShader.

Renvoie

l'identifiant du shader correspondant au code source shadercode.

                                                                                              {
  shader_t ** sh = findfnInShadersList(filename);
  if(*sh) return (*sh)->id;
  sh = addInShadersList(shadertype, filename, shadercode);
  return (sh) ? (*sh)->id : 0;
}

Références addInShadersList(), findfnInShadersList(), et shader_t::id.

Référencé par gl4duCreateProgram().

gl4duDeleteMatrix()

GL4DAPI GLboolean GL4DAPIENTRY gl4duDeleteMatrix

(

const char *

name

)

supprime la matrice liée au nom name passé en argument.

Si la matrice existe la supprime et renvoie GL_TRUE, sinon renvoie GL_FALSE. Si la matrice supprimée est la meme que la matrice courante (active), la matrice courante passe à NULL.

Paramètres

name	le nom de la matrice à rechercher pour suppression.

Renvoie

GL_TRUE si la matrice existe et est supprimée, GL_FALSE sinon.

                                               {
  bin_tree_t ** bt = findMatrix(name);
  if(bt) {
    if(_gl4dCurMatrix == (_GL4DUMatrix *)((*bt)->data))
      _gl4dCurMatrix = NULL;
    btDelete(bt, freeGL4DUMatrix);
    if(_gl4dLastMatrixn == bt)
      _gl4dLastMatrixn = NULL;
    return GL_TRUE;
  }
  return GL_FALSE;
}

Références _gl4dCurMatrix, _gl4dLastMatrixn, btDelete(), findMatrix(), et freeGL4DUMatrix().

gl4duDeleteProgram()

GL4DAPI void GL4DAPIENTRY gl4duDeleteProgram

(

GLuint

id

)

supprime le program dont l'identifiant openGL est id de la liste de programs programs_list.

                                   {
  program_t ** prg = findInProgramsList(id);
  if(*prg) deleteFromProgramsList(prg);
}

Références deleteFromProgramsList(), et findInProgramsList().

gl4duDeleteShader()

GL4DAPI void GL4DAPIENTRY gl4duDeleteShader

(

GLuint

id

)

supprime le shader dont l'identifiant openGL est id de la liste de shaders shaders_list.

                                  {
  shader_t ** sh = findidInShadersList(id);
  if(*sh) {
    if((*sh)->nprograms > 0)
      (*sh)->todelete = 1;
    else
      deleteFromShadersList(sh);
  }
}

Références deleteFromShadersList(), et findidInShadersList().

gl4duFindShader()

GL4DAPI GLuint GL4DAPIENTRY gl4duFindShader

(

const char *

filename

)

retourne l'identifiant du shader décrit dans filename.

Soit le shader existe et l'identifiant est retourné soit la fonction retourne 0.

Renvoie

l'identifiant du shader décrit dans filename ou 0 s'il n'a pas été chargé.

                                              {
  shader_t ** sh = findfnInShadersList(filename);
  return (*sh) ? (*sh)->id : 0;
}

Références findfnInShadersList().

gl4duFrustumd()

GL4DAPI void GL4DAPIENTRY gl4duFrustumd	(	GLdouble	l,
		GLdouble	r,
		GLdouble	b,
		GLdouble	t,
		GLdouble	n,
		GLdouble	f
	)

Création d'une matrice de projection perspective selon l'ancienne fonction glFrustum et la multiplie dans la matrice en cours.

La matrice en cours doit être de type GLdouble sinon utiliser gl4duFrustumf si le type est GLfloat.

Voir également

gl4duFrustumf

                                                                                           {
  GLdouble frustum[16];
  MFRUSTUM(frustum, l, r, b, t, n, f);
  gl4duMultMatrixd(frustum);
}

Références gl4duMultMatrixd(), et MFRUSTUM.

gl4duFrustumf()

GL4DAPI void GL4DAPIENTRY gl4duFrustumf	(	GLfloat	l,
		GLfloat	r,
		GLfloat	b,
		GLfloat	t,
		GLfloat	n,
		GLfloat	f
	)

Création d'une matrice de projection perspective selon l'ancienne fonction glFrustum et la multiplie dans la matrice en cours.

La matrice en cours doit être de type GLfloat sinon utiliser gl4duFrustumd si le type est GLdouble.

Voir également

gl4duFrustumd

                                                                                           {
  GLfloat frustum[16];
  MFRUSTUM(frustum, l, r, b, t, n, f);
  gl4duMultMatrixf(frustum);
}

Références gl4duMultMatrixf(), et MFRUSTUM.

gl4duGenMatrix()

GL4DAPI GLboolean GL4DAPIENTRY gl4duGenMatrix	(	GLenum	type,
		const char *	name
	)

génère et gère une matrice (pile de "une matrice 4x4") liée au nom name et de type type.

Le type peut etre GL_FLOAT ou GL_DOUBLE.

Paramètres

type	le type de la matrice à créer : GL_FLOAT ou GL_DOUBLE.
name	le nom de la matrice à créer.

Renvoie

GL_TRUE si la création est réussie, GL_FALSE sinon (apriori si le nom existe déjà).

                                                         {
  _GL4DUMatrix m, * p;
  pair_t pair;
  m.name = (char *)name;
  pair = btFind(&_gl4duMatrices, &m, matrixCmpFunc);
  if(pair.compResult) {
    p = newGL4DUMatrix(type, name);
    _gl4dLastMatrixn = (bin_tree_t **)(btInsert((bin_tree_t **)(pair.ptr), p, matrixCmpFunc).ptr);
    return GL_TRUE;
  }
  return GL_FALSE;
}

Références _gl4dLastMatrixn, _gl4duMatrices, btFind(), btInsert(), pair_t::compResult, matrixCmpFunc(), _GL4DUMatrix::name, newGL4DUMatrix(), et pair_t::ptr.

gl4duGetIntegerv()

GL4DAPI GLboolean GL4DAPIENTRY gl4duGetIntegerv	(	GL4DUenum	pname,
		GLint *	params
	)

Renseigne sur la valeur du paramètre demandé. Le paramètre est envoyé via pname et sera stocké dans params.

Paramètres

pname	le paramètre demandé.
params	là où sera stockée la/les valeur(s) du paramètre demandé.

Renvoie

GL_TRUE si l'opération est réussie, GL_FALSE sinon (ex. le pname est non géré par cette fonction).

A faire:

compléter cette fonction et bien la documenter (tous les cas gérés).

A faire:

faire la meme mais pour les float, double ...

                                                            {
  switch(pname) {
  case GL4DU_MATRIX_TYPE:
    assert(_gl4dCurMatrix);
    *params = (GLint)_gl4dCurMatrix->type;
    return GL_TRUE;
  default:
    return GL_FALSE;
  }
  return GL_FALSE;
}

Références _gl4dCurMatrix, GL4DU_MATRIX_TYPE, et _GL4DUMatrix::type.

gl4duGetMatrixData()

GL4DAPI void* GL4DAPIENTRY gl4duGetMatrixData

(

void

)

retourne le pointeur vers les données de la matrice (pile de "une matrice 4x4") courante.

En pratique, prend la donnée en haut de la pile. Le type de retour est (void *), il faut le caster dans le type correspondant au type de la matrice.

Renvoie

retourne le pointeur vers les données de la matrice.

                                {
  assert(_gl4dCurMatrix);
  return matrixData(_gl4dCurMatrix);
}

Références _gl4dCurMatrix, et matrixData().

gl4duHasInit()

GL4DAPI int GL4DAPIENTRY gl4duHasInit

(

void

)

indique si la bibliothèque a été initialisée

                       {
  return _hasInit;
}

Références _hasInit.

gl4duInit()

GL4DAPI void GL4DAPIENTRY gl4duInit	(	int	argc,
		char **	argv
	)

Initialise la bibliothèque.

Récupère le chemin relatif à partir duquel le binaire a été exécuté et le stocke dans _pathOfMe.

Initialise gl4dg via gl4dgInit

Voir également

_pathOfMe

                                       {
  findPathOfMe(argc > 0 ? argv[0] : "");
  gl4dgInit();
  _hasInit = 1;
}

Références _hasInit, findPathOfMe(), et gl4dgInit().

Référencé par initGL4DUW().

gl4duIsMatrix()

GL4DAPI GLboolean GL4DAPIENTRY gl4duIsMatrix

(

const char *

name

)

indique s'il existe une matrice est liée au nom name passé en argument.

Paramètres

name	le nom de la matrice à rechercher.

Renvoie

GL_TRUE si la matrice existe, GL_FALSE sinon.

                                           {
  _GL4DUMatrix m;
  m.name = (char *)name;
  return !btFind(&_gl4duMatrices, &m, matrixCmpFunc).compResult;
}

Références _gl4duMatrices, btFind(), pair_t::compResult, matrixCmpFunc(), et _GL4DUMatrix::name.

gl4duLoadIdentityd()

GL4DAPI void GL4DAPIENTRY gl4duLoadIdentityd

(

void

)

Chargement d'une matrice identité dans la matrice en cours.

La matrice en cours doit être de type GLdouble sinon utiliser gl4duLoadIdentityf si le type est GLfloat.

Voir également

gl4duLoadIdentityf

                              {
  GLdouble * mat;
  assert(_gl4dCurMatrix);
  assert(_gl4dCurMatrix->type == GL_DOUBLE);
  mat = (GLdouble *)&(((GLubyte *)_gl4dCurMatrix->data)[_gl4dCurMatrix->top * _gl4dCurMatrix->size]);
  MIDENTITY(mat);
}

Références _gl4dCurMatrix, _GL4DUMatrix::data, MIDENTITY, _GL4DUMatrix::size, _GL4DUMatrix::top, et _GL4DUMatrix::type.

gl4duLoadIdentityf()

GL4DAPI void GL4DAPIENTRY gl4duLoadIdentityf

(

void

)

Chargement d'une matrice identité dans la matrice en cours.

La matrice en cours doit être de type GLfloat sinon utiliser gl4duLoadIdentityd si le type est GLdouble.

Voir également

gl4duLoadIdentityd

                              {
  GLfloat * mat;
  assert(_gl4dCurMatrix);
  assert(_gl4dCurMatrix->type == GL_FLOAT);
  mat = (GLfloat *)&(((GLubyte *)_gl4dCurMatrix->data)[_gl4dCurMatrix->top * _gl4dCurMatrix->size]);
  MIDENTITY(mat);
}

Références _gl4dCurMatrix, _GL4DUMatrix::data, MIDENTITY, _GL4DUMatrix::size, _GL4DUMatrix::top, et _GL4DUMatrix::type.

gl4duLoadMatrixd()

GL4DAPI void GL4DAPIENTRY gl4duLoadMatrixd

(

const GLdouble *

matrix

)

Chargement d'une matrice matrix dans la matrice en cours.

La matrice en cours doit être de type GLdouble sinon utiliser gl4duLoadMatrixf si le type est GLfloat.

Paramètres

matrix

la matrice 4x4 à charger.

Voir également

gl4duLoadMatrixf

                                               {
  assert(_gl4dCurMatrix);
  assert(_gl4dCurMatrix->type == GL_DOUBLE);
  memcpy(&(((GLubyte *)_gl4dCurMatrix->data)[_gl4dCurMatrix->top * _gl4dCurMatrix->size]), matrix, _gl4dCurMatrix->size);
}

Références _gl4dCurMatrix, _GL4DUMatrix::data, _GL4DUMatrix::size, _GL4DUMatrix::top, et _GL4DUMatrix::type.

gl4duLoadMatrixf()

GL4DAPI void GL4DAPIENTRY gl4duLoadMatrixf

(

const GLfloat *

matrix

)

Chargement d'une matrice matrix dans la matrice en cours.

La matrice en cours doit être de type GLfloat sinon utiliser gl4duLoadMatrixd si le type est GLdouble.

Paramètres

matrix

la matrice 4x4 à charger.

Voir également

gl4duLoadMatrixd

                                              {
  assert(_gl4dCurMatrix);
  assert(_gl4dCurMatrix->type == GL_FLOAT);
  memcpy(&(((GLubyte *)_gl4dCurMatrix->data)[_gl4dCurMatrix->top * _gl4dCurMatrix->size]), matrix, _gl4dCurMatrix->size);
}

Références _gl4dCurMatrix, _GL4DUMatrix::data, _GL4DUMatrix::size, _GL4DUMatrix::top, et _GL4DUMatrix::type.

gl4duLookAtd()

GL4DAPI void GL4DAPIENTRY gl4duLookAtd	(	GLdouble	eyeX,
		GLdouble	eyeY,
		GLdouble	eyeZ,
		GLdouble	centerX,
		GLdouble	centerY,
		GLdouble	centerZ,
		GLdouble	upX,
		GLdouble	upY,
		GLdouble	upZ
	)

Définie des transformations pour simuler un point de vue avec direction de regard et orientation.

Version GL4Dummies de la fonction gluLookAt pour les types GLdouble (les matrices GL_DOUBLE). Pour la version gérant les double voir

Voir également

gl4duLookAtf.

Paramètres

eyeX	abcsisse de l'oeil.
eyeY	ordonnée de l'oeil.
eyeZ	cote de l'oeil.
centerX	abcsisse du point observé.
centerY	ordonnée du point observé.
centerZ	cote du point observé.
upX	X du vecteur décrivant l'orientation de la "tete" de l'observateur (vecteur haut)
upY	Y du vecteur décrivant l'orientation de la "tete" de l'observateur (vecteur haut)
upZ	Y du vecteur décrivant l'orientation de la "tete" de l'observateur (vecteur haut)

                                                                                                                                                                       {
  GLdouble forward[3], side[3], up[3];
  GLdouble m[] = {
          1.0,       0.0,       0.0,       0.0,
          0.0,       1.0,       0.0,       0.0,
          0.0,       0.0,       1.0,       0.0,
          0.0,       0.0,       0.0,       1.0
  };
  forward[0] = centerX - eyeX;
  forward[1] = centerY - eyeY;
  forward[2] = centerZ - eyeZ;
  up[0] = upX;
  up[1] = upY;
  up[2] = upZ;
  MVEC3NORMALIZE(forward);
  /* side = forward x up */
  MVEC3CROSS(side, forward, up);
  MVEC3NORMALIZE(side);
  /* up = side x forward */
  MVEC3CROSS(up, side, forward);
  m[0] = side[0];
  m[1] = side[1];
  m[2] = side[2];
  m[4] = up[0];
  m[5] = up[1];
  m[6] = up[2];
  m[8] = -forward[0];
  m[9] = -forward[1];
  m[10] = -forward[2];
  gl4duMultMatrixd(m);
  gl4duTranslated(-eyeX, -eyeY, -eyeZ);
}

Références gl4duMultMatrixd(), gl4duTranslated(), MVEC3CROSS, et MVEC3NORMALIZE.

gl4duLookAtf()

GL4DAPI void GL4DAPIENTRY gl4duLookAtf	(	GLfloat	eyeX,
		GLfloat	eyeY,
		GLfloat	eyeZ,
		GLfloat	centerX,
		GLfloat	centerY,
		GLfloat	centerZ,
		GLfloat	upX,
		GLfloat	upY,
		GLfloat	upZ
	)

Définie des transformations pour simuler un point de vue avec direction de regard et orientation.

Version GL4Dummies de la fonction gluLookAt pour les types GLfloat (les matrices GL_FLOAT). Pour la version gérant les double voir

Voir également

gl4duLookAtd.

Paramètres

eyeX	abcsisse de l'oeil.
eyeY	ordonnée de l'oeil.
eyeZ	cote de l'oeil.
centerX	abcsisse du point observé.
centerY	ordonnée du point observé.
centerZ	cote du point observé.
upX	X du vecteur décrivant l'orientation de la "tete" de l'observateur (vecteur haut)
upY	Y du vecteur décrivant l'orientation de la "tete" de l'observateur (vecteur haut)
upZ	Y du vecteur décrivant l'orientation de la "tete" de l'observateur (vecteur haut)

                                                                                                                                                      {
  GLfloat forward[3], side[3], up[3];
  GLfloat m[] = {
        1.0f,       0.0f,       0.0f,       0.0f,
        0.0f,       1.0f,       0.0f,       0.0f,
        0.0f,       0.0f,       1.0f,       0.0f,
        0.0f,       0.0f,       0.0f,       1.0f
  };
  forward[0] = centerX - eyeX;
  forward[1] = centerY - eyeY;
  forward[2] = centerZ - eyeZ;
  up[0] = upX;
  up[1] = upY;
  up[2] = upZ;
  MVEC3NORMALIZE(forward);
  /* side = forward x up */
  MVEC3CROSS(side, forward, up);
  MVEC3NORMALIZE(side);
  /* up = side x forward */
  MVEC3CROSS(up, side, forward);
  m[0] = side[0];
  m[1] = side[1];
  m[2] = side[2];
  m[4] = up[0];
  m[5] = up[1];
  m[6] = up[2];
  m[8] = -forward[0];
  m[9] = -forward[1];
  m[10] = -forward[2];
  gl4duMultMatrixf(m);
  gl4duTranslatef(-eyeX, -eyeY, -eyeZ);
}

Références gl4duMultMatrixf(), gl4duTranslatef(), MVEC3CROSS, et MVEC3NORMALIZE.

gl4duMakeBinRelativePath()

GL4DAPI void GL4DAPIENTRY gl4duMakeBinRelativePath	(	char *	dst,
		size_t	dst_size,
		const char *	filename
	)

Ajoute _pathOfMe au chemin filename passé en argument et stocke l'ensemble dans dst.

Voir également

_pathOfMe

                                                                                  {
  snprintf(dst, dst_size, "%s/%s", _pathOfMe, filename);
  if(!_pathOfMeInit) fprintf(stderr, "Binary path unknown, you should call gl4duInit(argc, argv) at program init\n");
}

Références _pathOfMe, et _pathOfMeInit.

Référencé par gl4duCreateShader().

gl4duMultMatrixByName()

GL4DAPI void GL4DAPIENTRY gl4duMultMatrixByName

(

const char *

name

)

Multiplication de la matrice en cours par une des matrices connues dans GL4Dummies. Cette fonction utilise le nom de la matrice name afin de la récupérer et réaliser la multiplication à droite, le tout dans la matrice courante : currentMatrix = currentMatrix x matrixBy(name)

Paramètres

name	le nom de la matrice GL4Dummies à utiliser pour la multiplication (currentMatrix x matrixBy(name)).

                                              {
  bin_tree_t ** bt;
  assert(_gl4dCurMatrix);
  if(_gl4dCurMatrix->type == GL_FLOAT) {
    GLfloat cpy[16], *mat = (GLfloat *)&(((GLubyte *)_gl4dCurMatrix->data)[_gl4dCurMatrix->top * _gl4dCurMatrix->size]);
    memcpy(cpy, mat, _gl4dCurMatrix->size);
    if(name && (bt = findMatrix(name))) {
      _GL4DUMatrix * namedMatrix = (_GL4DUMatrix *)((*bt)->data);
      if(namedMatrix->type == GL_FLOAT) {
    GLfloat *matrix = (GLfloat *)&(((GLubyte *)namedMatrix->data)[namedMatrix->top * namedMatrix->size]);
    MMAT4XMAT4(mat, cpy, matrix);
      } else { /* GL_DOUBLE */
    GLdouble *matrix = (GLdouble *)&(((GLubyte *)namedMatrix->data)[namedMatrix->top * namedMatrix->size]);
    MMAT4XMAT4(mat, cpy, matrix);
      }
    }
  } else {
    GLdouble cpy[16], *mat = (GLdouble *)&(((GLubyte *)_gl4dCurMatrix->data)[_gl4dCurMatrix->top * _gl4dCurMatrix->size]);
    memcpy(cpy, mat, _gl4dCurMatrix->size);
    if(name && (bt = findMatrix(name))) {
      _GL4DUMatrix * namedMatrix = (_GL4DUMatrix *)((*bt)->data);
      if(namedMatrix->type == GL_FLOAT) {
    GLfloat *matrix = (GLfloat *)&(((GLubyte *)namedMatrix->data)[namedMatrix->top * namedMatrix->size]);
    MMAT4XMAT4(mat, cpy, matrix);
      } else { /* GL_DOUBLE */
    GLdouble *matrix = (GLdouble *)&(((GLubyte *)namedMatrix->data)[namedMatrix->top * namedMatrix->size]);
    MMAT4XMAT4(mat, cpy, matrix);
      }
    }
  }
}

Références _gl4dCurMatrix, _GL4DUMatrix::data, findMatrix(), MMAT4XMAT4, _GL4DUMatrix::size, _GL4DUMatrix::top, et _GL4DUMatrix::type.

gl4duMultMatrixd()

GL4DAPI void GL4DAPIENTRY gl4duMultMatrixd

(

const GLdouble *

matrix

)

Multiplication de la matrice en cours par une matrice matrix.

La matrice en cours doit être de type GLdouble sinon utiliser gl4duMultMatrixf si le type est GLfloat.

Paramètres

matrix

la matrice 4x4 utilisée pour la multiplication (curMatrix x matrix).

Voir également

gl4duMultMatrixf

                                               {
  GLdouble * mat, cpy[16];
  assert(_gl4dCurMatrix);
  assert(_gl4dCurMatrix->type == GL_DOUBLE);
  mat = (GLdouble *)&(((GLubyte *)_gl4dCurMatrix->data)[_gl4dCurMatrix->top * _gl4dCurMatrix->size]);
  memcpy(cpy, mat, _gl4dCurMatrix->size);
  MMAT4XMAT4(mat, cpy, matrix);
}

Références _gl4dCurMatrix, _GL4DUMatrix::data, MMAT4XMAT4, _GL4DUMatrix::size, _GL4DUMatrix::top, et _GL4DUMatrix::type.

Référencé par gl4duFrustumd(), gl4duLookAtd(), gl4duOrthod(), gl4duPerspectived(), gl4duRotated(), gl4duScaled(), et gl4duTranslated().

gl4duMultMatrixf()

GL4DAPI void GL4DAPIENTRY gl4duMultMatrixf

(

const GLfloat *

matrix

)

Multiplication de la matrice en cours par une matrice matrix.

La matrice en cours doit être de type GLfloat sinon utiliser gl4duMultMatrixd si le type est GLdouble.

Paramètres

matrix

la matrice 4x4 utilisée pour la multiplication (curMatrix x matrix).

Voir également

gl4duMultMatrixd

                                              {
  GLfloat * mat, cpy[16];
  assert(_gl4dCurMatrix);
  assert(_gl4dCurMatrix->type == GL_FLOAT);
  mat = (GLfloat *)&(((GLubyte *)_gl4dCurMatrix->data)[_gl4dCurMatrix->top * _gl4dCurMatrix->size]);
  memcpy(cpy, mat, _gl4dCurMatrix->size);
  MMAT4XMAT4(mat, cpy, matrix);
}

Références _gl4dCurMatrix, _GL4DUMatrix::data, MMAT4XMAT4, _GL4DUMatrix::size, _GL4DUMatrix::top, et _GL4DUMatrix::type.

Référencé par gl4duFrustumf(), gl4duLookAtf(), gl4duLookAtf_DNW(), gl4duOrthof(), gl4duPerspectivef(), gl4duRotatef(), gl4duScalef(), et gl4duTranslatef().

gl4duOrthod()

GL4DAPI void GL4DAPIENTRY gl4duOrthod	(	GLdouble	l,
		GLdouble	r,
		GLdouble	b,
		GLdouble	t,
		GLdouble	n,
		GLdouble	f
	)

Création d'une matrice de projection orthogonale selon l'ancienne fonction glOrtho et la multiplie dans la matrice en cours.

La matrice en cours doit être de type GLdouble sinon utiliser gl4duOrthof si le type est GLfloat.

Voir également

gl4duOrthof

                                                                                               {
  GLdouble ortho[16];
  MORTHO(ortho, l, r, b, t, n, f);
  gl4duMultMatrixd(ortho);
}

Références gl4duMultMatrixd(), et MORTHO.

gl4duOrthof()

GL4DAPI void GL4DAPIENTRY gl4duOrthof	(	GLfloat	l,
		GLfloat	r,
		GLfloat	b,
		GLfloat	t,
		GLfloat	n,
		GLfloat	f
	)

Création d'une matrice de projection orthogonale selon l'ancienne fonction glOrtho et la multiplie dans la matrice en cours.

La matrice en cours doit être de type GLfloat sinon utiliser gl4duOrthod si le type est GLdouble.

Voir également

gl4duOrthod

                                                                                         {
  GLfloat ortho[16];
  MORTHO(ortho, l, r, b, t, n, f);
  gl4duMultMatrixf(ortho);
}

Références gl4duMultMatrixf(), et MORTHO.

gl4duPerspectived()

GL4DAPI void GL4DAPIENTRY gl4duPerspectived	(	GLdouble	fovy,
		GLdouble	aspect,
		GLdouble	zNear,
		GLdouble	zFar
	)

Création d'une matrice de projection perspective selon l'ancienne fonction gluPerspective et la multiplie dans la matrice en cours.

La matrice en cours doit être de type GLdouble sinon utiliser gl4duPerspectivef si le type est GLfloat.

Voir également

gl4duPerspectivef

                                                                                     {
  GLdouble perspective[16];
  MPERSPECTIVE(perspective, fovy, aspect, zNear, zFar);
  gl4duMultMatrixd(perspective);
}

Références gl4duMultMatrixd(), et MPERSPECTIVE.

gl4duPerspectivef()

GL4DAPI void GL4DAPIENTRY gl4duPerspectivef	(	GLdouble	fovy,
		GLdouble	aspect,
		GLdouble	zNear,
		GLdouble	zFar
	)

Création d'une matrice de projection perspective selon l'ancienne fonction gluPerspective et la multiplie dans la matrice en cours.

La matrice en cours doit être de type GLfloat sinon utiliser gl4duPerspectived si le type est GLdouble.

Voir également

gl4duPerspectived

                                                                                     {
  GLfloat perspective[16];
  MPERSPECTIVE(perspective, fovy, aspect, zNear, zFar);
  gl4duMultMatrixf(perspective);
}

Références gl4duMultMatrixf(), et MPERSPECTIVE.

gl4duPopMatrix()

GL4DAPI void GL4DAPIENTRY gl4duPopMatrix

(

void

)

dépile la matrice courante en restaurant l'état précédemment sauvegardé à l'aide de gl4duPushMatrix.

                          {
  assert(_gl4dCurMatrix);
  if(_gl4dCurMatrix->top)
    --_gl4dCurMatrix->top;
}

Références _gl4dCurMatrix, et _GL4DUMatrix::top.

gl4duPrintFPS()

GL4DAPI void GL4DAPIENTRY gl4duPrintFPS

(

FILE *

fp

)

imprime dans le fichier pointé par fp le Frame-Per-Second.

Cette fonction doit être appelée dans la loop.

                              {
  double t;
  static double t0 = 0;
  static unsigned int f = 0;
  f++;
  t = gl4dGetElapsedTime();
  if(t - t0 > 2000.0) {
    fprintf(fp, "%8.2f\n", (1000.0 * f / (t - t0)));
    t0 = t;
    f  = 0;
  }
}

Références gl4dGetElapsedTime(), et t0.

Référencé par gl4duwMainLoop().

gl4duPrintProgramInfoLog()

GL4DAPI void GL4DAPIENTRY gl4duPrintProgramInfoLog	(	GLuint	object,
		FILE *	f
	)

imprime s'il existe l'infoLog de l'édition de liens pour le Program object dans fp.

                                                        {
  char * log = NULL;
  int maxLen = 0, len = 0;
  glGetProgramiv(object, GL_INFO_LOG_LENGTH, &maxLen);
  if(maxLen > 1) {
    log = malloc(maxLen * sizeof * log);
    assert(log);
    glGetProgramInfoLog(object, maxLen, &len, log);
    fprintf(fp, "%s (%d): %s (ID = %d)\n%s\n", __FILE__, __LINE__, __func__, object, log);
    free(log);
  }
}

Référencé par gl4duCreateProgram(), et gl4duCreateProgramFED().

gl4duPrintShaderInfoLog()

GL4DAPI void GL4DAPIENTRY gl4duPrintShaderInfoLog	(	GLuint	object,
		FILE *	f
	)

imprime s'il existe l'infoLog de la compilation du Shader object dans fp.

                                                       {
  char * log = NULL;
  int maxLen = 0, len = 0;
  glGetShaderiv(object, GL_INFO_LOG_LENGTH, &maxLen);
  if(maxLen > 1) {
    log = malloc(maxLen * sizeof * log);
    assert(log);
    glGetShaderInfoLog(object, maxLen, &len, log);
    fprintf(fp, "%s (%d): %s (ID = %d)\n%s\n", __FILE__, __LINE__, __func__, object, log);
    free(log);
  }
}

Référencé par addInShadersList(), et addInShadersListFED().

gl4duPushMatrix()

GL4DAPI void GL4DAPIENTRY gl4duPushMatrix

(

void

)

empile (sauvegarde) la matrice courante et utilise une nouvelle matrice dont le contenu est le meme que celle empilée.

La pile est dynamique, sa taille non limitée.

                           {
  assert(_gl4dCurMatrix);
  if(++_gl4dCurMatrix->top == _gl4dCurMatrix->nmemb) {
    _gl4dCurMatrix->data  = realloc(_gl4dCurMatrix->data, _gl4dCurMatrix->size * (_gl4dCurMatrix->nmemb <<= 1));
    assert(_gl4dCurMatrix->data);
  }
  memcpy(&(((GLubyte *)_gl4dCurMatrix->data)[_gl4dCurMatrix->top * _gl4dCurMatrix->size]),
     &(((GLubyte *)_gl4dCurMatrix->data)[(_gl4dCurMatrix->top - 1) * _gl4dCurMatrix->size]),
     _gl4dCurMatrix->size);
}

Références _gl4dCurMatrix, _GL4DUMatrix::data, _GL4DUMatrix::nmemb, _GL4DUMatrix::size, et _GL4DUMatrix::top.

gl4duRotated()

GL4DAPI void GL4DAPIENTRY gl4duRotated	(	GLdouble	angle,
		GLdouble	x,
		GLdouble	y,
		GLdouble	z
	)

Multiplication de la matrice en cours par une matrice de rotation définie par un angle angle donné en degrés autour de l'axe (x, y, z).

Paramètres

angle	angle de rotation en degrés.
x	abcsisse de l'axe de rotation.
y	ordonnée de l'axe de rotation.
z	cote de l'axe de rotation.

                                                                      {
  GLdouble n = sqrt(x * x + y * y + z * z);
  if ( n > 0.0 ) {
    GLdouble a, s, c, cc, x2, y2, z2, xy, yz, zx, xs, ys, zs;
    GLdouble mat[] = { 0.0, 0.0, 0.0, 0.0,
               0.0, 0.0, 0.0, 0.0,
               0.0, 0.0, 0.0, 0.0,
               0.0, 0.0, 0.0, 1.0 };
    s  = sin ( a = (angle * GL4DM_PI / 180.0) );
    cc = 1.0 - (c = cos ( a ));
    x /= n;     y /= n;     z /= n;
    x2 = x * x; y2 = y * y; z2 = z * z;
    xy = x * y; yz = y * z; zx = z * x;
    xs = x * s; ys = y * s; zs = z * s;
    mat[0]  = (cc * x2) + c;
    mat[1]  = (cc * xy) - zs;
    mat[2]  = (cc * zx) + ys;
    /* mat[3]  = 0.0; */
    mat[4]  = (cc * xy) + zs;
    mat[5]  = (cc * y2) + c;
    mat[6]  = (cc * yz) - xs;
    /* mat[7]  = 0.0; */
    mat[8]  = (cc * zx) - ys;
    mat[9]  = (cc * yz) + xs;
    mat[10] = (cc * z2) + c;
    /* mat[11] = 0.0; */
    /* mat[12] = 0.0; mat[13] = 0.0; mat[14] = 0.0; mat[15] = 1.0; */
    gl4duMultMatrixd(mat);
  }
}

Références GL4DM_PI, et gl4duMultMatrixd().

gl4duRotatef()

GL4DAPI void GL4DAPIENTRY gl4duRotatef	(	GLfloat	angle,
		GLfloat	x,
		GLfloat	y,
		GLfloat	z
	)

Multiplication de la matrice en cours par une matrice de rotation définie par un angle angle donné en degrés autour de l'axe (x, y, z).

Paramètres

angle	angle de rotation en degrés.
x	abcsisse de l'axe de rotation.
y	ordonnée de l'axe de rotation.
z	cote de l'axe de rotation.

                                                                  {
  GLfloat n = sqrtf(x * x + y * y + z * z);
  if ( n > 0.0f ) {
    GLfloat a, s, c, cc, x2, y2, z2, xy, yz, zx, xs, ys, zs;
    GLfloat mat[] = { 0.0f, 0.0f, 0.0f, 0.0f,
              0.0f, 0.0f, 0.0f, 0.0f,
              0.0f, 0.0f, 0.0f, 0.0f,
              0.0f, 0.0f, 0.0f, 1.0f };
    s  = sinf ( a = (angle * (GLfloat)GL4DM_PI / 180.0f) );
    cc = 1.0f - (c = cosf ( a ));
    x /= n;     y /= n;     z /= n;
    x2 = x * x; y2 = y * y; z2 = z * z;
    xy = x * y; yz = y * z; zx = z * x;
    xs = x * s; ys = y * s; zs = z * s;
    mat[0]  = (cc * x2) + c;
    mat[1]  = (cc * xy) - zs;
    mat[2]  = (cc * zx) + ys;
    /* mat[3]  = 0.0f; */
    mat[4]  = (cc * xy) + zs;
    mat[5]  = (cc * y2) + c;
    mat[6]  = (cc * yz) - xs;
    /* mat[7]  = 0.0f; */
    mat[8]  = (cc * zx) - ys;
    mat[9]  = (cc * yz) + xs;
    mat[10] = (cc * z2) + c;
    /* mat[11] = 0.0f; */
    /* mat[12] = 0.0f; mat[13] = 0.0f; mat[14] = 0.0f; mat[15] = 1.0f; */
    gl4duMultMatrixf(mat);
  }
}

Références GL4DM_PI, et gl4duMultMatrixf().

gl4duScaled()

GL4DAPI void GL4DAPIENTRY gl4duScaled	(	GLdouble	sx,
		GLdouble	sy,
		GLdouble	sz
	)

Multiplication de la matrice en cours par une matrice d'homothétie (sx, sy, sz).

Paramètres

sx	abcsisse de l'homothétie.
sy	ordonnée de l'homothétie.
sz	cote de l'homothétie.

                                                        {
  GLdouble mat[] = { sx , 0.0, 0.0, 0.0,
             0.0,  sy, 0.0, 0.0,
             0.0, 0.0,  sz, 0.0,
             0.0, 0.0, 0.0, 1.0 };
  gl4duMultMatrixd(mat);
}

Références gl4duMultMatrixd().

gl4duScalef()

GL4DAPI void GL4DAPIENTRY gl4duScalef	(	GLfloat	sx,
		GLfloat	sy,
		GLfloat	sz
	)

Multiplication de la matrice en cours par une matrice d'homothétie (sx, sy, sz).

Paramètres

sx	abcsisse de l'homothétie.
sy	ordonnée de l'homothétie.
sz	cote de l'homothétie.

                                                     {
  GLfloat mat[] = { sx  , 0.0f, 0.0f, 0.0f,
            0.0f,   sy, 0.0f, 0.0f,
            0.0f, 0.0f,   sz, 0.0f,
            0.0f, 0.0f, 0.0f, 1.0f };
  gl4duMultMatrixf(mat);
}

Références gl4duMultMatrixf().

gl4duSendMatrices()

GL4DAPI void GL4DAPIENTRY gl4duSendMatrices

(

void

)

envoie toutes matrices au program shader en cours et en utilisant leurs noms pour obtenir le uniform location.

                             {
  GLint pId;
  glGetIntegerv(GL_CURRENT_PROGRAM, &pId);
  btForAll(_gl4duMatrices, sendMatrix, (void **)&pId);
}

Références _gl4duMatrices, btForAll(), et sendMatrix().

gl4duSendMatrix()

GL4DAPI void GL4DAPIENTRY gl4duSendMatrix

(

void

)

envoie la matrice courante au program shader en cours et en utilisant le nom de la matrice pour obtenir le uniform location.

                           {
  GLint pId;
  assert(_gl4dCurMatrix);
  glGetIntegerv(GL_CURRENT_PROGRAM, &pId);
  sendMatrix(_gl4dCurMatrix, (void **)&pId);
}

Références _gl4dCurMatrix, et sendMatrix().

gl4duTranslated()

GL4DAPI void GL4DAPIENTRY gl4duTranslated	(	GLdouble	tx,
		GLdouble	ty,
		GLdouble	tz
	)

Multiplication de la matrice en cours par une matrice de translation (tx, ty, tz).

Paramètres

tx	abcsisse de la translation.
ty	ordonnée de la translation.
tz	cote de la translation.

                                                            {
  GLdouble mat[] = { 1.0, 0.0, 0.0, tx,
             0.0, 1.0, 0.0, ty,
             0.0, 0.0, 1.0, tz,
             0.0, 0.0, 0.0, 1.0 };
  gl4duMultMatrixd(mat);
}

Références gl4duMultMatrixd().

Référencé par gl4duLookAtd().

gl4duTranslatef()

GL4DAPI void GL4DAPIENTRY gl4duTranslatef	(	GLfloat	tx,
		GLfloat	ty,
		GLfloat	tz
	)

Multiplication de la matrice en cours par une matrice de translation (tx, ty, tz).

Paramètres

tx	abcsisse de la translation.
ty	ordonnée de la translation.
tz	cote de la translation.

                                                         {
  GLfloat mat[] = { 1.0f, 0.0f, 0.0f, tx,
            0.0f, 1.0f, 0.0f, ty,
            0.0f, 0.0f, 1.0f, tz,
            0.0f, 0.0f, 0.0f, 1.0f };
  gl4duMultMatrixf(mat);
}

Références gl4duMultMatrixf().

Référencé par gl4duLookAtf(), et gl4duLookAtf_DNW().

gl4duUpdateShaders()

GL4DAPI int GL4DAPIENTRY gl4duUpdateShaders

(

void

)

parcours la liste des shaders shaders_list et vérifie s'il y a besoin de mettre à jour le shader (recompiler et relinker).

La vérification est effectuée sur la date de modification du fichier representant le shader.

Renvoie

1 s'il y a eu une mise à jour (recompilation et relink) sinon 0.

A faire:

peut être ajouter un test sur le temps passé pour ne parcourir la liste qu'un fois tous les 1/10 de secondes ????

                             {
  GLenum ot;
  char * fn;
  int maj = 0, i, n;
  struct stat buf;
  program_t ** p;
  shader_t ** ptr = &shaders_list;
#ifdef COMMERCIAL_V
  return 0;
#endif
  while(*ptr) {
    if(!(*ptr)->verify_timestamp) {
      ptr = &((*ptr)->next);
      continue;
    }
    if(stat((*ptr)->filename, &buf) != 0) {
      fprintf(stderr, "%s:%d:In %s: erreur %d: %s\n",
          __FILE__, __LINE__, __func__, errno, strerror(errno));
      return 0;
    }
    if((*ptr)->mod_time != buf.st_mtime) {
      if((n = (*ptr)->nprograms)) {
    p = malloc(n * sizeof * p);
    assert(p);
    memcpy(p, (*ptr)->programs, n * sizeof * p);
    for(i = 0; i < n; i++)
      detachShader(p[i], *ptr);
    ot = (*ptr)->shadertype;
    fn = strdup((*ptr)->filename);
    deleteFromShadersList(ptr);
    ptr = addInShadersList(ot, fn, NULL);
    for(i = 0; i < n; i++) {
      attachShader(p[i], *ptr);
      glLinkProgram(p[i]->id);
    }
    free(p);
    free(fn);
      } else {
    ot = (*ptr)->shadertype;
    fn = strdup((*ptr)->filename);
    deleteFromShadersList(ptr);
    ptr = addInShadersList(ot, fn, NULL);
      }
      maj = 1;
    } else
      ptr = &((*ptr)->next);
  }
  return maj;
}

Références addInShadersList(), attachShader(), deleteFromShadersList(), detachShader(), et shaders_list.

Référencé par gl4duwMainLoop().