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

#include "gl4du.h"
#include <string.h>
#include "gl4dh.h"
#include "bin_tree.h"
#include "linked_list.h"
#include <sys/stat.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include "aes.h"
#include <errno.h>
#include <limits.h>
#include <unistd.h>

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

Aller au code source de ce fichier.

Structures de données
struct	shader_t

struct	program_t

struct	_GL4DUMatrix
	structure de données pour une pile de "une matrice 4x4". Plus de détails...

Définitions de type
typedef struct shader_t	shader_t

typedef struct program_t	program_t

typedef struct _GL4DUMatrix	_GL4DUMatrix
	type de données lié à la structure struct _GL4DUMatrix. Plus de détails...

Fonctions
static shader_t **	findfnInShadersList (const char *filename)
	recherche un shader à partir du nom de fichier dans la liste shaders_list. Plus de détails...

static shader_t **	findidInShadersList (GLuint id)
	recherche un shader à partir de son identifiant openGL dans la liste shaders_list. Plus de détails...

static shader_t **	addInShadersList (GLenum shadertype, const char filename, const char shadercode)
	ajoute un nouveau shader dans la liste de shaders shaders_list. Plus de détails...

static shader_t **	addInShadersListFED (const char decData, GLenum shadertype, const char filename)
	ajoute un nouveau shader dans la liste de shaders shaders_list. Version FED Plus de détails...

static void	deleteFromShadersList (shader_t **shp)
	supprime le shader pointé par shp de la liste de shaders shaders_list. Plus de détails...

static program_t **	findInProgramsList (GLuint id)
	recherche un program à partir de son identifiant openGL dans la liste programs_list. Plus de détails...

static program_t **	addInProgramsList (GLuint id)
	ajoute un nouveau program dans la liste de program programs_list. Plus de détails...

static void	deleteFromProgramsList (program_t **pp)
	supprime le program pointé par pp de la liste des programs programs_list. Plus de détails...

static void	attachShader (program_t prg, shader_t sh)
	attache (lie) un program à un shader et vice versa. Plus de détails...

static void	detachShader (program_t prg, shader_t sh)
	détache (délie) un program à un shader et vice versa. Plus de détails...

static _GL4DUMatrix *	newGL4DUMatrix (GLenum type, const char *name)
	créé une nouvelle pile de "une matrice 4x4" dont le nom est name et le type est type. Plus de détails...

static void	freeGL4DUMatrix (void *matrix)
	libère la pile de "une matrice 4x4". Plus de détails...

static int	matrixCmpFunc (const void m1, const void m2)
	fonction de comparaison de deux matrices en fonction du nom pour insertion dans l'arbre binaire. Plus de détails...

static bin_tree_t **	findMatrix (const char *name)
	recherche et renvoie le pointeur de pointeur vers le noeud de l'arbre binaire pointant vers la matrice dont le nom est passé en argument (name). Plus de détails...

static void *	matrixData (_GL4DUMatrix *matrix)
	retourne le pointeur vers les données de la matrice (pile de "une matrice 4x4") courante. Plus de détails...

static void	findPathOfMe (const char *argv0)

void	gl4duInit (int argc, char **argv)
	Initialise la bibliothèque. Plus de détails...

int	gl4duHasInit (void)
	indique si la bibliothèque a été initialisée Plus de détails...

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

void	gl4duPrintShaderInfoLog (GLuint object, FILE *fp)
	imprime s'il existe l'infoLog de la compilation du Shader object dans fp. Plus de détails...

void	gl4duPrintProgramInfoLog (GLuint object, FILE *fp)
	imprime s'il existe l'infoLog de l'édition de liens pour le Program object dans fp. Plus de détails...

void	gl4duPrintFPS (FILE *fp)
	imprime dans le fichier pointé par fp le Frame-Per-Second. Plus de détails...

GLuint	gl4duCreateShader (GLenum shadertype, const char *filename)
	retourne l'identifiant du shader décrit dans filename. Plus de détails...

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

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

GLuint	gl4duFindShader (const char *filename)
	retourne l'identifiant du shader décrit dans filename. Plus de détails...

void	gl4duDeleteShader (GLuint id)
	supprime le shader dont l'identifiant openGL est id de la liste de shaders shaders_list. Plus de détails...

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

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

void	gl4duDeleteProgram (GLuint id)
	supprime le program dont l'identifiant openGL est id de la liste de programs programs_list. Plus de détails...

void	gl4duClean (GL4DUenum what)
	supprime tous les programs et/ou tous les shaders. Plus de détails...

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

