Référence du fichier gl4duw_SDL2.c

Fonctions haut-niveau de GL4Dummies pour la gestion des fenêtres avec SDL2. Plus de détails...

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "bin_tree.h"
#include "gl4duw_SDL2.h"

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

Aller au code source de ce fichier.

Structures de données
struct	window_t
	structure de données englobant le nom de la fenêtre, le pointeur vers sa structure SDL, son contexte OpenGL et les pointeurs vers ses fonctions callback. Plus de détails...

Définitions de type
typedef struct window_t	window_t
	type lié à la structure de données struct window_t. Plus de détails...

Fonctions
static int	initGL4DUW (int argc, char **argv)
	initialise SDL et GL4Dummies. Plus de détails...
static window_t *	newWindow (const char *name, SDL_Window *win, SDL_GLContext oglc)
	créé la fenêtre de type window_t. Plus de détails...
static int	windowCmpFunc (const void *w1, const void *w2)
	fonction de comparaison de deux fenêtres window_t en fonction du nom pour insertion dans l'arbre binaire. Plus de détails...
static void	freeWindows (void *window)
	libère la fenêtre Plus de détails...
static void	quit (void)
	est appelée au moment de sortir du programme (atexit), elle libère la (les) fenêtre(s) SDL et le(s) contexte(s) OpenGL lié(s). Plus de détails...
static void	resize (window_t *win)
	est appelée au moment du redimensionnement de la fenêtre win, elle récupère la taille de la fenêtre à l'aide de SDL_GetWindowSize puis appelle la callback resize de la fenêtre. Plus de détails...
static void	manageEvents (void)
	dispatche les événement selon le type en utilisant les callbacks de la fenêtre ayant le focus. Plus de détails...
static void	mainLoopBody (void *window, void **data)
	corps de la boucle principale événement/simulation/affichage Plus de détails...
static void	fake_resize (int w, int h)
	fonction fictive liée au callback de resize de la fenêtre. Plus de détails...
static void	fake_keydown (int keycode)
	fonction fictive liée au callback de touche clavier enfoncée. Plus de détails...
static void	fake_keyup (int keycode)
	fonction fictive liée au callback de touche clavier relachée. Plus de détails...
static void	fake_mousebutton (int button, int state, int x, int y)
	fonction fictive liée au callback d'un bouton de souris enfoncé ou relaché. Plus de détails...
static void	fake_mousemotion (int x, int y)
	fonction fictive liée au callback du mouvement de la souris avec bouton enfoncé. Plus de détails...
static void	fake_passivemousemotion (int x, int y)
	fonction fictive liée au callback du mouvement de la souris sans bouton enfoncé. Plus de détails...
static void	fake_idle (void)
	fonction fictive liée au callback de l'état idle de la fenêtre. Plus de détails...
static void	fake_display (void)
	fonction fictive liée au callback de display. Plus de détails...
static int	fake_catchSDL_Event (SDL_Event *event)
	fonction fictive liée au callback de catchSDL_Event. Plus de détails...
void	gl4duwSetGLAttributes (int glMajorVersion, int glMinorVersion, int glProfileMask, int glDoubleBuffer, int glDepthSize)
	modifie les paramètre par défaut du contexte OpenGL. Plus de détails...
GLboolean	gl4duwCreateWindow (int argc, char **argv, const char *title, int x, int y, int width, int height, Uint32 wflags)
	créé une fenêtre SDL avec un contexte OpenGL. Plus de détails...
SDL_Window *	gl4duwGetSDL_Window (void)
	retourne le pointeur vers la structure SDL_Window de la fenêtre courante (suite à un gl4duwCreateWindow ou gl4duwBindWindow ...). Plus de détails...
GLboolean	gl4duwBindWindow (const char *title)
	recherche et positionne "courant" une fenêtre en fonction de son titre. Plus de détails...
void	gl4duwMainLoop (void)
	boucle principale événement/simulation/affichage Plus de détails...
void	gl4duwResizeFunc (void(*func)(int width, int height))
	affecte la fonction appelée lors du resize. Plus de détails...
void	gl4duwKeyDownFunc (void(*func)(int keycode))
	affecte la fonction appelée lors de l'événement key down. Plus de détails...
