SDL personal lib

SDL#1/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#1/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#1/main.cpp

@@ -1,11 +1,13 @@
 #include "main.h"
 
 // On cree un sdl-toplevel statique
-static sdltl *mgr;
+static sdltl *mgr   = NULL;
+static bool running = true;
 
 
 
 int main(int argc, char* argv[]) {
+	srand(time(0));
 
 	/* [0] Initialisation de SDL
 	=========================================================*/
@@ -13,25 +15,57 @@ int main(int argc, char* argv[]) {
 
 	/* [1] Creation de la fenetre
 	=========================================================*/
-	if( !mgr->status() )
-		cout << "Erreur: " << SDL_GetError() << endl;
+	if( !mgr->status() ) cout << "Erreur: " << SDL_GetError() << endl;
 
 
 	/* [3] On definit le background color
 	=========================================================*/
-	// mgr->setBackground(255, 0, 255);
-	mgr->setBackground(255, 0, 0);
-	bool imageLoaded = mgr->setImage( "src/1.bmp" );
+	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
 	=========================================================*/
-	// while(1){
-		mgr->waitEvent(SDL_QUIT, &eventHandler);
-	// }
-	// SDL_Delay(5000);
+	mgr->manageFps(FPS);
+	running = true;
+	while(running){
+
+		mgr->waitEvent(SDL_QUIT, &quitEventHandler);
+
+		// Gestion des FPS (vitesse de la boucle)
+		mgr->manageFps();
+	}
+
+
+
+
 
 
 
@@ -42,7 +76,7 @@ int main(int argc, char* argv[]) {
 }
 
 
-void eventHandler(SDL_Event *e){
+void quitEventHandler(SDL_Event *e){
 	cout << "Ferme" << endl;
-	delete mgr;
+	running = false;
 }

SDL#1/main.h

@@ -5,11 +5,12 @@
 	/* [LIB] Internes
 	=========================================================*/
 	#include <iostream>
+	#include <ctime>
 
 	/* [LIB] Externes
 	=========================================================*/
 	#include "sdltl.h"  // gestion de la fenetre et SDL
-	#include "sprite.h" // gestion des sprites
+	#include "Sprite.h" // gestion des sprites
 
 	/* [NS] Namespace
 	=========================================================*/
@@ -20,8 +21,10 @@
 	#define WIN_WIDTH 600
 	#define WIN_HEIGHT 400
 
+	#define FPS 60
+
 	/* [FONCTIONS] Fonctions du corps
 	=========================================================*/
-	void eventHandler(SDL_Event *e);
+	void quitEventHandler(SDL_Event *e);
 
 #endif

SDL#1/makefile

@@ -1,6 +1,6 @@
 .PHONY: init, clean, mrproper
 CC=g++
-FLAGS=`pkg-config sdl2 --cflags --libs`
+FLAGS=`pkg-config sdl2 --cflags --libs` -l SDL2_image
 
 # INIT > STRUCTURE DE FICHIERS POUR LES EXECUTABLES
 init: clean

SDL#1/sdltl.cpp

@@ -1,6 +1,10 @@
 /* [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;
@@ -9,8 +13,8 @@ sdltl::sdltl(const char *t, int w, int h){
 	// Creation de la fenetre
 	_window = SDL_CreateWindow(
 		t,
-		SDL_WINDOWPOS_UNDEFINED,
-		SDL_WINDOWPOS_UNDEFINED,
+		SDL_WINDOWPOS_CENTERED,
+		SDL_WINDOWPOS_CENTERED,
 		w,
 		h,
 		SDL_WINDOW_SHOWN
@@ -36,7 +40,9 @@ sdltl::~sdltl(){
 
 /* [STATUS] Retourne le status
 =========================================================*/
-bool sdltl::status(){ return _status; }
+bool sdltl::status(){
+	return _window != NULL && _screen != NULL;
+}
 
 
 /* [WINDOW] Retourne la fenetre
@@ -100,4 +106,29 @@ void sdltl::waitEvent(SDL_EventType t, void(*handler)(SDL_Event*)){
 			(*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#1/sdltl.h

@@ -26,11 +26,19 @@
 			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;
 

SDL#1/sprite.h

@@ -1,34 +0,0 @@
-#ifndef DEF_SPRITE_H
-
-	#define DEF_SPRITE_H
-
-	/* [LIBS] Internes
-	=========================================================*/
-	#include "SDL.h"
-
-	/* [LIBS] Externes
-	=========================================================*/
-	
-
-	/* [NS] Namespaces
-	=========================================================*/
-	using namespace std;
-
-
-	class Sprite{
-
-		public:
-			Sprite();
-			~Sprite();
-
-		private:
-
-	};
-
-
-	/* [BODY] Inclusion du corps
-	=========================================================*/
-	// #include "sprite.cpp"
-
-
-#endif