Référence du fichier gl4dhAnimeManager.c

Bibliothèque de gestion des écrans d'animation et de mises à jour en fonction du son. Plus de détails...

#include "gl4dhAnimeManager.h"
#include <assert.h>
#include <stdlib.h>

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

Aller au code source de ce fichier.

Fonctions
static int	in (void *func, void **funcList, int n)
	regarde si le pointeur func est un élément du tableau funcList Plus de détails...
static void	add (void *func, void ***funcListp, int *n, int *s)
	ajoute le pointeur func dans le tableau d'éléments *funcListp Plus de détails...
static void	callAllWithState (GL4DHanime *animations, int state)
	Parcourt un tableau d'animations (possiblement dupliquées) et les appelle une et une seule fois avec l'état state. Plus de détails...
static void	drawOrUpdateWithAudio (GL4DHanime *animations, int state)
	joue ou met à jour parmi les animations passées en argument l'animation en cours (devant être jouée/mise à jour au temps t). Plus de détails...
void	gl4dhInit (GL4DHanime *animations, int w, int h, void(*callBeforeAllAnimationsInit)(void))
	Demande l'état initialisation à tous les éléments du tableau d'animations. Plus de détails...
void	gl4dhClean (void)
	demande l'état libération à tous les éléments du tableau d'animations. Plus de détails...
void	gl4dhStartingSignal (void)
	donne le top-départ de la démo. Cette fonction doit être appelée juste avant le début de la boucle infinie d'affichage (soit juste avant le premier GL4DH_DRAW obtenu en appelant gl4dhDraw). Plus de détails...
Uint32	gl4dhGetTicks (void)
	renvoie le nombre de milisecondes passée depuis le top-départ donné par gl4dhStartingSignal. Plus de détails...
void	gl4dhDraw (void)
	joue parmi les animations passées en argument l'animation en cours (devant être jouée au temps t). Plus de détails...
void	gl4dhUpdateWithAudio (void)
	met à jour parmi les animations passées en argument l'animation en cours. Plus de détails...

Variables
static Uint32	_startingTime = 0
static GL4DHanime *	_animations = NULL
	pointeur vers le tableau d'animations passé à l'init avec gl4dhInit Plus de détails...
static GLuint	_fbo = 0
	identifiant du framebuffer utilisé pour dessiner les animations Plus de détails...
static GLuint	_wTexId = 0
	identifiant de la texture liée en écriture au framebuffer _fbo (la texture dans laquelle les animations sont dessinées) Plus de détails...
static GLuint	_wdTexId = 0
static int	_w = 1
	largeur et hauteur de la texture _wTexId liée en écriture au framebuffer _fbo Plus de détails...
static int	_h = 1

Description détaillée

Bibliothèque de gestion des écrans d'animation et de mises à jour en fonction du son.

Auteur

Farès BELHADJ, amsi@.nosp@m.ai.u.nosp@m.niv-p.nosp@m.aris.nosp@m.8.fr

Date

April 29 2014

Définition dans le fichier gl4dhAnimeManager.c.

Documentation des fonctions

add()

static void add ( void *  func, void ***  funcListp, int *  n, int *  s  )

static

ajoute le pointeur func dans le tableau d'éléments *funcListp

Paramètres

func	un élément dont il faut tester la présence.
funcListp	le pointeur vers le tableau d'éléments.
n	le pointeur vers le nombre d'éléments dans *funcListp.
s	le pointeur vers la taille, en nombre d'éléments, de *funcListp.

                                                               {
  if(*s == 0) {
    *n = 0;
    *funcListp = calloc((*s = 16), sizeof **funcListp);
    assert(*funcListp);
  } else if(*n == *s) {
    *funcListp = realloc(*funcListp, (*s *= 2) * sizeof **funcListp);
    assert(*funcListp);
  }
  (*funcListp)[(*n)++] = func;
} 

Référencé par callAllWithState().

callAllWithState()

static void callAllWithState ( GL4DHanime *  animations, int  state  )

static

Parcourt un tableau d'animations (possiblement dupliquées) et les appelle une et une seule fois avec l'état state.

Paramètres