void	gl4duwKeyUpFunc (void(*func)(int keycode))
	affecte la fonction appelée lors de l'événement key up. Plus de détails...
void	gl4duwMouseFunc (void(*func)(int button, int state, int x, int y))
	affecte la fonction appelée lorsqu'un utilisateur appuie ou relache un bouton de la souris dans la fenêtre. Plus de détails...
void	gl4duwMotionFunc (void(*func)(int x, int y))
	affecte la fonction appelée lorsqu'un utilisateur déplace la souris dans la fenêtre tout en ayant un ou plusieurs boutons enfoncés. Plus de détails...
void	gl4duwPassiveMotionFunc (void(*func)(int x, int y))
	affecte la fonction appelée lorsqu'un utilisateur déplace la souris dans la fenêtre sans qu'aucun bouton ne soit enfoncé Plus de détails...
void	gl4duwIdleFunc (void(*func)(void))
	affecte la fonction appelée lors de l'idle (calcul/simulation avant affichage). Plus de détails...
void	gl4duwDisplayFunc (void(*func)(void))
	affecte la fonction appelée lors de l'affichage. Plus de détails...
void	gl4duwCatchSDL_EventFunc (int(*func)(SDL_Event *))
	affecte la fonction appelée lors de la gestion manuelle par le programmeur des événements SDL. Plus de détails...
void	gl4duwEnableManageEvents (void)
void	gl4duwDisableManageEvents (void)
void	gl4duwGetWindowSize (int *w, int *h)
	récupère la largeur et la hauteur de la fenêtre courante. Plus de détails...

Variables
static bin_tree_t *	_btWindows = NULL
	arbre binaire contenant l'ensemble des fenêtres créées. Plus de détails...
static bin_tree_t **	_lastWindown = NULL
	adresse du pointeur vers le noeud référençant la dernière fenêtre créée. Plus de détails...