void	gl4duCleanUnattached (GL4DUenum what)
	supprime programs et/ou shaders non liés. Plus de détails...

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

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

GLboolean	gl4duIsMatrix (const char *name)
	indique s'il existe une matrice est liée au nom name passé en argument. Plus de détails...

GLboolean	gl4duBindMatrix (const char *name)
	active (met en current) la matrice liée au nom name passé en argument. Plus de détails...

GLboolean	gl4duDeleteMatrix (const char *name)
	supprime la matrice liée au nom name passé en argument. Plus de détails...

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

void	gl4duPopMatrix (void)
	dépile la matrice courante en restaurant l'état précédemment sauvegardé à l'aide de gl4duPushMatrix. Plus de détails...

void	sendMatrix (void m, void *ppId)
	utilisée par btForAll pour envoyer la matrice m sur le program Id pointé par ppId. Plus de détails...

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

void	gl4duSendMatrices (void)
	envoie toutes matrices au program shader en cours et en utilisant leurs noms pour obtenir le uniform location. Plus de détails...

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

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

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

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

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

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

void	gl4duLoadIdentityf (void)
	Chargement d'une matrice identité dans la matrice en cours. Plus de détails...

void	gl4duLoadIdentityd (void)
	Chargement d'une matrice identité dans la matrice en cours. Plus de détails...

void	gl4duLoadMatrixf (const GLfloat *matrix)
	Chargement d'une matrice matrix dans la matrice en cours. Plus de détails...

void	gl4duLoadMatrixd (const GLdouble *matrix)
	Chargement d'une matrice matrix dans la matrice en cours. Plus de détails...

void	gl4duMultMatrixf (const GLfloat *matrix)
	Multiplication de la matrice en cours par une matrice matrix. Plus de détails...

void	gl4duMultMatrixd (const GLdouble *matrix)
	Multiplication de la matrice en cours par une matrice matrix. Plus de détails...

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

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

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

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

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

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

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

void	gl4duLookAtf_DNW (GLfloat eyeX, GLfloat eyeY, GLfloat eyeZ, GLfloat centerX, GLfloat centerY, GLfloat centerZ, GLfloat upX, GLfloat upY, GLfloat upZ)

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

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

void *	gl4duGetMatrixData (void)
	retourne le pointeur vers les données de la matrice (pile de "une matrice 4x4") courante. Plus de détails...

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

Variables
static shader_t *	shaders_list = NULL
	liste de vertex et fragment shaders. Chaque shader est composé d'un id (GL), du type, du nom de fichier et de la date de modification du fichier. Plus de détails...

static program_t *	programs_list = NULL
	liste de programs. Chaque program est composé d'un id (GL), il est lié à une liste de shaders. Plus de détails...

static bin_tree_t *	_gl4duMatrices = NULL
	arbre binaire contenant l'ensemble des matrices _GL4DUMatrix gérées. Plus de détails...

static _GL4DUMatrix *	_gl4dCurMatrix = NULL
	la matrice _GL4DUMatrix courante. Plus de détails...

static bin_tree_t **	_gl4dLastMatrixn = NULL
	le noeud vers la dernière matrice _GL4DUMatrix créée. Plus de détails...

static linked_list_t *	_aelist = NULL
	pile des fonctions à appeler lors du "at exit" de gl4duClean. Cette liste est remplie par gl4duAtExit. Plus de détails...

static char	_pathOfMe [BUFSIZ] = {0}
	stocke le chemin relatif à partir duquel le binaire a été exécuté. Est initialisée dans gl4dInit. Plus de détails...

static int	_pathOfMeInit = 0

static int	_hasInit = 0

Description détaillée

The GL4Dummies Utilities.

Auteur: Farès 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

