Référence du fichier gl4dummies.c

gestion simplifiée de GL sous différents OS et fonctionnalité de cryptage des shaders. Plus de détails...

#include <unistd.h>
#include "gl4dummies.h"
#include <math.h>
#include <time.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>

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

Aller au code source de ce fichier.

Macros
#define	getProcAddress(name)   (*SDL_GL_GetProcAddress)(name)

Fonctions
static int	kmpSearch (const char *p, const char *t)
	recherche un motif dans un text Plus de détails...
int GL4DAPIENTRY	gl4dExtensionSupported (const char *extension)
	recherche une extension dans glGetString(GL_EXTENSIONS) Plus de détails...
void	gl4dQuit (void)
	se charge de desalouer la memoire eventuellement utilisee par gl4dummies Plus de détails...
char *	gl4dReadTextFile (const char *filename)
	recopie un fichier texte en mémoire et renvoie un pointeur vers la donnée recopiée. Plus de détails...
char *	gl4dExtractFromDecData (const char *decData, const char *filename)
	recherche le shader filename dans le dat décrypté decData et retourne une copie du code. Plus de détails...
static double	getElapsedTime_sub1 (void)
static double	getElapsedTime_sub2 (void)
void	gl4dInitTime0 (void)
	Initialise t0. Plus de détails...
double	gl4dGetElapsedTime (void)
	Donne le temps ecoule en millisecondes depuis t0. Plus de détails...
void	gl4dInitTime (void)
	Initialise ti. Plus de détails...
double	gl4dGetTime (void)
	Donne le temps ecoule en millisecondes depuis ti. Plus de détails...
double	gl4dGetFps (void)
	Calcule le FPS - Frames Per Second. Plus de détails...
int	mv (const char *src, const char *dst)
	Déplace un fichier. Plus de détails...
char *	pathOf (const char *path)
	Renvoie le chemin vers le dossier contenant le fichier passé en argument. Plus de détails...
char *	filenameOf (const char *path)
	Renvoie le nom de fichier sans le chemin. Plus de détails...

Variables
static struct timeval	t0
	Le temps initial du programme. A initialiser avec gl4dInitTime0. Plus de détails...
static double(*	getET )(void) = getElapsedTime_sub1
static struct timeval	ti
	Une variable de temps. A initialiser avec gl4dInitTime. Plus de détails...

Description détaillée

gestion simplifiée de GL sous différents OS et fonctionnalité de cryptage des shaders.

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 - February 07, 2014

Définition dans le fichier gl4dummies.c.

Documentation des macros

getProcAddress

#define getProcAddress

(

name

)

(*SDL_GL_GetProcAddress)(name)

Documentation des fonctions

filenameOf()

char* filenameOf

(

const char *

path

)

Renvoie le nom de fichier sans le chemin.

Prend le nom du fichier à  partir de la dernière occurence du '/'. Cette chaîne doit être libérée avec free après usage.

Paramètres

path	le chemin vers le fichier/dossier

Renvoie

le nom de fichier sans le chemin. La chaîne renvoyée doit être libérée avec free après usage.

A faire:

renommer et bouger ailleurs

                                     {
  char * tmp = strrchr(path, '/');
  if (tmp == NULL)
    return strdup(path);
  return strdup(++tmp);
}

getElapsedTime_sub1()

static double getElapsedTime_sub1 ( void  )

static

                                        {
    gl4dInitTime0();
    getET = getElapsedTime_sub2;
    return 0.0;
}

Références getElapsedTime_sub2(), getET, et gl4dInitTime0().

getElapsedTime_sub2()

static double getElapsedTime_sub2 ( void  )

static

                                        {
  struct timeval t;
  double diff;
  gettimeofday(&t, (struct timezone*) 0);
  diff = (t.tv_sec - t0.tv_sec) * 1000000
    + (t.tv_usec - t0.tv_usec);
  return diff/1000.;
}

Références t0.

Référencé par getElapsedTime_sub1().

gl4dExtensionSupported()

int GL4DAPIENTRY gl4dExtensionSupported

(

const char *

extension

)

recherche une extension dans glGetString(GL_EXTENSIONS)

Renvoie