static window_t *	_curWindow = NULL
	la fenêtre window_t courante (coté code, Plus de détails...
static window_t *	_focusedWindow = NULL
	la fenêtre window_t ayant le focus ( Plus de détails...
static int	_glMajorVersion = 3
	les paramètres par défaut du contexte OpenGL Plus de détails...
static int	_glMinorVersion = 2
static int	_glProfileMask = SDL_GL_CONTEXT_PROFILE_CORE
static int	_glDoubleBuffer = 1
static int	_glDepthSize = 16
static int	_hasInit = 0
	flag permettant de savoir si la lib a déjà été initialisée Plus de détails...
static int	_hasManageEvents = 1
	flag permettant de savoir si la lib gère les événements Plus de détails...

Description détaillée

Fonctions haut-niveau de GL4Dummies pour la gestion des fenêtres avec SDL2.

Auteur

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

Date

Februry 01 2016

Définition dans le fichier gl4duw_SDL2.c.

Documentation des définitions de type

window_t

typedef struct window_t window_t

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

Documentation des fonctions

fake_catchSDL_Event()

static int fake_catchSDL_Event ( SDL_Event *  event )

inlinestatic

fonction fictive liée au callback de catchSDL_Event.

                                                          {
  (void)event; /* silenced warning */
  return 0;
}

Référencé par gl4duwCatchSDL_EventFunc(), et newWindow().

fake_display()

static void fake_display ( void  )

inlinestatic

fonction fictive liée au callback de display.

{}

Référencé par gl4duwDisplayFunc(), et newWindow().

fake_idle()

static void fake_idle ( void  )

inlinestatic

fonction fictive liée au callback de l'état idle de la fenêtre.

{}

Référencé par gl4duwIdleFunc(), et newWindow().

fake_keydown()

static void fake_keydown ( int  keycode )

inlinestatic

fonction fictive liée au callback de touche clavier enfoncée.

                                             {
  (void)keycode; /* silenced warning */
}

Référencé par gl4duwKeyDownFunc(), et newWindow().

fake_keyup()

static void fake_keyup ( int  keycode )

inlinestatic

fonction fictive liée au callback de touche clavier relachée.

                                           {
  (void)keycode; /* silenced warning */
}

Référencé par gl4duwKeyUpFunc(), et newWindow().

fake_mousebutton()

static void fake_mousebutton ( int  button, int  state, int  x, int  y  )

inlinestatic

fonction fictive liée au callback d'un bouton de souris enfoncé ou relaché.

                                                                         {
  (void)button; /* silenced warning */
  (void)state;  /* silenced warning */
  (void)x;      /* silenced warning */
  (void)y;      /* silenced warning */
}

Référencé par gl4duwMouseFunc(), et newWindow().

fake_mousemotion()

static void fake_mousemotion ( int  x, int  y  )

inlinestatic

fonction fictive liée au callback du mouvement de la souris avec bouton enfoncé.

                                                  {
  (void)x; /* silenced warning */
  (void)y; /* silenced warning */
}

Référencé par gl4duwMotionFunc(), et newWindow().

fake_passivemousemotion()

static void fake_passivemousemotion ( int  x, int  y  )

inlinestatic

fonction fictive liée au callback du mouvement de la souris sans bouton enfoncé.

                                                         {
  (void)x; /* silenced warning */
  (void)y; /* silenced warning */
}

Référencé par gl4duwPassiveMotionFunc(), et newWindow().

fake_resize()

static void fake_resize ( int  w, int  h  )

inlinestatic

fonction fictive liée au callback de resize de la fenêtre.

                                             {
  (void)w; /* silenced warning */
  (void)h; /* silenced warning */
}

Référencé par gl4duwResizeFunc(), et newWindow().

freeWindows()

static void freeWindows ( void *  window )

inlinestatic

libère la fenêtre

Paramètres

window

est la fenêtre de type window_t.

                                              {
  free(((window_t *)window)->name);
  SDL_GL_DeleteContext(((window_t *)window)->glContext);
  SDL_DestroyWindow(((window_t *)window)->window);
  free(window);
}

Référencé par quit().

gl4duwBindWindow()

GLboolean gl4duwBindWindow

(

const char *

title

)

recherche et positionne "courant" une fenêtre en fonction de son titre.

La fenêtre courante est celle qui est affectée par les appelles des fonctions telles que gl4duwResizeFunc, gl4duwKeyDownFunc, gl4duwKeyUpFunc, gl4duwIdleFunc, gl4duwDisplayFunc.

Paramètres

title

titre de la fenêtre SDL recherchée.

Renvoie

GL_TRUE en cas de réussite, GL_FALSE en cas d'échec.

                                               {
  window_t wt = {(char *)title, NULL, 0,    NULL, NULL, NULL,
                 NULL,          NULL, NULL, NULL, NULL, NULL};
  pair_t pair;
  pair = btFind(&_btWindows, &wt, windowCmpFunc);
  if(pair.compResult)
    return GL_FALSE;
  _curWindow = (window_t *)((*(bin_tree_t **)pair.ptr)->data);
  SDL_GL_MakeCurrent(_curWindow->window, _curWindow->glContext);
  return GL_TRUE;
}

Références _btWindows, _curWindow, btFind(), pair_t::compResult, window_t::glContext, pair_t::ptr, window_t::window, et windowCmpFunc().

gl4duwCatchSDL_EventFunc()

void gl4duwCatchSDL_EventFunc

(

int(*)(SDL_Event *)

func

)

affecte la fonction appelée lors de la gestion manuelle par le programmeur des événements SDL.

Paramètres

func

pointeur vers fonction utilisateur à appeler pour la gestion manuelle des événements SDL. Cette fonction reçoit le pointeur vers l'événement bas-niveau SDL à traiter. Si la fonction utilisateur traitant l'événement renvoie une valeur non nulle ceci implique que l'événement est traité et ne doit plus figurer dans la liste des événements à traiter, sinon, potentiellement l'événement pourra être traité par une des "autres" fonctions "événements" spécialisées.

                                                        {
  _curWindow->catchSDL_Event = func ? func : fake_catchSDL_Event;
}

Références _curWindow, window_t::catchSDL_Event, et fake_catchSDL_Event().

gl4duwCreateWindow()

GLboolean gl4duwCreateWindow	(	int	argc,
		char **	argv,
		const char *	title,
		int	x,
		int	y,
		int	width,
		int	height,
		Uint32	wflags
	)

créé une fenêtre SDL avec un contexte OpenGL.

Pour modifier les valeurs utilisée par le contexte OpenGL, utiliser la fonction gl4duwSetGLAttributes.

Paramètres

argc	nombre d'arguments passés au programme (premier argument de la fonction main).
argv	liste des arguments passés au programme (second argument de la fonction main).
title	titre de la fenêtre SDL à créer.
x	la postion x de la fenêtre à créer ou GL4DW_POS_CENTERED, ou GL4DW_POS_UNDEFINED.
y	la postion y de la fenêtre à créer ou GL4DW_POS_CENTERED, ou GL4DW_POS_UNDEFINED.
width	la largeur de la fenêtre à créer.
height	la hauteur de la fenêtre à créer.
wflags	des options sur la fenêtre à créer. Peut être 0 ou une ou toute combinaison (via OR "|") de : GL4DW_FULLSCREEN, GL4DW_FULLSCREEN_DESKTOP, GL4DW_OPENGL, GL4DW_HIDDEN, GL4DW_BORDERLESS, GL4DW_RESIZABLE, GL4DW_MINIMIZED, GL4DW_MAXIMIZED, GL4DW_INPUT_GRABBED, GL4DW_ALLOW_HIGHDPI.

Renvoie

GL_TRUE en cas de réussite, GL_FALSE en cas d'échec.

Voir également

gl4duwSetGLAttributes

SDL_CreateWindow

                                                     {
  (void)x; /* silenced warning */
  (void)y; /* silenced warning */
  SDL_Window * win = NULL;
  SDL_GLContext oglc = NULL;
  window_t wt = {(char *)title, NULL, 0,    NULL, NULL, NULL,
                 NULL,          NULL, NULL, NULL, NULL, NULL};
  pair_t pair;
  static int ft = 1;
  pair = btFind(&_btWindows, &wt, windowCmpFunc);
  if(!pair.compResult) {
    fprintf(stderr, "%s (%d): %s:\n\tErreur lors de la creation de la fenetre SDL : une fenetre portant le meme nom existe deja\n",
        __FILE__, __LINE__, __func__);
    return GL_FALSE;
  }
  initGL4DUW(argc, argv);
  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, _glMajorVersion);
  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, _glMinorVersion);
  SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, _glProfileMask);
  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, _glDoubleBuffer);
  SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, _glDepthSize);
  if( (win = SDL_CreateWindow(title, GL4DW_POS_CENTERED, GL4DW_POS_CENTERED,
                  width, height, GL4DW_OPENGL | wflags)) == NULL ) {
    fprintf(stderr, "%s (%d): %s:\n\tErreur lors de la creation de la fenetre SDL : %s",
        __FILE__, __LINE__, __func__, SDL_GetError());
    return GL_FALSE;
  }
  if( (oglc = SDL_GL_CreateContext(win)) == NULL ) {
    SDL_DestroyWindow(win);
    fprintf(stderr, "%s (%d): %s:\n\tErreur lors de la creation du contexte OpenGL : %s",
        __FILE__, __LINE__, __func__, SDL_GetError());
    return GL_FALSE;
  }
  _curWindow = newWindow(title, win, oglc);
  _lastWindown = (bin_tree_t **)(btInsert((bin_tree_t **)(pair.ptr), _curWindow, windowCmpFunc).ptr);
  if(ft) {
    fprintf(stderr, "OpenGL version: %s\n", glGetString(GL_VERSION));
    fprintf(stderr, "Supported shaders version: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
    ft = 0;
  }
  return GL_TRUE;
}