animations	tableau d'animations se terminant par un élément dont le champ first est à NULL.
state	état à utiliser pour chaque appel.

                                                                 {
  int n = 0, s = 0;
  void **called = NULL;
  assert(animations);
  while(animations->first) {
    if(!in(animations->first, called, n)) {
      animations->first(state);
      add(animations->first, &called, &n, &s);
    }
    if(animations->last && !in(animations->last, called, n)) {
      animations->last(state);
      add(animations->last, &called, &n, &s);
    }
    if(animations->transition && !in(animations->transition, called, n)) {
      animations->transition(NULL, NULL, 0, 0, state);
      add(animations->transition, &called, &n, &s);
    }
    animations++;
  }
  if(called)
    free(called);
}

Références add(), GL4DHanime::first, in(), GL4DHanime::last, et GL4DHanime::transition.

Référencé par gl4dhClean(), et gl4dhInit().

drawOrUpdateWithAudio()

static void drawOrUpdateWithAudio ( GL4DHanime *  animations, int  state  )

static

joue ou met à jour parmi les animations passées en argument l'animation en cours (devant être jouée/mise à jour au temps t).

Paramètres

animations	tableau d'animations se terminant par un élément dont le champ first est à NULL.
state	état devant être appliqué : jouer (GL4DH_DRAW) ou mettre à jour (GL4DH_UPDATE_WITH_AUDIO)

                                                                      {
  int i;
  static int cur = 0;
  Uint32 t = 0, at = 0;
  if(!animations[cur].first)
    goto noMoreAnimationsFlag;
  for(i = 0; i < cur; i++) at += animations[i].time;
  t = gl4dhGetTicks() - at;
  if(t >= animations[cur].time) {
    t -= animations[cur].time;
    cur = (cur + 1);
    if(!animations[cur].first)
      goto noMoreAnimationsFlag;
  }
  if(animations[cur].transition)
    animations[cur].transition(animations[cur].first, animations[cur].last, animations[cur].time, t, state);
  else
    animations[cur].first(state);
  return;
 noMoreAnimationsFlag:
  if(state == GL4DH_DRAW) 
    exit(0); // mettre cur = 0; pour tourner en boucle
}

Références GL4DHanime::first, GL4DH_DRAW, gl4dhGetTicks(), GL4DHanime::time, et GL4DHanime::transition.

Référencé par gl4dhDraw(), et gl4dhUpdateWithAudio().

gl4dhClean()

void gl4dhClean

(

void

)

demande l'état libération à tous les éléments du tableau d'animations.

                      {
  if(_animations) {
    callAllWithState(_animations, GL4DH_FREE);
    _animations = NULL;
  }
  if(_wTexId) {
    glDeleteTextures(1, &_wTexId);
    _wTexId = 0;
  }
  if(_wdTexId) {
    glDeleteTextures(1, &_wdTexId);
    _wdTexId = 0;
  }
  if(_fbo) {
    glDeleteFramebuffers(1, &_fbo);
    _fbo = 0;
  }
}

Références _animations, _fbo, _wdTexId, _wTexId, callAllWithState(), et GL4DH_FREE.

Référencé par gl4duClean().

gl4dhDraw()

void gl4dhDraw

(

void

)

joue parmi les animations passées en argument l'animation en cours (devant être jouée au temps t).

                     {
  int vp[4];
  glGetIntegerv(GL_VIEWPORT, vp);
  glBindFramebuffer(GL_FRAMEBUFFER, _fbo);
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,  _wTexId,  0);
  drawOrUpdateWithAudio(_animations, GL4DH_DRAW);
 
  glUseProgram(0);
 
  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
  glBlitFramebuffer(0, 0, _w, _h, vp[0], vp[1], vp[0] + vp[2], vp[1] + vp[3], GL_COLOR_BUFFER_BIT, GL_LINEAR);
  glBlitFramebuffer(0, 0, _w, _h, vp[0], vp[1], vp[0] + vp[2], vp[1] + vp[3], GL_DEPTH_BUFFER_BIT, GL_NEAREST);
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
}

Références _animations, _fbo, _h, _w, _wTexId, drawOrUpdateWithAudio(), et GL4DH_DRAW.

gl4dhGetTicks()

Uint32 gl4dhGetTicks

(

void

)

renvoie le nombre de milisecondes passée depuis le top-départ donné par gl4dhStartingSignal.

                           {
  return SDL_GetTicks() - _startingTime;
}

Références _startingTime.

Référencé par drawOrUpdateWithAudio().

gl4dhInit()

void gl4dhInit	(	GL4DHanime *	animations,
		int	w,
		int	h,
		void(*)(void)	callBeforeAllAnimationsInit
	)

Demande l'état initialisation à tous les éléments du tableau d'animations.