A faire:: ajouter la prise en compte de différents contextes GL dans la structure shader_t et ainsi différencier les shaders (même quand c'est les mêmes) créés dans différents contextes

A faire:: ajouter, pour pas mal de fonctions, une gestion des erreurs à la errno ...

A faire:: la macro PI_180 a été ajoutée et le code antérieur n'a pas été modifié par manque de temps sur les tests de non regression.

Définition dans le fichier gl4du.c.

Documentation des définitions de type

◆ _GL4DUMatrix

typedef struct _GL4DUMatrix _GL4DUMatrix

type de données lié à la structure struct _GL4DUMatrix.

◆ program_t

typedef struct program_t program_t

◆ shader_t

typedef struct shader_t shader_t

Documentation des fonctions

◆ addInProgramsList()

static program_t ** addInProgramsList ( GLuint id )

static

ajoute un nouveau program dans la liste de program programs_list.

Renvoie: l'adresse du program ajouté sinon NULL.

                                                  {
   program_t * ptr = programs_list;
   programs_list = malloc(sizeof * programs_list);
   assert(programs_list);
   programs_list->id       = id;
   programs_list->nshaders = 0;
   programs_list->sshaders = 4;
   programs_list->next     = ptr;
   programs_list->shaders  = malloc(programs_list->sshaders * sizeof * programs_list->shaders);
   assert(programs_list->shaders);
   return &programs_list;
 }

Références program_t::id, program_t::next, program_t::nshaders, programs_list, program_t::shaders, et program_t::sshaders.

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

◆ addInShadersList()

static shader_t ** addInShadersList	(	GLenum	shadertype,
		const char *	filename,
		const char *	shadercode
	)

static

ajoute un nouveau shader dans la liste de shaders shaders_list.

Paramètres

shadertype	type de shader (vertex, fragment et geometry)
filename	nom du fichier shader
shadercode	source du shader, si NULL sera récupéré depuis filename

Renvoie: l'adresse du shader ajouté sinon NULL.

                                                                                                        {
   GLuint id;
   char * txt = NULL;
   struct stat buf;
   shader_t * ptr;
   if(!(id = glCreateShader(shadertype))) {
     fprintf(stderr, "%s (%d): %s: impossible de créer le shader\nglCreateShader a retourné 0\n",
         __FILE__, __LINE__, __func__);
     return NULL;
   }
   if(shadercode == NULL) {
     if(!(txt = gl4dReadTextFile(filename))) {
       glDeleteShader(id);
       return NULL;
     }
     if(stat(filename, &buf) != 0) {
       fprintf(stderr, "%s:%d:In %s: erreur %d: %s\n",
           __FILE__, __LINE__, __func__, errno, strerror(errno));
       glDeleteShader(id);
       return NULL;
     }
   } else
     txt = (char *)shadercode;
   ptr = shaders_list;
   shaders_list = malloc(sizeof * shaders_list);
   assert(shaders_list);
   shaders_list->id         = id;
   shaders_list->shadertype = shadertype;
   shaders_list->filename   = strdup(filename);
   shaders_list->mod_time   = shadercode ? INT_MAX : buf.st_mtime;
   shaders_list->verify_timestamp = shadercode ? GL_FALSE : GL_TRUE;
   shaders_list->todelete   = 0;
   shaders_list->nprograms  = 0;
   shaders_list->sprograms  = 2;
   shaders_list->next       = ptr;
   shaders_list->programs   = malloc(shaders_list->sprograms * sizeof shaders_list->programs);
   assert(shaders_list->programs);
   glShaderSource(id, 1, (const char **)&txt, NULL);
   glCompileShader(id);
   gl4duPrintShaderInfoLog(id, stderr);
   if(shadercode == NULL)
     free(txt);
   return &shaders_list;
 }

Références shader_t::filename, gl4dReadTextFile(), gl4duPrintShaderInfoLog(), shader_t::id, shader_t::mod_time, shader_t::next, shader_t::nprograms, shader_t::programs, shaders_list, shader_t::shadertype, shader_t::sprograms, shader_t::todelete, et shader_t::verify_timestamp.

Référencé par gl4duCreateShader(), gl4duCreateShaderIM(), et gl4duUpdateShaders().

◆ addInShadersListFED()

static shader_t ** addInShadersListFED	(	const char *	decData,
		GLenum	shadertype,
		const char *	filename
	)

static

ajoute un nouveau shader dans la liste de shaders shaders_list. Version FED

Renvoie: l'adresse du shader ajouté sinon NULL.

                                                                                                        {
   GLuint id;
   char * txt;
   shader_t * ptr;
   if(!(id = glCreateShader(shadertype))) {
     fprintf(stderr, "%s (%d): %s: impossible de créer le shader\nglCreateShader a retourné 0\n",
         __FILE__, __LINE__, __func__);
     return NULL;
   }
   if(!(txt = gl4dExtractFromDecData(decData, filename))) {
     glDeleteShader(id);
     return NULL;
   }
   ptr = shaders_list;
   shaders_list = malloc(sizeof * shaders_list);
   assert(shaders_list);
   shaders_list->id         = id;
   shaders_list->shadertype = shadertype;
   shaders_list->filename   = strdup(filename);
   shaders_list->mod_time   = INT_MAX;
   shaders_list->verify_timestamp = GL_FALSE;
   shaders_list->todelete   = 0;
   shaders_list->nprograms  = 0;
   shaders_list->sprograms  = 2;
   shaders_list->next       = ptr;
   shaders_list->programs   = malloc(shaders_list->sprograms * sizeof shaders_list->programs);
   assert(shaders_list->programs);
   glShaderSource(id, 1, (const char **)&txt, NULL);
   glCompileShader(id);
   gl4duPrintShaderInfoLog(id, stderr);
   free(txt);
   return &shaders_list;
 }

Références shader_t::filename, gl4dExtractFromDecData(), gl4duPrintShaderInfoLog(), shader_t::id, shader_t::mod_time, shader_t::next, shader_t::nprograms, shader_t::programs, shaders_list, shader_t::shadertype, shader_t::sprograms, shader_t::todelete, et shader_t::verify_timestamp.

Référencé par gl4duCreateShaderFED().

◆ attachShader()

static void attachShader	(	program_t *	prg,
		shader_t *	sh
	)

static

attache (lie) un program à un shader et vice versa.

                                                          {
   int i;
   for(i = 0; i < prg->nshaders; i++)
     if(prg->shaders[i] == sh) return;
   for(i = 0; i < sh->nprograms; i++)
     if(sh->programs[i] == prg) return;
   if(prg->nshaders >= prg->sshaders) { /* ne devrait pas être supérieur */
     prg->shaders = realloc(prg->shaders, (prg->sshaders <<= 1) * sizeof * prg->shaders);
     assert(prg->shaders);
   }
   if(sh->nprograms >= sh->sprograms) { /* ne devrait pas être supérieur */
     sh->programs = realloc(sh->programs, (sh->sprograms <<= 1) * sizeof * sh->programs);
     assert(sh->programs);
   }
   prg->shaders[prg->nshaders++] =  sh;
   sh->programs[sh->nprograms++] = prg;
   glAttachShader(prg->id, sh->id);
 }

Références shader_t::id, program_t::id, shader_t::nprograms, program_t::nshaders, shader_t::programs, program_t::shaders, shader_t::sprograms, et program_t::sshaders.

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

◆ deleteFromProgramsList()

static void deleteFromProgramsList ( program_t ** pp )

static

supprime le program pointé par pp de la liste des programs programs_list.

                                                     {
   int i;
   program_t * ptr = *pp;
   *pp = (*pp)->next;
   for(i = 0; i < ptr->nshaders; i++)
     detachShader(ptr, ptr->shaders[i]);
   free(ptr->shaders);
   glDeleteProgram(ptr->id);
   free(ptr);
 }

Références detachShader(), program_t::id, program_t::next, program_t::nshaders, et program_t::shaders.

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

◆ deleteFromShadersList()

static void deleteFromShadersList ( shader_t ** shp )

static

supprime le shader pointé par shp de la liste de shaders shaders_list.

                                                    {
   shader_t * ptr = *shp;
   *shp = (*shp)->next;
   free(ptr->filename);
   free(ptr->programs);
   glDeleteShader(ptr->id);
   free(ptr);
 }

Références shader_t::filename, shader_t::id, shader_t::next, et shader_t::programs.

Référencé par detachShader(), gl4duClean(), gl4duCleanUnattached(), gl4duDeleteShader(), et gl4duUpdateShaders().

◆ detachShader()

static void detachShader	(	program_t *	prg,
		shader_t *	sh
	)

static

détache (délie) un program à un shader et vice versa.

                                                          {
   int i;
   glDetachShader(prg->id, sh->id);
   for(i = 0; i < prg->nshaders; i++)
     if(prg->shaders[i] == sh) break;
   for(prg->nshaders--; i < prg->nshaders; i++)
     prg->shaders[i] = prg->shaders[i + 1];
   for(i = 0; i < sh->nprograms; i++)
     if(sh->programs[i] == prg) break;
   for(sh->nprograms--; i < sh->nprograms; i++)
     sh->programs[i] = sh->programs[i + 1];
   if(sh->nprograms <= 0 && sh->todelete) /* ne devrait pas être négatif */
     deleteFromShadersList(findidInShadersList(sh->id));
 }

Références deleteFromShadersList(), findidInShadersList(), shader_t::id, program_t::id, shader_t::nprograms, program_t::nshaders, shader_t::programs, program_t::shaders, et shader_t::todelete.

Référencé par deleteFromProgramsList(), et gl4duUpdateShaders().

◆ findfnInShadersList()

static shader_t ** findfnInShadersList ( const char * filename )

static

recherche un shader à partir du nom de fichier dans la liste shaders_list.

Si le shader n'existe pas la fonction retourne NULL;

Paramètres

filename le nom (le chemin entier (relatif)) du fichier contenant le shader

Renvoie: le pointeur de pointeur vers le shader.

                                                               {
   shader_t ** ptr = &shaders_list;
   while(*ptr) {
     if(!strcmp(filename, (*ptr)->filename))
       return ptr;
     ptr = &((*ptr)->next);
   }
   return ptr;
 }

Références shaders_list.

Référencé par gl4duCreateShader(), gl4duCreateShaderFED(), gl4duCreateShaderIM(), et gl4duFindShader().

◆ findidInShadersList()

static shader_t ** findidInShadersList ( GLuint id )

static

recherche un shader à partir de son identifiant openGL dans la liste shaders_list.

Si le shader n'existe pas la fonction retourne NULL;

Paramètres

id	l'identifiant openGL du shader.

Renvoie: le pointeur de pointeur vers le shader.

                                                   {
   shader_t ** ptr = &shaders_list;
   while(*ptr) {
     if(id == (*ptr)->id)
       return ptr;
     ptr = &((*ptr)->next);
   }
   return ptr;
 }

Références shaders_list.

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

◆ findInProgramsList()

static program_t ** findInProgramsList ( GLuint id )

static

recherche un program à partir de son identifiant openGL dans la liste programs_list.

Si le program n'existe pas la fonction retourne NULL;

Renvoie: le pointeur de pointeur vers le program.

                                                   {
   program_t ** ptr = &programs_list;
   while(*ptr) {
     if(id == (*ptr)->id)
       return ptr;
     ptr = &((*ptr)->next);
   }
   return ptr;
 }

Références programs_list.

Référencé par gl4duDeleteProgram().

◆ findMatrix()

static bin_tree_t ** findMatrix ( const char * name )

inlinestatic

recherche et renvoie le pointeur de pointeur vers le noeud de l'arbre binaire pointant vers la matrice dont le nom est passé en argument (name).

Paramètres

name	le nom de la matrice recherchée.

Renvoie: le pointeur de pointeur vers le noeud de l'arbre binaire pointant vers la matrice dont le nom est passé en argument (name).

                                                           {
   pair_t pair;
   _GL4DUMatrix m;
   if(_gl4dLastMatrixn && strcmp(((_GL4DUMatrix *)((*_gl4dLastMatrixn)->data))->name, name) == 0)
     return _gl4dLastMatrixn;
   m.name = (char *)name;
   pair = btFind(&_gl4duMatrices, &m, matrixCmpFunc);
   if(!pair.compResult)
     return (bin_tree_t **)pair.ptr;
   return NULL;
 }

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

Référencé par gl4duBindMatrix(), gl4duDeleteMatrix(), et gl4duMultMatrixByName().

◆ findPathOfMe()

static void findPathOfMe ( const char * argv0 )

static

                                              {
   char buf[BUFSIZ] = {0};
   ssize_t len = 0;
 #if defined(_WIN32)
   /* tous les compilateurs sous windows ? */
   if(GetModuleFileNameA(NULL, buf, sizeof buf - 1) == 0)
     fprintf(stderr, "%s (%s:%d) - error while GetModuleFileNameA(), error: %s\n",
         __func__, __FILE__, __LINE__, GetLastError());
 #elif defined(__FreeBSD__)
   struct kinfo_proc *proc = kinfo_getproc(getpid());
   if(proc) {
     strncpy(buf, proc->ki_comm, sizeof buf - 1);
     free(proc);
   } else {
     fprintf(stderr, "%s (%s:%d) - error while kinfo_getproc(getpid()), trying with readlink\n",
         __func__, __FILE__, __LINE__);
     if((len = readlink("/proc/curproc/file", buf, sizeof buf - 1)) < 0) { /* only if it has procfs which it does not by default */
       fprintf(stderr, "%s (%s:%d) - finding exec path failed with readlink, error: %s\n",
           __func__, __FILE__, __LINE__, strerror(errno));
       /* sinon essayer sysctl CTL_KERN KERN_PROC KERN_PROC_PATHNAME -1 ??? */
     } else {
         buf[len] = '\0';
     }
   }
 #elif defined(__MACOSX__)
   pid_t pid = getpid();
   char symlinkpath[BUFSIZ];
   uint32_t size = BUFSIZ;
   if(proc_pidpath(pid, buf, sizeof buf) <= 0) {
     fprintf(stderr, "%s (%s:%d) - proc_pidpath(%d ...) error: %s\n",
         __func__, __FILE__, __LINE__, pid, strerror(errno));
   }
   if (_NSGetExecutablePath(symlinkpath, &size) == 0)
     realpath(symlinkpath, buf);
   else
     fprintf(stderr, "%s (%s:%d) - _NSGetExecutablePath() returns a path that exceeds the buffer size, size needed: %d\n",
             __func__, __FILE__, __LINE__, size);
 #else /* autres unices */
   if((len = readlink("/proc/self/exe", buf, sizeof buf - 1)) > 0) /*  (Linux)  */
     buf[len] = '\0';
   else if((len = readlink("/proc/curproc/file", buf, sizeof buf - 1)) > 0)    /* (BSD ?) */
     buf[len] = '\0';
   else if((len = readlink("/proc/curproc/exe", buf, sizeof buf - 1)) > 0)    /* (NetBSD) */
     buf[len] = '\0';
   else if((len = readlink("/proc/self/path/a.out", buf, sizeof buf - 1)) > 0)  /* (Solaris) sinon strncpy(buf, getexecname(), sizeof buf) ?? */
     buf[len] = '\0';
   else
     fprintf(stderr, "%s (%s:%d) - finding exec path failed with readlink, error: %s\n",
         __func__, __FILE__, __LINE__, strerror(errno));
 #endif
   strncpy(_pathOfMe, pathOf(strlen(buf) > 0 ? buf : argv0), sizeof _pathOfMe - 1);
   _pathOfMeInit = 1;
 }

Références _pathOfMe, _pathOfMeInit, et pathOf().

Référencé par gl4duInit().

◆ freeGL4DUMatrix()

static void freeGL4DUMatrix ( void * matrix )

inlinestatic

libère la pile de "une matrice 4x4".

Paramètres

matrix est la pile de "une matrice 4x4".

                                                   {
   free(((_GL4DUMatrix *)matrix)->name);
   free(((_GL4DUMatrix *)matrix)->data);
   free(matrix);
 }

Référencé par gl4duClean(), et gl4duDeleteMatrix().

◆ gl4duAtExit()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

int gl4duHasInit ( void )

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

                        {
   return _hasInit;
 }

Références _hasInit.

◆ gl4duInit()

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

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

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

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

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

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

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

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

◆ gl4duLookAtf_DNW()

void gl4duLookAtf_DNW	(	GLfloat	eyeX,
		GLfloat	eyeY,
		GLfloat	eyeZ,
		GLfloat	centerX,
		GLfloat	centerY,
		GLfloat	centerZ,
		GLfloat	upX,
		GLfloat	upY,
		GLfloat	upZ
	)

                                                                                                                                                                   {
   GLfloat haut[3] = { upX, upY, upZ }, dirVue[] = { centerX - eyeX, centerY - eyeY, centerZ - eyeZ };
   GLfloat mat[] = {
     0.0f,       0.0f,       0.0f,       0.0f,
     0.0f,       0.0f,       0.0f,       0.0f,
     -dirVue[0], -dirVue[1], -dirVue[2], 0.0f,
     0.0f,       0.0f,       0.0f,       1.0f
   };
   //MMAT4TRANSPOSE(mat);
   MVEC3NORMALIZE(dirVue);
   /* Première version
      GLfloat cote[3];
      MVEC3CROSS(cote, dirVue, haut); // j'ai envie de faire haut x dirVue
      MVEC3NORMALIZE(cote);
      mat[0] = cote[0]; mat[1] = cote[1]; mat[2] = cote[2];
      //\todo dire pourquoi (lié à la normalisation de cote)
      MVEC3CROSS(haut, cote, dirVue); // j'ai envie de faire dirVue x coté
      mat[4] = haut[0]; mat[5] = haut[1]; mat[6] = haut[2]; */
   MVEC3CROSS(mat, dirVue, haut);
   MVEC3NORMALIZE(mat);
   MVEC3CROSS(&mat[4], mat, dirVue);
   gl4duMultMatrixf(mat);
   gl4duTranslatef(-eyeX, -eyeY, -eyeZ);
 }

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

◆ gl4duMakeBinRelativePath()

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

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

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

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

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

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

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

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

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

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

void gl4duPrintProgramInfoLog	(	GLuint	object,
		FILE *	fp
	)

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

void gl4duPrintShaderInfoLog	(	GLuint	object,
		FILE *	fp
	)

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

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

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

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

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

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

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

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

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

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

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

◆ matrixCmpFunc()

static int matrixCmpFunc	(	const void *	m1,
		const void *	m2
	)

inlinestatic

fonction de comparaison de deux matrices en fonction du nom pour insertion dans l'arbre binaire.

Cette fonction utilise strcmp.

Paramètres

m1	première matrice (de type _GL4DUMatrix).
m2	seconde matrice (de type _GL4DUMatrix).

Renvoie: entier négatif, nul ou positif selon que le nom de la première soit respectivement inférieur, égal ou supérieur à la seconde.

                                                                   {
   return strcmp( ((_GL4DUMatrix *)m1)->name, ((_GL4DUMatrix *)m2)->name );
 }

Référencé par findMatrix(), gl4duGenMatrix(), et gl4duIsMatrix().

◆ matrixData()

static void * matrixData ( _GL4DUMatrix * matrix )

inlinestatic

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.

                                                        {
   return (void *)&(((GLubyte *)matrix->data)[matrix->top * matrix->size]);
 }

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

Référencé par gl4duGetMatrixData(), et sendMatrix().

◆ newGL4DUMatrix()

static _GL4DUMatrix * newGL4DUMatrix	(	GLenum	type,
		const char *	name
	)

inlinestatic

créé une nouvelle pile de "une matrice 4x4" dont le nom est name et le type est type.

La (pile de) matrice créée n'est pas initialisée et le haut de la pile pointe déjà sur une matrice.

Paramètres

type	est le type de données utilisé dans la matrice, peut etre GL_FLOAT ou GL_DOUBLE.
name	est le nom unique donné à la matrice.

Renvoie: la nouvelle pile de "une matrice 4x4" créée.

                                                                             {
   _GL4DUMatrix * m = malloc(sizeof *m);
   assert(m);
   m->name  = strdup(name);
   m->type  = type;
   m->size  = 16 * ( (type == GL_FLOAT) ? sizeof (GLfloat) : /* type == GL_DOUBLE */ sizeof (GLdouble) );
   m->nmemb = 16;
   m->top   = 0; /* déjà une matrice en haut de la pile */
   m->data  = malloc(m->size * m->nmemb);
   assert(m->data);
   return m;
 }

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

Référencé par gl4duGenMatrix().

◆ sendMatrix()

void sendMatrix	(	void *	m,
		void **	ppId
	)

utilisée par btForAll pour envoyer la matrice m sur le program Id pointé par ppId.

A faire:: ajouter la gestion des GLdouble

                                        {
   _GL4DUMatrix * matrix = (_GL4DUMatrix * )m;
   GLint pId = *(GLint *)ppId;
 #ifdef __ANDROID__
  
   GLfloat t[16], * M = matrixData(matrix);
   t[0] = M[0]; t[1] = M[4]; t[2] = M[8]; t[3] = M[12];
   t[4] = M[1]; t[5] = M[5]; t[6] = M[9]; t[7] = M[13];
   t[8] = M[2]; t[9] = M[6]; t[10] = M[10]; t[11] = M[14];
   t[12] = M[3]; t[13] = M[7]; t[14] = M[11]; t[15] = M[15];
   glUniformMatrix4fv(glGetUniformLocation(pId, matrix->name), 1, GL_FALSE, t);
   //__android_log_print(ANDROID_LOG_ERROR, "AndroidGL4D", "PROGRAM %d, Matrix %s : %d\n", pId, matrix->name, glGetUniformLocation(pId, matrix->name));
 #else
   glUniformMatrix4fv(glGetUniformLocation(pId, matrix->name), 1, GL_TRUE, matrixData(matrix));
 #endif
 }

Références matrixData(), et _GL4DUMatrix::name.

Référencé par gl4duSendMatrices(), et gl4duSendMatrix().

Documentation des variables

◆ _aelist

linked_list_t* _aelist = NULL

static

pile des fonctions à appeler lors du "at exit" de gl4duClean. Cette liste est remplie par gl4duAtExit.

Référencé par gl4duAtExit(), et gl4duClean().

◆ _gl4dCurMatrix

_GL4DUMatrix* _gl4dCurMatrix = NULL

static

la matrice _GL4DUMatrix courante.

Référencé par gl4duBindMatrix(), gl4duDeleteMatrix(), gl4duGetIntegerv(), gl4duGetMatrixData(), gl4duLoadIdentityd(), gl4duLoadIdentityf(), gl4duLoadMatrixd(), gl4duLoadMatrixf(), gl4duMultMatrixByName(), gl4duMultMatrixd(), gl4duMultMatrixf(), gl4duPopMatrix(), gl4duPushMatrix(), et gl4duSendMatrix().

◆ _gl4dLastMatrixn

bin_tree_t** _gl4dLastMatrixn = NULL

static

le noeud vers la dernière matrice _GL4DUMatrix créée.

Référencé par findMatrix(), gl4duDeleteMatrix(), et gl4duGenMatrix().

◆ _gl4duMatrices

bin_tree_t* _gl4duMatrices = NULL

static

arbre binaire contenant l'ensemble des matrices _GL4DUMatrix gérées.

Référencé par findMatrix(), gl4duClean(), gl4duGenMatrix(), gl4duIsMatrix(), et gl4duSendMatrices().

◆ _hasInit

int _hasInit = 0

static

Référencé par gl4duClean(), gl4duHasInit(), et gl4duInit().

◆ _pathOfMe

char _pathOfMe[BUFSIZ] = {0}

static

stocke le chemin relatif à partir duquel le binaire a été exécuté. Est initialisée dans gl4dInit.

Voir également: gl4dInit

Référencé par findPathOfMe(), et gl4duMakeBinRelativePath().

◆ _pathOfMeInit

int _pathOfMeInit = 0

static

Référencé par findPathOfMe(), et gl4duMakeBinRelativePath().

◆ programs_list

program_t* programs_list = NULL

static

liste de programs. Chaque program est composé d'un id (GL), il est lié à une liste de shaders.

Référencé par addInProgramsList(), findInProgramsList(), gl4duClean(), et gl4duCleanUnattached().

◆ shaders_list

shader_t* shaders_list = NULL

static

liste de vertex et fragment shaders. Chaque shader est composé d'un id (GL), du type, du nom de fichier et de la date de modification du fichier.

Référencé par addInShadersList(), addInShadersListFED(), findfnInShadersList(), findidInShadersList(), gl4duClean(), gl4duCleanUnattached(), et gl4duUpdateShaders().

Structures de données

Définitions de type

Fonctions

Variables

Description détaillée

Documentation des définitions de type

◆ _GL4DUMatrix

◆ program_t

◆ shader_t

Documentation des fonctions

◆ addInProgramsList()

◆ addInShadersList()

◆ addInShadersListFED()

◆ attachShader()

◆ deleteFromProgramsList()

◆ deleteFromShadersList()

◆ detachShader()

◆ findfnInShadersList()

◆ findidInShadersList()

◆ findInProgramsList()

◆ findMatrix()

◆ findPathOfMe()

◆ freeGL4DUMatrix()

◆ gl4duAtExit()

◆ gl4duBindMatrix()

◆ gl4duClean()

◆ gl4duCleanUnattached()

◆ gl4duCreateProgram()

◆ gl4duCreateProgramFED()

◆ gl4duCreateShader()

◆ gl4duCreateShaderFED()

◆ gl4duCreateShaderIM()

◆ gl4duDeleteMatrix()

◆ gl4duDeleteProgram()

◆ gl4duDeleteShader()

◆ gl4duFindShader()

◆ gl4duFrustumd()

◆ gl4duFrustumf()

◆ gl4duGenMatrix()

◆ gl4duGetIntegerv()

◆ gl4duGetMatrixData()

◆ gl4duHasInit()

◆ gl4duInit()

◆ gl4duIsMatrix()

◆ gl4duLoadIdentityd()

◆ gl4duLoadIdentityf()

◆ gl4duLoadMatrixd()

◆ gl4duLoadMatrixf()

◆ gl4duLookAtd()

◆ gl4duLookAtf()

◆ gl4duLookAtf_DNW()

◆ gl4duMakeBinRelativePath()

◆ gl4duMultMatrixByName()

◆ gl4duMultMatrixd()

◆ gl4duMultMatrixf()

◆ gl4duOrthod()

◆ gl4duOrthof()

◆ gl4duPerspectived()

◆ gl4duPerspectivef()

◆ gl4duPopMatrix()

◆ gl4duPrintFPS()

◆ gl4duPrintProgramInfoLog()

◆ gl4duPrintShaderInfoLog()

◆ gl4duPushMatrix()

◆ gl4duRotated()

◆ gl4duRotatef()

◆ gl4duScaled()

◆ gl4duScalef()

◆ gl4duSendMatrices()

◆ gl4duSendMatrix()

◆ gl4duTranslated()

◆ gl4duTranslatef()

◆ gl4duUpdateShaders()

◆ matrixCmpFunc()

◆ matrixData()

◆ newGL4DUMatrix()

◆ sendMatrix()

Documentation des variables

◆ _aelist

◆ _gl4dCurMatrix