Références _btWindows, _curWindow, _glDepthSize, _glDoubleBuffer, _glMajorVersion, _glMinorVersion, _glProfileMask, _lastWindown, btFind(), btInsert(), pair_t::compResult, GL4DW_OPENGL, GL4DW_POS_CENTERED, initGL4DUW(), newWindow(), pair_t::ptr, et windowCmpFunc().

gl4duwDisableManageEvents()

void gl4duwDisableManageEvents

(

void

)

                                     {
  _hasManageEvents = 0;
}

Références _hasManageEvents.

gl4duwDisplayFunc()

void gl4duwDisplayFunc

(

void(*)(void)

func

)

affecte la fonction appelée lors de l'affichage.

Paramètres

func	pointeur vers fonction utilisateur à appeler pour réaliser le display (dessin).

                                           {
  _curWindow->display = func ? func : fake_display;
}

Références _curWindow, window_t::display, et fake_display().

gl4duwEnableManageEvents()

void gl4duwEnableManageEvents

(

void

)

                                    {
  _hasManageEvents = 1;
}

Références _hasManageEvents.

gl4duwGetSDL_Window()

SDL_Window* gl4duwGetSDL_Window

(

void

)

retourne le pointeur vers la structure SDL_Window de la fenêtre courante (suite à un gl4duwCreateWindow ou gl4duwBindWindow ...).