Paramètres

animations	tableau d'animations se terminant par un élément dont le champ first est à NULL.
w	largeur de la texture dans laquelle sont réalisées les animations.
h	hauteur de la texture dans laquelle sont réalisées les animations.
callBeforeAllAnimationsInit	fonction à appeler avant le lancement des inits d'animations. Ce paramètre peut-etre NULL si rien n'est fait avant.

                                                                                                 {
  _animations = animations;
  _w = w; _h = h;
  if(!_fbo)
    glGenFramebuffers(1, &_fbo);
  if(!_wTexId)
    glGenTextures(1, &_wTexId);
  glBindTexture(GL_TEXTURE_2D, _wTexId);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
  if(!_wdTexId)
    glGenTextures(1, &_wdTexId);
  glBindTexture(GL_TEXTURE_2D, _wdTexId);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, w, h, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
  glBindTexture(GL_TEXTURE_2D, 0);
 
  glBindFramebuffer(GL_FRAMEBUFFER, _fbo);
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,  _wTexId,  0);
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, _wdTexId, 0);
  if(callBeforeAllAnimationsInit)
    callBeforeAllAnimationsInit();
  callAllWithState(_animations, GL4DH_INIT);
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

Références _animations, _fbo, _h, _w, _wdTexId, _wTexId, callAllWithState(), et GL4DH_INIT.

gl4dhStartingSignal()

void gl4dhStartingSignal

(

void

)

donne le top-départ de la démo. Cette fonction doit être appelée juste avant le début de la boucle infinie d'affichage (soit juste avant le premier GL4DH_DRAW obtenu en appelant gl4dhDraw).

                               {
  _startingTime = SDL_GetTicks();
}

Références _startingTime.

gl4dhUpdateWithAudio()

void gl4dhUpdateWithAudio

(

void

)

met à jour parmi les animations passées en argument l'animation en cours.

                                {
  drawOrUpdateWithAudio(_animations, GL4DH_UPDATE_WITH_AUDIO);
}

Références _animations, drawOrUpdateWithAudio(), et GL4DH_UPDATE_WITH_AUDIO.

in()

static int in ( void *  func, void **  funcList, int  n  )

static

regarde si le pointeur func est un élément du tableau funcList

Paramètres

func	un élément dont il faut tester la présence.
funcList	un tableau d'éléments.
n	le nombre d'éléments dans funcList.

Renvoie

vrai si l'élément est présent, faux sinon.

                                                  {
  int i;
  for(i = 0; i < n; i++)
    if(func == funcList[i])
      return 1;
  return 0;
}

Référencé par blurffunc(), blurfinit(), callAllWithState(), cannyffunc(), cannyfinit(), fractalPaintingffunc(), fractalPaintingfinit(), gl4dfBlur(), gl4dfCanny(), gl4dfConvTex2Frame(), gl4dfConvTex2Tex(), gl4dfMCMD(), gl4dfMedian(), gl4dfScattering(), gl4dfSobel(), gl4dqCreatePurFromPoint(), gl4dqRotatePoint(), medianffunc(), medianfinit(), mv(), scatteringffunc(), scatteringfinit(), sobelffunc(), et sobelfinit().

Documentation des variables

_animations

GL4DHanime* _animations = NULL

static

pointeur vers le tableau d'animations passé à l'init avec gl4dhInit

Référencé par gl4dhClean(), gl4dhDraw(), gl4dhInit(), et gl4dhUpdateWithAudio().

_fbo

GLuint _fbo = 0

static

identifiant du framebuffer utilisé pour dessiner les animations

Référencé par gl4dhClean(), gl4dhDraw(), et gl4dhInit().

_h

int _h = 1

static

Référencé par gl4dhDraw(), et gl4dhInit().

_startingTime

Uint32 _startingTime = 0

static

Référencé par gl4dhGetTicks(), et gl4dhStartingSignal().

_w

int _w = 1

static

largeur et hauteur de la texture _wTexId liée en écriture au framebuffer _fbo

Référencé par gl4dhDraw(), et gl4dhInit().

_wdTexId

GLuint _wdTexId = 0

static

Référencé par gl4dhClean(), et gl4dhInit().

_wTexId

GLuint _wTexId = 0

static

identifiant de la texture liée en écriture au framebuffer _fbo (la texture dans laquelle les animations sont dessinées)

Référencé par gl4dhClean(), gl4dhDraw(), et gl4dhInit().