vrai si l'extension est trouvée

                                                                {
  const char * extensions = (const char *)glGetString(GL_EXTENSIONS);
  return kmpSearch(extension, extensions) < (int)strlen(extensions) ? 1 : 0;
}

Références kmpSearch().

gl4dExtractFromDecData()

char* gl4dExtractFromDecData	(	const char *	decData,
		const char *	filename
	)

recherche le shader filename dans le dat décrypté decData et retourne une copie du code.

                                                                           {
    int i, j;
    char a[BUFSIZ], * r;
    snprintf(a, BUFSIZ, "<shader %s>", filename);
    if((i = kmpSearch(a, decData)) < 0)
        return NULL;
    if((j = kmpSearch("</shader>", &decData[i + strlen(a)])) < 0)
        return NULL;
    r = malloc((j + 1) * sizeof * r);
    assert(r);
    strncpy(r, &decData[i + strlen(a)], j);
    r[j] = 0;
    return r;
}

Références kmpSearch().

Référencé par addInShadersListFED().

gl4dGetElapsedTime()

double gl4dGetElapsedTime

(

void

)

Donne le temps ecoule en millisecondes depuis t0.

Voir également

initTime0

Renvoie

le temps ecoule en millisecondes.

                                {
    return getET();
}

Références getET.

Référencé par gl4duPrintFPS().

gl4dGetFps()

double gl4dGetFps

(

void

)

Calcule le FPS - Frames Per Second.

Mettre un appel a cette fonction juste apres (ou avant) chaque affichage.

Voir également

gl4dInitTime0

getElapsedTime

Renvoie

le nombre d'images par seconde.

                        {
  static int f = 0;
  static double t0 = 0, t1 = 0, fps = 0.0;
  t1 = gl4dGetTime(); f++;
  if(t1 - t0 > 1000) {
    fps = 1000.0 * f / (t1 - t0);
    t0 = t1; f = 0;
  }
  return fps;
}

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

gl4dGetTime()

double gl4dGetTime

(

void

)

Donne le temps ecoule en millisecondes depuis ti.

Voir également

gl4dInitTime

Renvoie

le temps ecoule en millisecondes.

                         {
  struct timeval t;
  double diff;
  gettimeofday(&t, (struct timezone*) 0);
  diff = (t.tv_sec - ti.tv_sec) * 1000000
    + (t.tv_usec - ti.tv_usec);
  return diff/1000.;
}

Références ti.

Référencé par gl4dGetFps().

gl4dInitTime()

void gl4dInitTime

(

void

)

Initialise ti.

                        {
  gettimeofday(&ti, (struct timezone*) 0);
}

Références ti.

gl4dInitTime0()

void gl4dInitTime0

(

void

)

Initialise t0.

                         {
  gettimeofday(&t0, (struct timezone*) 0);
}

Références t0.

Référencé par getElapsedTime_sub1().

gl4dQuit()

void gl4dQuit

(

void

)

se charge de desalouer la memoire eventuellement utilisee par gl4dummies

                    {
  kmpSearch(NULL, NULL);
}

Références kmpSearch().

gl4dReadTextFile()

char* gl4dReadTextFile

(

const char *

filename

)

recopie un fichier texte en mémoire et renvoie un pointeur vers la donnée recopiée.

Renvoie