Renvoie

le pointeur vers la structure SDL_Window de la fenêtre courante.

                                       {
  return _curWindow ? _curWindow->window : NULL;
}

Références _curWindow, et window_t::window.

gl4duwGetWindowSize()

void gl4duwGetWindowSize	(	int *	w,
		int *	h
	)

récupère la largeur et la hauteur de la fenêtre courante.

Paramètres

w	pointeur vers entier où sera renseignée la largeur de la fenêtre.
h	pointeur vers entier où sera renseignée la hauteur de la fenêtre.

                                           {
  SDL_GetWindowSize(_curWindow->window, w, h);
}

Références _curWindow, et window_t::window.

gl4duwIdleFunc()

void gl4duwIdleFunc

(

void(*)(void)

func

)

affecte la fonction appelée lors de l'idle (calcul/simulation avant affichage).

Paramètres

func	pointeur vers fonction utilisateur à appeler pour réaliser la phase calcul/simulation.

                                        {
  _curWindow->idle = func ? func : fake_idle;
}

Références _curWindow, fake_idle(), et window_t::idle.

gl4duwKeyDownFunc()

void gl4duwKeyDownFunc

(

void(*)(int keycode)

func

)

affecte la fonction appelée lors de l'événement key down.

Paramètres

func	pointeur vers fonction utilisateur à appeler lors du de l'événement keydown. Cette dernière reçoit en paramètre le code keycode de la touche enfoncée (voir les macros GL4DK_xxx).

                                                  {
  _curWindow->keydown = func ? func : fake_keydown;
}

Références _curWindow, fake_keydown(), et window_t::keydown.

gl4duwKeyUpFunc()

void gl4duwKeyUpFunc

(

void(*)(int keycode)

func

)

affecte la fonction appelée lors de l'événement key up.

Paramètres

func	pointeur vers fonction utilisateur à appeler lors du de l'événement keyup. Cette dernière reçoit en paramètre le code keycode de la touche relachée (voir les macros GL4DK_xxx).

                                                {
  _curWindow->keyup = func ? func : fake_keyup;
}

Références _curWindow, fake_keyup(), et window_t::keyup.

gl4duwMainLoop()

void gl4duwMainLoop

(

void

)

boucle principale événement/simulation/affichage

                          {
  for(;;) {
    if(_hasManageEvents)
      manageEvents();
    btForAll(_btWindows, mainLoopBody, NULL);
    SDL_GL_MakeCurrent(_curWindow->window, _curWindow->glContext);
    gl4duPrintFPS(stderr);
    gl4duUpdateShaders();
  }
}

Références _btWindows, _curWindow, _hasManageEvents, btForAll(), gl4duPrintFPS(), gl4duUpdateShaders(), window_t::glContext, mainLoopBody(), manageEvents(), et window_t::window.

gl4duwMotionFunc()

void gl4duwMotionFunc

(

void(*)(int x, int y)

func

)

affecte la fonction appelée lorsqu'un utilisateur déplace la souris dans la fenêtre tout en ayant un ou plusieurs boutons enfoncés.

Paramètres

func	pointeur vers fonction utilisateur à appeler lors du déplacement "drag" de la souris. Cette dernière reçoit en paramètre : l'abscisse x de la souris et son ordonée y.

                                                  {
  _curWindow->mousemotion = func ? func : fake_mousemotion;
}

Références _curWindow, fake_mousemotion(), et window_t::mousemotion.

gl4duwMouseFunc()

void gl4duwMouseFunc

(

void(*)(int button, int state, int x, int y)

func

)

affecte la fonction appelée lorsqu'un utilisateur appuie ou relache un bouton de la souris dans la fenêtre.

