Close SDL#1

SDL#1/Sprite.cpp

@@ -1,11 +1,12 @@
 
 /* [CONSTRUCTOR] Construction de la surface vide
 =========================================================*/
-Sprite::Sprite(int x, int y, int w, int h){
+Sprite::Sprite(SDL_Rect r){
-	_surface = SDL_CreateRGBSurface(0, w, h, 32, 0, 0, 0, 0);
+	_surface = SDL_CreateRGBSurface(0, r.w, r.h, 32, 0, 0, 0, 0);
 
 	// On definit les dimensions
-	_rect = (SDL_Rect){x, y, w, h};
+	_rect   = (SDL_Rect){r.x, r.y, r.w, r.h};
+	_origin = (SDL_Rect){0, 0, r.w, r.h};
 
 	// On applique les offset
 	SDL_SetClipRect( _surface, &_rect );
@@ -16,17 +17,21 @@ Sprite::Sprite(int x, int y, int w, int h){
 
 /* [CONSTRUCTOR] Construction de la surface avec couleur
 =========================================================*/
-Sprite::Sprite(int c[], int x, int y, int w, int h){
+Sprite::Sprite(const int rgb[], SDL_Rect r){
-	_surface = SDL_CreateRGBSurface(0, w, h, 32, 0, 0, 0, 0);
+	cout << "a: [" << (sizeof(rgb)/sizeof(*rgb)) << "]" << endl;
+
+	_surface = SDL_CreateRGBSurface(0, r.w, r.h, 32, 0, 0, 0, rgb[3]);
 
 	// On recupere la couleur
-	Uint32 color = SDL_MapRGB( _surface->format, c[0], c[1], c[2]);
+	Uint32 color = SDL_MapRGBA( _surface->format, rgb[0], rgb[1], rgb[2], rgb[3]);
 
 	// On remplit avec la couleur
 	SDL_FillRect( _surface, NULL, color );
 
 	// On definit les dimensions
-	_rect = (SDL_Rect){x, y, w, h};
+	_rect   = (SDL_Rect){r.x, r.y, r.w, r.h};
+	_origin = (SDL_Rect){0, 0, r.w, r.h};
+
 	
 	// On applique les offset
 	SDL_SetClipRect( _surface, &_rect );
@@ -36,9 +41,9 @@ Sprite::Sprite(int c[], int x, int y, int w, int h){
 
 /* [CONSTRUCTOR] Construction de la surface avec image
 =========================================================*/
-Sprite::Sprite(const char url[], int x, int y, int w, int h){
+Sprite::Sprite(const char url[], SDL_Rect r, SDL_Rect clip){
+
 	/* (1) On cree la surface (avec image) */
-	// _surface = SDL_LoadBMP( url );
 	_surface = IMG_Load( url );
 
 	// Gestion erreur
@@ -46,10 +51,11 @@ Sprite::Sprite(const char url[], int x, int y, int w, int h){
 		return;
 
 	// On definit les dimensions
-	_rect = (SDL_Rect){x, y, w, h};
+	_rect   = (SDL_Rect){r.x, r.y, r.w, r.h};
+	_origin = (SDL_Rect){clip.x, clip.y, r.w, r.h};
 
-	// On applique les offset
+	// On applique le clip
-	SDL_SetClipRect( _surface, &_rect );
+	SDL_SetClipRect( _surface, &clip );
 
 }
 
@@ -58,7 +64,7 @@ Sprite::Sprite(const char url[], int x, int y, int w, int h){
 /* [APPENDTO] Ajoute le Sprite a une autre
 =========================================================*/
 void Sprite::appendTo(SDL_Surface *dest){
-	SDL_BlitSurface( _surface, NULL, dest, &_rect );
+	SDL_BlitSurface( _surface, &_origin, dest, &_rect );
 }
 
 /* [SURFACE] Retourne la surface

SDL#1/Sprite.h

@@ -20,9 +20,11 @@
 	class Sprite{
 
 		public:
-			Sprite(int x, int y, int w, int h);
+			Sprite(SDL_Rect r);
-			Sprite(int c[], int x, int y, int w, int h);
+			Sprite(const int rgb[], SDL_Rect r);
-			Sprite(const char url[], int x, int y, int w, int h);
+			Sprite(const char url[], SDL_Rect r, SDL_Rect clip);
+
+			void setImage(const char url[], int ox=0, int oy=0);
 
 			// ~Sprite();
 			void appendTo(SDL_Surface *dest);
@@ -33,6 +35,7 @@
 		private:
 			SDL_Surface *_surface;
 			SDL_Rect    _rect;
+			SDL_Rect    _origin;
 
 	};
 

SDL#1/main.cpp

@@ -27,24 +27,35 @@ int main(int argc, char* argv[]) {
 
 	/* [4] On ajoute une sprite
 	=========================================================*/
-	SpriteGroup back;
+	SpriteGroup background;
 
 	/* (1) Bloc vide */
-	back.add( new Sprite(             0,   0, 200, 200 ) );
+	background.add( new Sprite(
+		(SDL_Rect) {0, 0, 200, 200}
+	));
 	
 	/* (2) Bloc rose */
 	int pink[] = {255, 0, 255};
-	back.add( new Sprite(pink,        200, 0, 200, 200 ) );
+	cout << "a: [" << (sizeof(pink)/sizeof(*pink)) << "]" << endl;
+
+	background.add( new Sprite(
+		pink,
+		(SDL_Rect){200, 0, 200, 200}
+	));
 
 	/* (2) Bloc image */
-	back.add( new Sprite("src/1.bmp", 400, 0, 200, 200 ) );
+	background.add( new Sprite(
+		"src/1.bmp",
+		(SDL_Rect){400, 0, 200, 200},
+		(SDL_Rect){200, 200, 200, 200}
+	));
 
 
 
 
 	/* [5] On ajoute les elements + mise a jour affichage
 	=========================================================*/
-	back.appendTo( mgr->screen() );
+	background.appendTo( mgr->screen() );
 	mgr->update();
 
 

SDL#2/SDL#1/Sprite.cpp

@@ -0,0 +1,132 @@
+
+/* [CONSTRUCTOR] Construction de la surface vide
+=========================================================*/
+Sprite::Sprite(SDL_Rect r){
+	_surface = SDL_CreateRGBSurface(0, r.w, r.h, 32, 0, 0, 0, 0);
+
+	// On definit les dimensions
+	_rect   = (SDL_Rect){r.x, r.y, r.w, r.h};
+	_origin = (SDL_Rect){0, 0, r.w, r.h};
+
+	// On applique les offset
+	SDL_SetClipRect( _surface, &_rect );
+
+}
+
+
+
+/* [CONSTRUCTOR] Construction de la surface avec couleur
+=========================================================*/
+Sprite::Sprite(const int rgb[], SDL_Rect r){
+	cout << "a: [" << (sizeof(rgb)/sizeof(*rgb)) << "]" << endl;
+
+	_surface = SDL_CreateRGBSurface(0, r.w, r.h, 32, 0, 0, 0, rgb[3]);
+
+	// On recupere la couleur
+	Uint32 color = SDL_MapRGBA( _surface->format, rgb[0], rgb[1], rgb[2], rgb[3]);
+
+	// On remplit avec la couleur
+	SDL_FillRect( _surface, NULL, color );
+
+	// On definit les dimensions
+	_rect   = (SDL_Rect){r.x, r.y, r.w, r.h};
+	_origin = (SDL_Rect){0, 0, r.w, r.h};
+
+	
+	// On applique les offset
+	SDL_SetClipRect( _surface, &_rect );
+}
+
+
+
+/* [CONSTRUCTOR] Construction de la surface avec image
+=========================================================*/
+Sprite::Sprite(const char url[], SDL_Rect r, SDL_Rect clip){
+
+	/* (1) On cree la surface (avec image) */
+	_surface = IMG_Load( url );
+
+	// Gestion erreur
+	if( _surface == NULL )
+		return;
+
+	// On definit les dimensions
+	_rect   = (SDL_Rect){r.x, r.y, r.w, r.h};
+	_origin = (SDL_Rect){clip.x, clip.y, r.w, r.h};
+
+	// On applique le clip
+	SDL_SetClipRect( _surface, &clip );
+
+}
+
+
+
+/* [APPENDTO] Ajoute le Sprite a une autre
+=========================================================*/
+void Sprite::appendTo(SDL_Surface *dest){
+	SDL_BlitSurface( _surface, &_origin, dest, &_rect );
+}
+
+/* [SURFACE] Retourne la surface
+=========================================================*/
+SDL_Surface *Sprite::surface(){ return _surface; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**********************************/
+/*********** SPRITEGROUP **********/
+/**********************************/
+/* [CONSTRUCTOR] Initialisation de la liste de Sprite
+=========================================================*/
+SpriteGroup::SpriteGroup(){
+	// _sprites = new vector<Sprite*>(0);
+}
+
+/* [ADD] Ajoute un Sprite au groupe
+=========================================================*/
+void SpriteGroup::add(Sprite *s){
+	_sprites.push_back( s );
+}
+
+/* [REMOVE] Suppression d'un Sprite du groupe
+=========================================================*/
+void SpriteGroup::remove(Sprite *s){
+	int index = -1; // on cherche l'indice du sprite
+
+	// On parcours la liste pour trouver l'indice
+	for( int i = 0 ; i < _sprites.size() ; i++ )
+		if( _sprites[i] == s ) index = i;
+
+	// Si on a pas trouve l'indice
+	if( index == -1 ) return;
+
+	// On supprime le sprite de la liste
+	_sprites.erase(_sprites.begin() + index );
+
+}
+
+/* [APPEBDTI] Ajoute tous les Sprite du groupe a une surface parente
+=========================================================*/
+void SpriteGroup::appendTo(SDL_Surface *dest){
+	for( int i = 0 ; i < _sprites.size() ; i++ )
+		_sprites[i]->appendTo( dest );
+}
+
+/* [GET] Retourne le Sprite d'index donne
+=========================================================*/
+Sprite* SpriteGroup::get(int i){
+	return _sprites[i];
+}

SDL#2/SDL#1/Sprite.h

@@ -0,0 +1,64 @@
+#ifndef DEF_SPRITE_H
+
+	#define DEF_SPRITE_H
+
+	/* [LIBS] Internes
+	=========================================================*/
+	#include "SDL.h"
+	#include "SDL_image.h"
+	#include <vector>
+
+	/* [LIBS] Externes
+	=========================================================*/
+	
+
+	/* [NS] Namespaces
+	=========================================================*/
+	using namespace std;
+
+
+	class Sprite{
+
+		public:
+			Sprite(SDL_Rect r);
+			Sprite(const int rgb[], SDL_Rect r);
+			Sprite(const char url[], SDL_Rect r, SDL_Rect clip);
+
+			void setImage(const char url[], int ox=0, int oy=0);
+
+			// ~Sprite();
+			void appendTo(SDL_Surface *dest);
+
+			// GETTERS
+			SDL_Surface *surface();
+
+		private:
+			SDL_Surface *_surface;
+			SDL_Rect    _rect;
+			SDL_Rect    _origin;
+
+	};
+
+	/* [AGGR] Groupement de Sprite
+	=========================================================*/
+	class SpriteGroup{
+
+		public:
+			SpriteGroup();
+			void add(Sprite *s);
+			void remove(Sprite *s);
+			Sprite* get(int i);
+			void appendTo(SDL_Surface *dest);
+
+		private:
+			vector<Sprite*> _sprites;
+
+	};
+
+
+	/* [BODY] Inclusion du corps
+	=========================================================*/
+	#include "Sprite.cpp"
+
+
+#endif

SDL#2/SDL#1/main.cpp

@@ -0,0 +1,93 @@
+#include "main.h"
+
+// On cree un sdl-toplevel statique
+static sdltl *mgr   = NULL;
+static bool running = true;
+
+
+
+int main(int argc, char* argv[]) {
+	srand(time(0));
+
+	/* [0] Initialisation de SDL
+	=========================================================*/
+	mgr = new sdltl("Ma fenetre SDL", WIN_WIDTH, WIN_HEIGHT);
+
+	/* [1] Creation de la fenetre
+	=========================================================*/
+	if( !mgr->status() ) cout << "Erreur: " << SDL_GetError() << endl;
+
+
+	/* [3] On definit le background color
+	=========================================================*/
+	mgr->setBackground(255, 255, 255);
+	// bool imageLoaded = mgr->setImage( "src/1.bmp" );
+
+
+
+	/* [4] On ajoute une sprite
+	=========================================================*/
+	SpriteGroup background;
+
+	/* (1) Bloc vide */
+	background.add( new Sprite(
+		(SDL_Rect) {0, 0, 200, 200}
+	));
+	
+	/* (2) Bloc rose */
+	int pink[] = {255, 0, 255};
+	cout << "a: [" << (sizeof(pink)/sizeof(*pink)) << "]" << endl;
+
+	background.add( new Sprite(
+		pink,
+		(SDL_Rect){200, 0, 200, 200}
+	));
+
+	/* (2) Bloc image */
+	background.add( new Sprite(
+		"src/1.bmp",
+		(SDL_Rect){400, 0, 200, 200},
+		(SDL_Rect){200, 200, 200, 200}
+	));
+
+
+
+
+	/* [5] On ajoute les elements + mise a jour affichage
+	=========================================================*/
+	background.appendTo( mgr->screen() );
+	mgr->update();
+
+
+
+
+
+	/* [n-1] Boucle infinie
+	=========================================================*/
+	mgr->manageFps(FPS);
+	running = true;
+	while(running){
+
+		mgr->waitEvent(SDL_QUIT, &quitEventHandler);
+
+		// Gestion des FPS (vitesse de la boucle)
+		mgr->manageFps();
+	}
+
+
+
+
+
+
+
+	/* [n] Fin d'execution
+	=========================================================*/
+	delete mgr;
+	return 0;
+}
+
+
+void quitEventHandler(SDL_Event *e){
+	cout << "Ferme" << endl;
+	running = false;
+}

SDL#2/SDL#1/main.h

@@ -0,0 +1,30 @@
+#ifndef DEF_MAIN_H
+
+	#define DEF_MAIN_H
+
+	/* [LIB] Internes
+	=========================================================*/
+	#include <iostream>
+	#include <ctime>
+
+	/* [LIB] Externes
+	=========================================================*/
+	#include "sdltl.h"  // gestion de la fenetre et SDL
+	#include "Sprite.h" // gestion des sprites
+
+	/* [NS] Namespace
+	=========================================================*/
+	using namespace std;
+
+	/* [CONST] Constantes et enumerations
+	=========================================================*/
+	#define WIN_WIDTH 600
+	#define WIN_HEIGHT 400
+
+	#define FPS 60
+
+	/* [FONCTIONS] Fonctions du corps
+	=========================================================*/
+	void quitEventHandler(SDL_Event *e);
+
+#endif

SDL#2/SDL#1/makefile

@@ -0,0 +1,41 @@
+.PHONY: init, clean, mrproper
+CC=g++
+FLAGS=`pkg-config sdl2 --cflags --libs` -l SDL2_image
+
+# INIT > STRUCTURE DE FICHIERS POUR LES EXECUTABLES
+init: clean
+	mkdir dep.o
+
+
+
+
+
+
+
+
+
+
+# EXECUTABLE > DEPENDANCES DE L'EXECUTABLE
+all: init main.o clean
+	rm -r dep.o
+	$(CC) main.o -o exe $(FLAGS)
+
+# AMORCE > PROGRAMME PRINCIPAL
+main.o: main.cpp
+	$(CC) -c $< -o main.o $(FLAGS)
+
+
+
+
+
+
+
+
+# RESET > SUPPRESSION DES FICHIERS 
+clean:
+		touch init.o
+		rm -r *.o
+
+# RESET FOR REBUILD > SUPPRESSION DE L'EXECUTABLE
+mrproper:
+	rm exe

SDL#2/SDL#1/sdltl.cpp

@@ -0,0 +1,134 @@
+/* [CONSTRUCTOR] Constructeur de la classe
+=========================================================*/
+sdltl::sdltl(const char *t, int w, int h){
+	// default values
+	_lasttick = 0;
+	_fpstime = 1000/60;
+
+	SDL_Init( SDL_INIT_EVERYTHING );
+
+	_window = NULL;
+	_screen = NULL;
+
+	// Creation de la fenetre
+	_window = SDL_CreateWindow(
+		t,
+		SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED,
+		w,
+		h,
+		SDL_WINDOW_SHOWN
+	);
+
+	// Gestion erreur
+	if( _window == NULL )
+		_status = false;
+
+	// On recupere la surface
+	_screen = SDL_GetWindowSurface( _window );
+
+	// On retourne que tout s'est bien passe
+	_status = true;
+}
+
+/* [DESTROYER] Destructeur de la classe
+=========================================================*/
+sdltl::~sdltl(){
+	SDL_DestroyWindow( _window );
+	SDL_Quit();
+}
+
+/* [STATUS] Retourne le status
+=========================================================*/
+bool sdltl::status(){
+	return _window != NULL && _screen != NULL;
+}
+
+
+/* [WINDOW] Retourne la fenetre
+=========================================================*/
+SDL_Window* sdltl::window(){ return _window; }
+
+
+/* [SCREEN] Retourne la fenetre
+=========================================================*/
+SDL_Surface* sdltl::screen(){ return _screen; }
+
+
+/* [SETBACKGROUND] Modifie la couleur de fond
+=========================================================*/
+void sdltl::setBackground(int r, int g, int b){
+	Uint32 color = SDL_MapRGB( _screen->format, r, g, b );
+
+	SDL_FillRect( _screen, NULL, color );
+}
+
+/* [SETIMAGE] Met une image en fond
+=========================================================*/
+bool sdltl::setImage(const char *url){
+	SDL_Surface *image = NULL;
+	image = SDL_LoadBMP( url );
+
+	// Si erreur de chargement image
+	if( image == NULL )
+		return false;
+
+	SDL_Rect dimensions;
+	dimensions.x = 0;
+	dimensions.y = 0;
+	SDL_GetWindowSize(_window, &dimensions.w, &dimensions.h);
+
+	SDL_BlitSurface( image, NULL, _screen, &dimensions);
+
+	// On libere la surface pour l'image
+	SDL_FreeSurface(image);
+	image = NULL;
+
+	return true;
+}
+
+/* [UPDATE] Mise a jour du rendu
+=========================================================*/
+void sdltl::update(){
+	SDL_UpdateWindowSurface( _window );
+}
+
+/* [WAITEVENT] Attends un evenement pour executer
+=========================================================*/
+void sdltl::waitEvent(SDL_EventType t, void(*handler)(SDL_Event*)){
+	SDL_Event event;
+
+	// On attends un evenement
+	while( SDL_PollEvent(&event) ){
+
+		// quand evenement, si type = t
+		if( event.type == t )
+			(*handler)(&event);
+
+	}
+}
+
+/* [MANAGEFTP] Gestion de la vitesse de boucle
+=========================================================*/
+void sdltl::manageFps(const int fps){
+	/* (1) Definition de fps */
+	if( fps != 0 ) _fpstime = 1000/fps;
+
+	/* (2) Initialisation timer */
+	if( _lasttick == 0 )
+		_lasttick = SDL_GetTicks();
+
+	/* (3) Utilisation en fin de WHILE() */
+
+	// 1 > Si trop rapide, on attends + definit _lasttick
+	else if( SDL_GetTicks()-_lasttick < _fpstime ){
+		SDL_Delay( _fpstime - (SDL_GetTicks()-_lasttick) );
+
+		_lasttick = SDL_GetTicks() + _fpstime - (SDL_GetTicks()-_lasttick);
+
+	// 2 > Temps ok
+	}else
+		_lasttick = SDL_GetTicks();
+	
+
+}

SDL#2/SDL#1/sdltl.h

@@ -0,0 +1,53 @@
+#ifndef DEF_SDLTL_H
+
+	#define DEF_SDLTL_H
+
+	/* [LIBS] Internes
+	=========================================================*/
+	#include "SDL.h"
+
+	/* [LIBS] Externes
+	=========================================================*/
+	
+
+	/* [NS] Namespaces
+	=========================================================*/
+	using namespace std;
+
+
+	class sdltl{
+
+		public:
+			sdltl(const char *t, int w, int h);
+			~sdltl();
+			SDL_Window *window();
+			SDL_Surface *screen();
+			bool status();
+			void setBackground(int r, int g, int b);
+			bool setImage(const char *url);
+			void waitEvent(SDL_EventType t, void(*handler)(SDL_Event*) );
+			void update();
+
+			void manageFps(const int fps=0);
+
+		private:
+			// gestion FPS
+			Uint32 _lasttick;
+			Uint32 _fpstime;
+
+			// status de l'initialisation
+			bool _status;
+
+			// Elements utiles
+			SDL_Window  *_window;
+			SDL_Surface *_screen;
+
+	};
+
+
+	/* [BODY] Inclusion du corps
+	=========================================================*/
+	#include "sdltl.cpp"
+
+
+#endif

SDL#2/Sprite.cpp

@@ -0,0 +1,126 @@
+
+/* [CONSTRUCTOR] Construction de la surface vide
+=========================================================*/
+Sprite::Sprite(int x, int y, int w, int h){
+	_surface = SDL_CreateRGBSurface(0, w, h, 32, 0, 0, 0, 0);
+
+	// On definit les dimensions
+	_rect = (SDL_Rect){x, y, w, h};
+
+	// On applique les offset
+	SDL_SetClipRect( _surface, &_rect );
+
+}
+
+
+
+/* [CONSTRUCTOR] Construction de la surface avec couleur
+=========================================================*/
+Sprite::Sprite(int c[], int x, int y, int w, int h){
+	_surface = SDL_CreateRGBSurface(0, w, h, 32, 0, 0, 0, 0);
+
+	// On recupere la couleur
+	Uint32 color = SDL_MapRGB( _surface->format, c[0], c[1], c[2]);
+
+	// On remplit avec la couleur
+	SDL_FillRect( _surface, NULL, color );
+
+	// On definit les dimensions
+	_rect = (SDL_Rect){x, y, w, h};
+
+	// On applique les offset
+	SDL_SetClipRect( _surface, &_rect );
+}
+
+
+
+/* [CONSTRUCTOR] Construction de la surface avec image
+=========================================================*/
+Sprite::Sprite(const char url[], int x, int y, int w, int h){
+	/* (1) On cree la surface (avec image) */
+	// _surface = SDL_LoadBMP( url );
+	_surface = IMG_Load( url );
+
+	// Gestion erreur
+	if( _surface == NULL )
+		return;
+
+	// On definit les dimensions
+	_rect = (SDL_Rect){x, y, w, h};
+
+	// On applique les offset
+	SDL_SetClipRect( _surface, &_rect );
+
+}
+
+
+
+/* [APPENDTO] Ajoute le Sprite a une autre
+=========================================================*/
+void Sprite::appendTo(SDL_Surface *dest){
+	SDL_BlitSurface( _surface, NULL, dest, &_rect );
+}
+
+/* [SURFACE] Retourne la surface
+=========================================================*/
+SDL_Surface *Sprite::surface(){ return _surface; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**********************************/
+/*********** SPRITEGROUP **********/
+/**********************************/
+/* [CONSTRUCTOR] Initialisation de la liste de Sprite
+=========================================================*/
+SpriteGroup::SpriteGroup(){
+	// _sprites = new vector<Sprite*>(0);
+}
+
+/* [ADD] Ajoute un Sprite au groupe
+=========================================================*/
+void SpriteGroup::add(Sprite *s){
+	_sprites.push_back( s );
+}
+
+/* [REMOVE] Suppression d'un Sprite du groupe
+=========================================================*/
+void SpriteGroup::remove(Sprite *s){
+	int index = -1; // on cherche l'indice du sprite
+
+	// On parcours la liste pour trouver l'indice
+	for( int i = 0 ; i < _sprites.size() ; i++ )
+		if( _sprites[i] == s ) index = i;
+
+	// Si on a pas trouve l'indice
+	if( index == -1 ) return;
+
+	// On supprime le sprite de la liste
+	_sprites.erase(_sprites.begin() + index );
+
+}
+
+/* [APPEBDTI] Ajoute tous les Sprite du groupe a une surface parente
+=========================================================*/
+void SpriteGroup::appendTo(SDL_Surface *dest){
+	for( int i = 0 ; i < _sprites.size() ; i++ )
+		_sprites[i]->appendTo( dest );
+}
+
+/* [GET] Retourne le Sprite d'index donne
+=========================================================*/
+Sprite* SpriteGroup::get(int i){
+	return _sprites[i];
+}

SDL#2/Sprite.h

@@ -0,0 +1,61 @@
+#ifndef DEF_SPRITE_H
+
+	#define DEF_SPRITE_H
+
+	/* [LIBS] Internes
+	=========================================================*/
+	#include "SDL.h"
+	#include "SDL_image.h"
+	#include <vector>
+
+	/* [LIBS] Externes
+	=========================================================*/
+	
+
+	/* [NS] Namespaces
+	=========================================================*/
+	using namespace std;
+
+
+	class Sprite{
+
+		public:
+			Sprite(int x, int y, int w, int h);
+			Sprite(int c[], int x, int y, int w, int h);
+			Sprite(const char url[], int x, int y, int w, int h);
+
+			// ~Sprite();
+			void appendTo(SDL_Surface *dest);
+
+			// GETTERS
+			SDL_Surface *surface();
+
+		private:
+			SDL_Surface *_surface;
+			SDL_Rect    _rect;
+
+	};
+
+	/* [AGGR] Groupement de Sprite
+	=========================================================*/
+	class SpriteGroup{
+
+		public:
+			SpriteGroup();
+			void add(Sprite *s);
+			void remove(Sprite *s);
+			Sprite* get(int i);
+			void appendTo(SDL_Surface *dest);
+
+		private:
+			vector<Sprite*> _sprites;
+
+	};
+
+
+	/* [BODY] Inclusion du corps
+	=========================================================*/
+	#include "Sprite.cpp"
+
+
+#endif

SDL#2/main.cpp

@@ -0,0 +1,82 @@
+#include "main.h"
+
+// On cree un sdl-toplevel statique
+static sdltl *mgr   = NULL;
+static bool running = true;
+
+
+
+int main(int argc, char* argv[]) {
+	srand(time(0));
+
+	/* [0] Initialisation de SDL
+	=========================================================*/
+	mgr = new sdltl("Ma fenetre SDL", WIN_WIDTH, WIN_HEIGHT);
+
+	/* [1] Creation de la fenetre
+	=========================================================*/
+	if( !mgr->status() ) cout << "Erreur: " << SDL_GetError() << endl;
+
+
+	/* [3] On definit le background color
+	=========================================================*/
+	mgr->setBackground(255, 255, 255);
+	// bool imageLoaded = mgr->setImage( "src/1.bmp" );
+
+
+
+	/* [4] On ajoute une sprite
+	=========================================================*/
+	SpriteGroup back;
+
+	/* (1) Bloc vide */
+	back.add( new Sprite(             0,   0, 200, 200 ) );
+	
+	/* (2) Bloc rose */
+	int pink[] = {255, 0, 255};
+	back.add( new Sprite(pink,        200, 0, 200, 200 ) );
+
+	/* (2) Bloc image */
+	back.add( new Sprite("src/1.bmp", 400, 0, 200, 200 ) );
+
+
+
+
+	/* [5] On ajoute les elements + mise a jour affichage
+	=========================================================*/
+	back.appendTo( mgr->screen() );
+	mgr->update();
+
+
+
+
+
+	/* [n-1] Boucle infinie
+	=========================================================*/
+	mgr->manageFps(FPS);
+	running = true;
+	while(running){
+
+		mgr->waitEvent(SDL_QUIT, &quitEventHandler);
+
+		// Gestion des FPS (vitesse de la boucle)
+		mgr->manageFps();
+	}
+
+
+
+
+
+
+
+	/* [n] Fin d'execution
+	=========================================================*/
+	delete mgr;
+	return 0;
+}
+
+
+void quitEventHandler(SDL_Event *e){
+	cout << "Ferme" << endl;
+	running = false;
+}

SDL#2/main.h

@@ -0,0 +1,30 @@
+#ifndef DEF_MAIN_H
+
+	#define DEF_MAIN_H
+
+	/* [LIB] Internes
+	=========================================================*/
+	#include <iostream>
+	#include <ctime>
+
+	/* [LIB] Externes
+	=========================================================*/
+	#include "sdltl.h"  // gestion de la fenetre et SDL
+	#include "Sprite.h" // gestion des sprites
+
+	/* [NS] Namespace
+	=========================================================*/
+	using namespace std;
+
+	/* [CONST] Constantes et enumerations
+	=========================================================*/
+	#define WIN_WIDTH 600
+	#define WIN_HEIGHT 400
+
+	#define FPS 60
+
+	/* [FONCTIONS] Fonctions du corps
+	=========================================================*/
+	void quitEventHandler(SDL_Event *e);
+
+#endif

SDL#2/makefile

@@ -0,0 +1,41 @@
+.PHONY: init, clean, mrproper
+CC=g++
+FLAGS=`pkg-config sdl2 --cflags --libs` -l SDL2_image
+
+# INIT > STRUCTURE DE FICHIERS POUR LES EXECUTABLES
+init: clean
+	mkdir dep.o
+
+
+
+
+
+
+
+
+
+
+# EXECUTABLE > DEPENDANCES DE L'EXECUTABLE
+all: init main.o clean
+	rm -r dep.o
+	$(CC) main.o -o exe $(FLAGS)
+
+# AMORCE > PROGRAMME PRINCIPAL
+main.o: main.cpp
+	$(CC) -c $< -o main.o $(FLAGS)
+
+
+
+
+
+
+
+
+# RESET > SUPPRESSION DES FICHIERS 
+clean:
+		touch init.o
+		rm -r *.o
+
+# RESET FOR REBUILD > SUPPRESSION DE L'EXECUTABLE
+mrproper:
+	rm exe

SDL#2/sdltl.cpp

@@ -0,0 +1,134 @@
+/* [CONSTRUCTOR] Constructeur de la classe
+=========================================================*/
+sdltl::sdltl(const char *t, int w, int h){
+	// default values
+	_lasttick = 0;
+	_fpstime = 1000/60;
+
+	SDL_Init( SDL_INIT_EVERYTHING );
+
+	_window = NULL;
+	_screen = NULL;
+
+	// Creation de la fenetre
+	_window = SDL_CreateWindow(
+		t,
+		SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED,
+		w,
+		h,
+		SDL_WINDOW_SHOWN
+	);
+
+	// Gestion erreur
+	if( _window == NULL )
+		_status = false;
+
+	// On recupere la surface
+	_screen = SDL_GetWindowSurface( _window );
+
+	// On retourne que tout s'est bien passe
+	_status = true;
+}
+
+/* [DESTROYER] Destructeur de la classe
+=========================================================*/
+sdltl::~sdltl(){
+	SDL_DestroyWindow( _window );
+	SDL_Quit();
+}
+
+/* [STATUS] Retourne le status
+=========================================================*/
+bool sdltl::status(){
+	return _window != NULL && _screen != NULL;
+}
+
+
+/* [WINDOW] Retourne la fenetre
+=========================================================*/
+SDL_Window* sdltl::window(){ return _window; }
+
+
+/* [SCREEN] Retourne la fenetre
+=========================================================*/
+SDL_Surface* sdltl::screen(){ return _screen; }
+
+
+/* [SETBACKGROUND] Modifie la couleur de fond
+=========================================================*/
+void sdltl::setBackground(int r, int g, int b){
+	Uint32 color = SDL_MapRGB( _screen->format, r, g, b );
+
+	SDL_FillRect( _screen, NULL, color );
+}
+
+/* [SETIMAGE] Met une image en fond
+=========================================================*/
+bool sdltl::setImage(const char *url){
+	SDL_Surface *image = NULL;
+	image = SDL_LoadBMP( url );
+
+	// Si erreur de chargement image
+	if( image == NULL )
+		return false;
+
+	SDL_Rect dimensions;
+	dimensions.x = 0;
+	dimensions.y = 0;
+	SDL_GetWindowSize(_window, &dimensions.w, &dimensions.h);
+
+	SDL_BlitSurface( image, NULL, _screen, &dimensions);
+
+	// On libere la surface pour l'image
+	SDL_FreeSurface(image);
+	image = NULL;
+
+	return true;
+}
+
+/* [UPDATE] Mise a jour du rendu
+=========================================================*/
+void sdltl::update(){
+	SDL_UpdateWindowSurface( _window );
+}
+
+/* [WAITEVENT] Attends un evenement pour executer
+=========================================================*/
+void sdltl::waitEvent(SDL_EventType t, void(*handler)(SDL_Event*)){
+	SDL_Event event;
+
+	// On attends un evenement
+	while( SDL_PollEvent(&event) ){
+
+		// quand evenement, si type = t
+		if( event.type == t )
+			(*handler)(&event);
+
+	}
+}
+
+/* [MANAGEFTP] Gestion de la vitesse de boucle
+=========================================================*/
+void sdltl::manageFps(const int fps){
+	/* (1) Definition de fps */
+	if( fps != 0 ) _fpstime = 1000/fps;
+
+	/* (2) Initialisation timer */
+	if( _lasttick == 0 )
+		_lasttick = SDL_GetTicks();
+
+	/* (3) Utilisation en fin de WHILE() */
+
+	// 1 > Si trop rapide, on attends + definit _lasttick
+	else if( SDL_GetTicks()-_lasttick < _fpstime ){
+		SDL_Delay( _fpstime - (SDL_GetTicks()-_lasttick) );
+
+		_lasttick = SDL_GetTicks() + _fpstime - (SDL_GetTicks()-_lasttick);
+
+	// 2 > Temps ok
+	}else
+		_lasttick = SDL_GetTicks();
+	
+
+}

SDL#2/sdltl.h

@@ -0,0 +1,53 @@
+#ifndef DEF_SDLTL_H
+
+	#define DEF_SDLTL_H
+
+	/* [LIBS] Internes
+	=========================================================*/
+	#include "SDL.h"
+
+	/* [LIBS] Externes
+	=========================================================*/
+	
+
+	/* [NS] Namespaces
+	=========================================================*/
+	using namespace std;
+
+
+	class sdltl{
+
+		public:
+			sdltl(const char *t, int w, int h);
+			~sdltl();
+			SDL_Window *window();
+			SDL_Surface *screen();
+			bool status();
+			void setBackground(int r, int g, int b);
+			bool setImage(const char *url);
+			void waitEvent(SDL_EventType t, void(*handler)(SDL_Event*) );
+			void update();
+
+			void manageFps(const int fps=0);
+
+		private:
+			// gestion FPS
+			Uint32 _lasttick;
+			Uint32 _fpstime;
+
+			// status de l'initialisation
+			bool _status;
+
+			// Elements utiles
+			SDL_Window  *_window;
+			SDL_Surface *_screen;
+
+	};
+
+
+	/* [BODY] Inclusion du corps
+	=========================================================*/
+	#include "sdltl.cpp"
+
+
+#endif