un pointeur vers le texte recopié en mémoire. La mémoire doit être libérée par free.

                                               {
  int l;
  char * data = NULL;
  FILE * f;
  struct stat buf;
  if(stat(filename, &buf) != 0) {
    fprintf(stderr, "%s:%d:In %s: error %d: %s (%s)\n",
        __FILE__, __LINE__, __func__, errno, strerror(errno), filename);
    return NULL;
  }
  data = malloc( (buf.st_size + 1) * sizeof * data );
  assert(data);
  if( (f = fopen(filename, "rb")) == NULL ) {
    fprintf(stderr, "%s:%d:In %s: error %d: %s (%s)\n",
        __FILE__, __LINE__, __func__, errno, strerror(errno), filename);
    free(data);
    return NULL;
  }
#ifdef _WIN32
  if( (l = (int)fread(data, sizeof * data, buf.st_size, f)) == 0) {
#else
  if( (l = (int)fread(data, sizeof * data, buf.st_size, f)) != buf.st_size) {
#endif
    fprintf(stderr, "%s:%d:In %s: une erreur s'est produite lors de la lecture du fichier %s\n",
        __FILE__, __LINE__, __func__, filename);
    free(data);
    fclose(f);
    return NULL;
  }
  data[l] = '\0';
  fclose(f);
  return data;
}

Référencé par addInShadersList().

kmpSearch()

static int kmpSearch ( const char *  p, const char *  t  )

static

recherche un motif dans un text

Utilise l'algorithme ameliore Knuth-Morris-Pratt. Ici l'initialisation de l'automate est faite si besoin dans la meme fonction. Pour liberer l'automate appeler la fonction avec le premier argument egal a NULL.

Renvoie

l'indice de la premiere occurence su motif

                                                     {
  int i, j, lt;
  static int lm = 0, * back = NULL;
  static const char * m = NULL;
  if(m != p || !p) {
    if(back){
      free(back);
      back = NULL;
    }
    if(!p) return -1;
    lm = (int)strlen(m = p);
    back = malloc(lm * sizeof * back);
    assert(back);
    for(back[i = 0] = j = -1; i < lm - 1; i++, j++, back[i] = (m[i] == m[j]) ? back[j] : j)
      while( j >= 0 && m[i] != m[j] ) j = back[j];
  }
  lt = (int)strlen(t);
  for(i = j = 0; j < lm && i < lt; i++, j++)
    while( j >= 0 && t[i] != m[j] ) { j = back[j]; }
  if(j == lm) return i - lm;
  return lt;
}

Référencé par gl4dExtensionSupported(), gl4dExtractFromDecData(), et gl4dQuit().

mv()

int mv	(	const char *	src,
		const char *	dst
	)

Déplace un fichier.

Paramètres

src	le chemin vers le fichier à  déplacer
dst	le nouveau chemin/nom

Renvoie

1 en cas de succès sinon 0.

A faire:

gérer les dossiers, les unlink (liés à l'OS) ...

A faire:

renommer et bouger ailleurs

                                           {
  size_t l;
  char buf[BUFSIZ] = {0};
  FILE *in = fopen(src, "rb");
  if(!in) {
    return 0;
  }
  FILE* out = fopen(dst, "wb");
  if(!out) {
    fclose(in);
    return 0;
  }
  while((l = fread(buf, 1, sizeof buf, in)) > 0)
    fwrite(buf, 1, l, out);
  fclose(out); fclose(in);
  if(remove(src))
    return 1;
  return 0;
}

Références in().

pathOf()

char* pathOf

(

const char *

path

)

Renvoie le chemin vers le dossier contenant le fichier passé en argument.

Fabrique la chaîne allant jusqu'à la dernière occurence du '/'. Cette chaîne doit être libérée avec free après usage.

Paramètres

path	le chemin vers le fichier/dossier

Renvoie

le chemin vers le dossier contenant le fichier passé en argument. La chaîne renvoyée doit être libérée avec free après usage.

A faire:

renommer et bouger ailleurs

                                 {
  int spos = -1;
  char * tmp, * ptr;
  tmp = malloc((strlen(path) + 1) * sizeof * tmp); assert(tmp); strcpy(tmp, path); //strdup(path);
  ptr = tmp;
  while(*ptr) {
    if(*ptr == '/' || *ptr == '\\')
      spos = ptr - tmp;
    ++ptr;
  }
  tmp[spos >= 0 ? spos : 0] = 0;
  return tmp;
}

Référencé par findPathOfMe().

Documentation des variables

getET

double(* getET) (void) = getElapsedTime_sub1

static

Référencé par getElapsedTime_sub1(), et gl4dGetElapsedTime().

t0

struct timeval t0

static

Le temps initial du programme. A initialiser avec gl4dInitTime0.

Voir également

gl4dInitTime0

Référencé par getElapsedTime_sub2(), gl4dGetFps(), gl4dInitTime0(), gl4dpCopyFromSDLSurfaceWithTransforms(), et gl4duPrintFPS().

ti

struct timeval ti

static

Une variable de temps. A initialiser avec gl4dInitTime.

Voir également

gl4dInitTime

Référencé par gl4dGetTime(), et gl4dInitTime().