Paramètres

func	pointeur vers fonction utilisateur à appeler lors du de l'événement lié à la souris. Cette dernière reçoit en paramètre : le code button du bouton concerné (voir les macros GL4D_MOUSE_xxx), l'état state du bouton, l'abscisse x de la souris et son ordonée y.

                                                                        {
  _curWindow->mousebutton = func ? func : fake_mousebutton;
}

Références _curWindow, fake_mousebutton(), et window_t::mousebutton.

gl4duwPassiveMotionFunc()

void gl4duwPassiveMotionFunc

(

void(*)(int x, int y)

func

)

affecte la fonction appelée lorsqu'un utilisateur déplace la souris dans la fenêtre sans qu'aucun bouton ne soit enfoncé

Paramètres

func	pointeur vers fonction utilisateur à appeler lors du "drop" de la souris. Cette dernière reçoit en paramètre : l'abscisse x de la souris et son ordonée y.

                                                         {
  _curWindow->passivemousemotion = func ? func : fake_passivemousemotion;
}

Références _curWindow, fake_passivemousemotion(), et window_t::passivemousemotion.

gl4duwResizeFunc()

void gl4duwResizeFunc

(

void(*)(int width, int height)

func

)

affecte la fonction appelée lors du resize.

Paramètres

func	pointeur vers fonction utilisateur à appeler lors du resize. Cette dernière reçoit en paramètre la largeur width et la hauteur height de la fenêtre.

                                                           {
  _curWindow->resize = func ? func : fake_resize;
}

Références _curWindow, fake_resize(), et window_t::resize.

gl4duwSetGLAttributes()

void gl4duwSetGLAttributes	(	int	glMajorVersion,
		int	glMinorVersion,
		int	glProfileMask,
		int	glDoubleBuffer,
		int	glDepthSize
	)

modifie les paramètre par défaut du contexte OpenGL.

Cette fonction est à appeler avant gl4duwCreateWindow si vous souhaitez que ses paramètres soient pris en compte. Si vous souhaitez modifier plus de paramètres voir la fonction SDL_GL_SetAttribute.

Paramètres

glMajorVersion	version majeure d'OpenGL, par défaut vaut 3.
glMinorVersion	version mineure d'OpenGL, par défaut vaut 2.
glProfileMask	modifie le profile d'OpenGL, par défaut vaut GL4DW_CONTEXT_PROFILE_CORE mais peut aussi prendre GL4DW_CONTEXT_PROFILE_COMPATIBILITY, GL4DW_CONTEXT_PROFILE_ES.
glDoubleBuffer	modifie l'état actif ou non du double buffer, par défaut vaut 1 (vrai).
glDepthSize	modifie la dimension (nombre de bits utilisés) du buffer de profondeur, par défaut vaut 16.

Voir également

gl4duwCreateWindow

                                                                                                                           {
  _glMajorVersion = glMajorVersion;
  _glMinorVersion = glMinorVersion;
  _glProfileMask  = glProfileMask;
  _glDoubleBuffer = glDoubleBuffer;
  _glDepthSize    = glDepthSize;
}

Références _glDepthSize, _glDoubleBuffer, _glMajorVersion, _glMinorVersion, et _glProfileMask.

initGL4DUW()

static int initGL4DUW ( int  argc, char **  argv  )

inlinestatic

initialise SDL et GL4Dummies.

Paramètres

argc	nombre d'arguments passés au programme (premier argument de la fonction main).
argv	liste des arguments passés au programme (second argument de la fonction main).

Renvoie

0 en cas d'échec, !=0 sinon.

                                                     {
  if(_hasInit) return 1;
  if(SDL_Init(SDL_INIT_VIDEO) < 0) {
    fprintf(stderr, "%s (%d): %s:\n\tErreur lors de l'initialisation de SDL :  %s",
        __FILE__, __LINE__, __func__, SDL_GetError());
    return 0;
  }
  atexit(SDL_Quit);
  atexit(quit);
  gl4duInit(argc, argv);
  _hasInit = 1;
  return 1;
}

Références _hasInit, gl4duInit(), et quit().

Référencé par gl4duwCreateWindow().

mainLoopBody()

static void mainLoopBody ( void *  window, void **  data  )

inlinestatic

corps de la boucle principale événement/simulation/affichage

                                                             {
  (void)data; /* warning silenced */
  window_t * w = (window_t *)window;
  SDL_GL_MakeCurrent(w->window, w->glContext);
  w->idle();
  w->display();
  SDL_GL_SwapWindow(w->window);
}

Références window_t::display, window_t::glContext, window_t::idle, et window_t::window.

Référencé par gl4duwMainLoop().

manageEvents()

static void manageEvents ( void  )

inlinestatic

dispatche les événement selon le type en utilisant les callbacks de la fenêtre ayant le focus.

                                      {
  SDL_Event event;
  while(SDL_PollEvent(&event)) {
    if(_focusedWindow && _focusedWindow->catchSDL_Event(&event))
      continue;
    switch (event.type) {
    case SDL_KEYDOWN:
      if(_focusedWindow)
    _focusedWindow->keydown(event.key.keysym.sym);
      break;
    case SDL_KEYUP:
      if(_focusedWindow)
    _focusedWindow->keyup(event.key.keysym.sym);
      break;
    case SDL_MOUSEBUTTONDOWN:
    case SDL_MOUSEBUTTONUP:
      if(_focusedWindow)
    _focusedWindow->mousebutton(event.button.button, event.button.state, event.button.x, event.button.y);
      break;
    case SDL_MOUSEMOTION:
      if (_focusedWindow){
        if (event.motion.state & (SDL_BUTTON_LMASK | SDL_BUTTON_MMASK | SDL_BUTTON_RMASK))
          _focusedWindow->mousemotion(event.motion.x, event.motion.y);
        else
          _focusedWindow->passivemousemotion(event.motion.x, event.motion.y);
      }
      break;
    case SDL_WINDOWEVENT: {
      SDL_Window * focusedw = SDL_GetWindowFromID(event.window.windowID);
      window_t wt = {(char *)SDL_GetWindowTitle(focusedw),
                     NULL,
                     0,
                     NULL,
                     NULL,
                     NULL,
                     NULL,
                     NULL,
                     NULL,
                     NULL,
                     NULL,
                     NULL};
      pair_t pair;
      pair = btFind(&_btWindows, &wt, windowCmpFunc);
      _focusedWindow = (window_t *)(*(bin_tree_t **)(pair.ptr))->data;
      switch (event.window.event) {
      case SDL_WINDOWEVENT_RESIZED:
    resize(_focusedWindow);
    break;
      case SDL_WINDOWEVENT_CLOSE:
    event.type = SDL_QUIT;
    SDL_PushEvent(&event);
    break;
      }
      break;
    }
    case SDL_QUIT:
      exit(0);
    }
  }
}

Références _btWindows, _focusedWindow, btFind(), window_t::catchSDL_Event, window_t::keydown, window_t::keyup, window_t::mousebutton, window_t::mousemotion, window_t::passivemousemotion, pair_t::ptr, resize(), et windowCmpFunc().

Référencé par gl4duwMainLoop().

newWindow()

static window_t * newWindow ( const char *  name, SDL_Window *  win, SDL_GLContext  oglc  )

inlinestatic

créé la fenêtre de type window_t.

Paramètres

name	titre de la fenêtre
win	le pointeur vers la structure de fenêtre SDL
oglc	la référence vers le contexte OpenGL lié à la fenêtre

Renvoie

le pointeur vers la fenêtre de type window_t créée

                                                                                            {
  window_t * w = malloc(sizeof *w);
  assert(w);
  w->name = strdup(name);
  w->window = win;
  w->glContext = oglc;
  w->resize = fake_resize;
  w->keydown = fake_keydown;
  w->keyup = fake_keyup;
  w->mousebutton = fake_mousebutton;
  w->mousemotion = fake_mousemotion;
  w->passivemousemotion = fake_passivemousemotion;
  w->idle = fake_idle;
  w->display = fake_display;
  w->catchSDL_Event = fake_catchSDL_Event;
  return w;
}

Références window_t::catchSDL_Event, window_t::display, fake_catchSDL_Event(), fake_display(), fake_idle(), fake_keydown(), fake_keyup(), fake_mousebutton(), fake_mousemotion(), fake_passivemousemotion(), fake_resize(), window_t::glContext, window_t::idle, window_t::keydown, window_t::keyup, window_t::mousebutton, window_t::mousemotion, window_t::name, window_t::passivemousemotion, window_t::resize, et window_t::window.

Référencé par gl4duwCreateWindow().

quit()

static void quit ( void  )

inlinestatic

est appelée au moment de sortir du programme (atexit), elle libère la (les) fenêtre(s) SDL et le(s) contexte(s) OpenGL lié(s).

                              {
  btFree(&_btWindows, freeWindows);
}

Références _btWindows, btFree(), et freeWindows().

Référencé par initGL4DUW().

resize()

static void resize ( window_t *  win )

inlinestatic

est appelée au moment du redimensionnement de la fenêtre win, elle récupère la taille de la fenêtre à l'aide de SDL_GetWindowSize puis appelle la callback resize de la fenêtre.

Paramètres

win	la fenêtre redimensionnée

                                          {
  int w, h;
  SDL_GetWindowSize(win->window, &w, &h);
  win->resize(w, h);
}

Références window_t::resize, et window_t::window.

Référencé par manageEvents().

windowCmpFunc()

static int windowCmpFunc ( const void *  w1, const void *  w2  )

inlinestatic

fonction de comparaison de deux fenêtres window_t en fonction du nom pour insertion dans l'arbre binaire.

Cette fonction utilise strcmp.

Paramètres

w1	première fenêtre (de type window_t).
w2	seconde fenêtre (de type window_t).

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( ((window_t *)w1)->name, ((window_t *)w2)->name );
}

Référencé par gl4duwBindWindow(), gl4duwCreateWindow(), et manageEvents().

Documentation des variables

_btWindows

bin_tree_t* _btWindows = NULL

static

arbre binaire contenant l'ensemble des fenêtres créées.

Référencé par gl4duwBindWindow(), gl4duwCreateWindow(), gl4duwMainLoop(), manageEvents(), et quit().

_curWindow

window_t* _curWindow = NULL

static

la fenêtre window_t courante (coté code,

Voir également

gl4duwBindWindow).

Référencé par gl4duwBindWindow(), gl4duwCatchSDL_EventFunc(), gl4duwCreateWindow(), gl4duwDisplayFunc(), gl4duwGetSDL_Window(), gl4duwGetWindowSize(), gl4duwIdleFunc(), gl4duwKeyDownFunc(), gl4duwKeyUpFunc(), gl4duwMainLoop(), gl4duwMotionFunc(), gl4duwMouseFunc(), gl4duwPassiveMotionFunc(), et gl4duwResizeFunc().

_focusedWindow

window_t* _focusedWindow = NULL

static

la fenêtre window_t ayant le focus (

Voir également

manageEvents).

Référencé par manageEvents().

_glDepthSize

int _glDepthSize = 16

static

Référencé par gl4duwCreateWindow(), et gl4duwSetGLAttributes().

_glDoubleBuffer

int _glDoubleBuffer = 1

static

Référencé par gl4duwCreateWindow(), et gl4duwSetGLAttributes().

_glMajorVersion

int _glMajorVersion = 3

static

les paramètres par défaut du contexte OpenGL

Référencé par gl4duwCreateWindow(), et gl4duwSetGLAttributes().

_glMinorVersion

int _glMinorVersion = 2

static

Référencé par gl4duwCreateWindow(), et gl4duwSetGLAttributes().

_glProfileMask

int _glProfileMask = SDL_GL_CONTEXT_PROFILE_CORE

static

Référencé par gl4duwCreateWindow(), et gl4duwSetGLAttributes().

_hasInit

int _hasInit = 0

static

flag permettant de savoir si la lib a déjà été initialisée

Référencé par initGL4DUW().

_hasManageEvents

int _hasManageEvents = 1

static

flag permettant de savoir si la lib gère les événements

Référencé par gl4duwDisableManageEvents(), gl4duwEnableManageEvents(), et gl4duwMainLoop().

_lastWindown

bin_tree_t** _lastWindown = NULL

static

adresse du pointeur vers le noeud référençant la dernière fenêtre créée.

Référencé par gl4duwCreateWindow().