xdrm-brackets
/
lab.cpp
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

SDL#3 Animations gerees (mais pb de <vector> avec thread donc 1 seule a la fois pour l'instant) + Gestion de la redimension + animation avec changement de SDL_Rect uniquement a faire

This commit is contained in:
xdrm-brackets 2016-03-12 00:10:38 +01:00
parent dfe178e140
commit b0e5c93a23
8 changed files with 224 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
SDL#3/Sprite.cpp
View File

@ -1,89 +1,130 @@
/* [DESTRUCTOR] Destruction de la surface /* [DESTRUCTOR] Destruction de la surface
=========================================================*/ =========================================================*/
Sprite::~Sprite(){ Sprite::~Sprite(){
SDL_FreeSurface( _surface ); SDL_DestroyTexture( _texture );
_manager = NULL;
} }
/* [CONSTRUCTOR] Construction de la surface vide /* [CONSTRUCTOR] Construction de la surface vide
=========================================================*/ =========================================================*/
Sprite::Sprite(SDL_Rect r){ Sprite::Sprite(sdltl *m){
_surface = SDL_CreateRGBSurface(0, r.w, r.h, 32, 0, 0, 0, 0); _manager = m;
_texture = NULL;
// 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 /* [CONSTRUCTOR] Construction de la surface avec couleur
=========================================================*/ =========================================================*/
Sprite::Sprite(const int rgb[], SDL_Rect r){ Sprite::Sprite(sdltl *m, const int rgb[]){
_manager = m;
_texture = NULL;
cout << "a: [" << (sizeof(rgb)/sizeof(*rgb)) << "]" << endl; cout << "a: [" << (sizeof(rgb)/sizeof(*rgb)) << "]" << endl;
_surface = SDL_CreateRGBSurface(0, r.w, r.h, 32, 0, 0, 0, rgb[3]); SDL_Surface *surf = SDL_CreateRGBSurface(0, 0, 0, 32, 0, 0, 0, rgb[3]);
// On recupere la couleur // On recupere la couleur
Uint32 color = SDL_MapRGBA( _surface->format, rgb[0], rgb[1], rgb[2], rgb[3]); Uint32 color = SDL_MapRGBA( surf->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 // On cree la texture a partir de la surface
SDL_SetClipRect( _surface, &_rect ); _texture = SDL_CreateTextureFromSurface(_manager->renderer(), surf);
// On libere la surface inutile maintenant
SDL_FreeSurface( surf );
surf = NULL;
} }
/* [CONSTRUCTOR] Construction de la surface avec image /* [CONSTRUCTOR] Construction de la surface avec image
=========================================================*/ =========================================================*/
Sprite::Sprite(const char url[], SDL_Rect r, SDL_Rect clip){ Sprite::Sprite(sdltl *m, const char *url){
_manager = m;
_texture = NULL;
/* (1) On cree la surface (avec image) */ /* (1) On cree la surface (avec image) */
_surface = IMG_Load( url ); _texture = IMG_LoadTexture(_manager->renderer(), url);
// Gestion erreur // Gestion erreur
if( _surface == NULL ) if( _texture == NULL )
return; 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 );
} }
/* [DIMENSIONS] Definition des dimensions par defaut
/* [APPENDTO] Ajoute le Sprite au rendu
=========================================================*/ =========================================================*/
void Sprite::appendTo(sdltl *mgr){ void Sprite::dimensions(){
_texture = SDL_CreateTextureFromSurface(mgr->renderer(), _surface); cout <<"A"<<endl;
mgr->add(_texture, &_origin, &_rect); /* (1) On recupere les informations de la texture */
int w, h;
SDL_QueryTexture(_texture, NULL, NULL, &w, &h);
/* (2) On definit les dimensions par defaut */
_dst = (SDL_Rect){0, 0, w, h};
_src = (SDL_Rect){0, 0, w, h};
} }
/* [REMOVEFROM] Retire une sprite du rendu
/* [DIMENSIONS] Definition des dimensions de la texture
=========================================================*/ =========================================================*/
void Sprite::removeFrom(sdltl *mgr){ void Sprite::dimensions(SDL_Rect r){
mgr->remove( _texture ); cout <<"B"<<endl;
/* (1) On recupere les informations de la texture */
int w, h;
SDL_QueryTexture(_texture, NULL, NULL, &w, &h);
/* (2) On definit les dimensions */
_dst = (SDL_Rect){r.x, r.y, r.w, r.h};
_src = (SDL_Rect){0, 0, w, h};
} }
/* [SURFACE] Retourne la surface /* [DIMENSIONS] Definition des dimensions de la texture+clip
=========================================================*/ =========================================================*/
SDL_Surface *Sprite::surface(){ return _surface; } void Sprite::dimensions(SDL_Rect r, SDL_Rect clip){
cout <<"C"<<endl;
/* (1) On definit les dimensions */
_dst = (SDL_Rect){r.x, r.y, r.w, r.h};
_src = (SDL_Rect){clip.x, clip.y, clip.w, clip.h};
}
/* [PUSH] Ajoute le Sprite au rendu
=========================================================*/
void Sprite::push(){
_manager->push(_texture, &_src, &_dst);
}
/* [PULL] Retire une sprite du rendu
=========================================================*/
void Sprite::pull(){
_manager->pull( _texture );
}
/* [UPDATE] Mise a jour du rendu
=========================================================*/
void Sprite::update(){
_manager->update();
}
/* [TEXTURE] Retourne la texture
=========================================================*/
SDL_Texture *Sprite::texture(){ return _texture; }
/* [MANAGER] Retourne le manager
=========================================================*/
sdltl *Sprite::manager(){ return _manager; }
@ -132,18 +173,27 @@ void SpriteGroup::remove(Sprite *s){
} }
/* [APPENDTO] Ajoute tous les Sprite du groupe a une surface parente /* [PUSH] Ajoute tous les Sprite du groupe a une surface parente
=========================================================*/ =========================================================*/
void SpriteGroup::appendTo(sdltl *mgr){ void SpriteGroup::push(){
for( int i = 0 ; i < _sprites.size() ; i++ ) for( int i = 0 ; i < _sprites.size() ; i++ )
_sprites[i]->appendTo( mgr ); _sprites[i]->push();
} }
/* [REMOVEFROM] Retire une sprite de la surface parents /* [PULL] Retire une sprite de la surface parents
=========================================================*/ =========================================================*/
void SpriteGroup::removeFrom(sdltl *mgr){ void SpriteGroup::pull(){
for( int i = 0 ; i < _sprites.size() ; i++ ) for( int i = 0 ; i < _sprites.size() ; i++ )
_sprites[i]->removeFrom( mgr ); _sprites[i]->pull();
}
/* [UPDATE] Mise a jour du rendu
=========================================================*/
void SpriteGroup::update(){
if( _sprites.size() > 0 )
_sprites[0]->update();
} }
@ -158,7 +208,7 @@ Sprite* SpriteGroup::get(int i){
/* [TRHEAD] Process de l'animation /* [TRHEAD] Process de l'animation
=========================================================*/ =========================================================*/
void SpriteGroupAnimation(sdltl *mgr, SpriteGroup *sg, int t, int flags){ void SpriteGroupAnimation(SpriteGroup *sg, int t, int flags){
int length = sg->_sprites.size(); int length = sg->_sprites.size();
int timer = 0; int timer = 0;
int step = 1; int step = 1;
@ -175,13 +225,13 @@ void SpriteGroupAnimation(sdltl *mgr, SpriteGroup *sg, int t, int flags){
// On retire le sprite precedent // On retire le sprite precedent
if( lastindex > -1 ) if( lastindex > -1 )
sg->_sprites[lastindex]->removeFrom( mgr ); sg->get(lastindex)->pull();
// On ajoute le sprite // On ajoute le sprite
sg->_sprites[i]->appendTo( mgr ); sg->get(i)->push();
// On met a jour le rendu // On met a jour le rendu
// mgr->update(); // sg->get(i)->update();
if( SDL_GetTicks()-timer < t ) if( SDL_GetTicks()-timer < t )
@ -212,8 +262,8 @@ void SpriteGroupAnimation(sdltl *mgr, SpriteGroup *sg, int t, int flags){
/* [ANIMATE] Modifie le Sprite dans l'ordre du SpriteGroup /* [ANIMATE] Modifie le Sprite dans l'ordre du SpriteGroup
=========================================================*/ =========================================================*/
thread* SpriteGroup::animate(sdltl *mgr, int t, int flags){ thread* SpriteGroup::animate(int t, int flags){
_animation = new thread(SpriteGroupAnimation, mgr, this, t, flags); _animation = new thread(SpriteGroupAnimation, this, t, flags);
// On attends pas le thread // On attends pas le thread
_animation->detach(); _animation->detach();

38
SDL#3/Sprite.h
View File

@ -24,25 +24,31 @@
class Sprite{ class Sprite{
public: public:
Sprite(SDL_Rect r); Sprite(sdltl *m); // Sprite vide
Sprite(const int rgb[], SDL_Rect r); Sprite(sdltl *m, const int rgb[]); // Sprite couleur
Sprite(const char url[], SDL_Rect r, SDL_Rect clip); Sprite(sdltl *m, const char *url); // Sprite image
~Sprite(); ~Sprite();
void setImage(const char url[], int ox=0, int oy=0); void dimensions(); // Dimensions par defaut
void dimensions(SDL_Rect r); // Dimensions sortie
void dimensions(SDL_Rect r, SDL_Rect clip); // Dimensions in/out
void appendTo(sdltl *mgr); void push(); // Ajoute a l'affichage
void removeFrom(sdltl *mgr); void pull(); // Retire de l'affichage
void update(); // Fait renmonter la mise a jour du manager
// GETTERS // GETTERS
SDL_Surface *surface(); SDL_Texture *texture();
sdltl *manager();
private: private:
SDL_Surface *_surface; sdltl *_manager;
SDL_Texture *_texture; SDL_Texture *_texture;
SDL_Rect _rect; SDL_Rect _dst;
SDL_Rect _origin; SDL_Rect _src;
}; };
@ -55,18 +61,20 @@
void add(Sprite *s); void add(Sprite *s);
void remove(Sprite *s); void remove(Sprite *s);
Sprite* get(int i); Sprite* get(int i);
void appendTo(sdltl *mgr);
void removeFrom(sdltl *mgr);
thread *animate(sdltl *mgr, int t, int flags=0); void push(); // Ajoute les sprites a l'affichage
void pull(); // Retire les sprites de l'affichage
void update(); // Fait renmonter la mise a jour du manager
thread *animate(int t, int flags=0);
private: private:
SDL_Renderer *_renderer;
vector<Sprite*> _sprites; vector<Sprite*> _sprites;
thread *_animation; thread *_animation;
friend void SpriteGroupAnimation(sdltl *mgr, SpriteGroup *sg, int t, int flags=SPRITE_ANIM_ONCE ); friend void SpriteGroupAnimation(SpriteGroup *sg, int t, int flags=SPRITE_ANIM_ONCE );
}; };

BIN
SDL#3/exe
View File

Binary file not shown.

122
SDL#3/main.cpp
View File

@ -9,143 +9,115 @@ static bool running = true;
int main(int argc, char* argv[]) { int main(int argc, char* argv[]) {
srand(time(0)); srand(time(0));
/* [0] Initialisation de SDL /* [0] Initialisation du manager + Creation de la fenetre
=========================================================*/ =========================================================*/
mgr = new sdltl("Ma fenetre SDL", WIN_WIDTH, WIN_HEIGHT); mgr = new sdltl("Ma fenetre SDL", WIN_WIDTH, WIN_HEIGHT);
/* [1] Creation de la fenetre // Gestion erreur
=========================================================*/ if( !mgr->status() ){
if( !mgr->status() ) cout << "Erreur: " << SDL_GetError() << endl; cout << "[INIT] -> " << SDL_GetError() << endl;
return -1;
}
/* [3] On definit le background color /* [2] On definit le background color
=========================================================*/ =========================================================*/
bool bgLoaded = mgr->setBackground(255, 255, 255); mgr->setBackground(255, 0, 255, 150);
cout << "BG: " << bgLoaded << endl; // mgr->setImage( "src/1.bmp" );
// bool imageLoaded = mgr->setImage( "src/1.bmp" );
/* [4] On ajoute Une animation /* [4] On ajoute Une animation
=========================================================*/ =========================================================*/
/* (1) On cree les fonds pour couvrir les frames en arriere plan */ /* (1) On cree les fonds pour couvrir les frames en arriere plan */
int white[] = {255, 255, 255}; // int white[] = {255, 255, 255};
Sprite *mb_background = new Sprite( // Sprite *mb_background = new Sprite(mgr, white );
white, // mb_background->dimensions((SDL_Rect){0, 0, 20, 20});
(SDL_Rect){0, 0, 20, 20}
);
Sprite *gs_background = new Sprite(
white,
(SDL_Rect){100, 0, 20, 20}
);
Sprite *rs_background = new Sprite(
white,
(SDL_Rect){150, 0, 20, 20}
);
/* (2) On enregistre les frames de l'animation du bloc mystere */ // Sprite *gs_background = new Sprite(mgr, white);
// gs_background->dimensions((SDL_Rect){100, 0, 20, 20});
// Sprite *rs_background = new Sprite(mgr, white);
// rs_background->dimensions((SDL_Rect){150, 0, 20, 20});
// /* (2) On enregistre les frames de l'animation du bloc mystere */
SpriteGroup animated_mystery_bloc; SpriteGroup animated_mystery_bloc;
for( int i = 0 ; i < 4 ; i++ ){ for( int i = 0 ; i < 4 ; i++ ){
animated_mystery_bloc.add( new Sprite( animated_mystery_bloc.add( new Sprite(mgr, "src/mario_crop.png") );
"src/mario_crop.png", animated_mystery_bloc.get(i)->dimensions(
(SDL_Rect){0, 0, 20, 20}, (SDL_Rect){0, 0, 100, 100},
(SDL_Rect){4*19+19*i, 2*20, 20, 20} (SDL_Rect){4*19+19*i, 2*20, 20, 20}
) ); );
} }
/* (3) On enregistre les frames de l'animation d'une carapace verte */ // (3) On enregistre les frames de l'animation d'une carapace verte
SpriteGroup animated_green_shell; SpriteGroup animated_green_shell;
for( int i = 0 ; i < 4 ; i++ ){ for( int i = 0 ; i < 4 ; i++ ){
animated_green_shell.add( new Sprite( animated_green_shell.add( new Sprite(mgr, "src/mario_crop.png") );
"src/mario_crop.png", animated_green_shell.get(i)->dimensions(
(SDL_Rect){100, 0, 20, 20}, (SDL_Rect){100, 0, 20, 20},
(SDL_Rect){4*19+19*i, 11*19, 20, 20} (SDL_Rect){4*19+19*i, 11*19, 20, 20}
) ); );
} }
/* (4) On enregistre les frames de l'animation d'une carapace rouge */ // /* (4) On enregistre les frames de l'animation d'une carapace rouge */
SpriteGroup animated_red_shell; SpriteGroup animated_red_shell;
for( int i = 0 ; i < 4 ; i++ ){ for( int i = 0 ; i < 4 ; i++ ){
animated_red_shell.add( new Sprite( animated_red_shell.add( new Sprite(mgr, "src/mario_crop.png") );
"src/mario_crop.png", animated_red_shell.get(i)->dimensions(
(SDL_Rect){150, 0, 20, 20}, (SDL_Rect){150, 0, 50, 50},
(SDL_Rect){2+19*i, 11*19, 20, 20} (SDL_Rect){2+19*i, 11*19, 20, 20}
) ); );
} }
// TEST
int red[] = {255, 0, 0};
int pink[] = {255, 0, 255};
SpriteGroup testgroup;
testgroup.add( new Sprite(
"src/mario_crop.png",
(SDL_Rect){150, 0, 20, 20},
(SDL_Rect){2+19*1, 11*19, 20, 20}
) );
testgroup.add( new Sprite(
pink,
(SDL_Rect){100, 0, 100, 100}
) );
// testgroup.appendTo(mgr);
testgroup.get(0)->appendTo(mgr);
// /* [5] On lance les animation en parallele
// =========================================================*/
/* [5] On lance les animation en parallele
=========================================================*/
vector<thread*> animations(0); vector<thread*> animations(0);
animations.push_back( animated_mystery_bloc.animate( // animations.push_back( animated_mystery_bloc.animate(
mgr, // rendu a mettre a jour // 200, // delai entre-frames
200, // delai entre-frames // SPRITE_ANIM_INFINITE // FLAGS
SPRITE_ANIM_INFINITE // FLAGS // ) );
) ); // delete animations[0]; // On le supprime ensuite
delete animations[0]; // On le supprime ensuite
animations.push_back( animated_green_shell.animate( // animations.push_back( animated_green_shell.animate(
mgr, // rendu a mettre a jour // 100, // delai entre-frames
100, // delai entre-frames // SPRITE_ANIM_INFINITE // FLAGS
SPRITE_ANIM_INFINITE // FLAGS // ) );
) ); // delete animations[1]; // On le supprime ensuite
delete animations[1]; // On le supprime ensuite
animations.push_back( animated_red_shell.animate( animations.push_back( animated_red_shell.animate(
mgr, // rendu a mettre a jour
100, // delai entre-frames 100, // delai entre-frames
SPRITE_ANIM_INFINITE // FLAGS SPRITE_ANIM_INFINITE // FLAGS
) ); ) );
delete animations[2]; // On le supprime ensuite delete animations[0]; // On le supprime ensuite
/* [n-1] Boucle infinie /* [n-1] Boucle infinie
=========================================================*/ =========================================================*/
mgr->update();
mgr->manageFps(FPS); mgr->manageFps(FPS);
running = true; running = true;
while(running){ while(running){
mgr->waitEvent(SDL_QUIT, &quitEventHandler); mgr->waitEvent(SDL_QUIT, &quitEventHandler);
// cout << "Main loop" << endl; // cout << "Main loop" << endl;

4
SDL#3/main.h
View File

@ -19,8 +19,8 @@
/* [CONST] Constantes et enumerations /* [CONST] Constantes et enumerations
=========================================================*/ =========================================================*/
#define WIN_WIDTH 600 #define WIN_WIDTH 1200
#define WIN_HEIGHT 400 #define WIN_HEIGHT 800
#define FPS 60 #define FPS 60

BIN
SDL#3/main.o
View File

Binary file not shown.

96
SDL#3/sdltl.cpp
View File

@ -32,7 +32,7 @@ sdltl::sdltl(const char *t, int w, int h){
_renderer = SDL_CreateRenderer( _renderer = SDL_CreateRenderer(
_window, _window,
-1, -1,
SDL_RENDERER_ACCELERATED SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC
); );
} }
@ -65,38 +65,9 @@ SDL_Renderer* sdltl::renderer(){ return _renderer; }
/* [SETBACKGROUND] Modifie la couleur de fond /* [SETBACKGROUND] Modifie la couleur de fond
=========================================================*/ =========================================================*/
bool sdltl::setBackground(int r, int g, int b){ bool sdltl::setBackground(Uint8 r, Uint8 g, Uint8 b, Uint8 a){
/*// On cree la surface
SDL_Surface *surf = NULL;
int win[2];
SDL_GetWindowSize(_window, &win[0], &win[1]);
// On cree la surface SDL_SetRenderDrawColor( _renderer, r, g, b, a );
surf = SDL_CreateRGBSurface(0, win[0], win[1], 32, 0, 0, 0, 0);
if( surf == NULL )
return false;
// On cree la couleur
Uint32 color = SDL_MapRGB(surf->format, r, g, b);
// On colore la surface
SDL_FillRect(surf, NULL, color);
// On applique a la texture
_texture = SDL_CreateTextureFromSurface(_renderer, surf);
if( _texture == NULL )
return false;
// On libere la memoire
SDL_FreeSurface(surf);
surf = NULL;
*/
SDL_SetRenderDrawColor( _renderer, 0xFF, 0xFF, 0xFF, 0x00 );
return true; return true;
} }
@ -105,39 +76,25 @@ bool sdltl::setBackground(int r, int g, int b){
=========================================================*/ =========================================================*/
bool sdltl::setImage(const char *url){ bool sdltl::setImage(const char *url){
SDL_Surface *image = NULL;
image = SDL_LoadBMP( url );
// Si erreur de chargement image
if( image == NULL )
return false;
// On cree la texture associee // On cree la texture associee
_texture = SDL_CreateTextureFromSurface( _texture = IMG_LoadTexture( _renderer, url );
_renderer,
image
);
// On libere la surface pour l'image return _texture != NULL;
SDL_FreeSurface(image);
delete image;
return true;
} }
/* [ADD] Ajoute une texture au rendu principal /* [PUSH] Ajoute une texture au rendu principal
=========================================================*/ =========================================================*/
void sdltl::add(SDL_Texture *t, SDL_Rect *origin, SDL_Rect *dest){ void sdltl::push(SDL_Texture *t, SDL_Rect *src, SDL_Rect *dst){
_sprites.push_back( t ); _sprites.push_back( t );
_origins.push_back( origin ); _src.push_back( src );
_dests.push_back( dest ); _dst.push_back( dst );
} }
/* [REMOVE] Retire une texture du rendu principal /* [PULL] Retire une texture du rendu principal
=========================================================*/ =========================================================*/
void sdltl::remove(SDL_Texture *t){ void sdltl::pull(SDL_Texture *t){
// On cherche l'indice de la texture // On cherche l'indice de la texture
int index = -1; int index = -1;
@ -150,8 +107,8 @@ void sdltl::remove(SDL_Texture *t){
// On supprime la texture et ses dimensions // On supprime la texture et ses dimensions
_sprites.erase( _sprites.begin() + index ); _sprites.erase( _sprites.begin() + index );
_origins.erase( _origins.begin() + index ); _src.erase( _src.begin() + index );
_dests.erase( _dests.begin() + index ); _dst.erase( _dst.begin() + index );
} }
@ -159,21 +116,32 @@ void sdltl::remove(SDL_Texture *t){
/* [UPDATE] Mise a jour du rendu /* [UPDATE] Mise a jour du rendu
=========================================================*/ =========================================================*/
void sdltl::update(){ void sdltl::update(){
// On efface l'ecran
/* (1) On efface le rendu */
SDL_RenderClear(_renderer); SDL_RenderClear(_renderer);
// On ajoute le rendu principal au rendu
/* (2) On applique la couleur de fond */
SDL_Rect dRect; // On recupere les dimensions de la fenetre
SDL_GetWindowSize(_window, &dRect.w, &dRect.h);
SDL_RenderDrawRect(_renderer, &dRect);
/* (3) On ajoute le rendu principal (si existe) */
if( _texture != NULL) if( _texture != NULL)
SDL_RenderCopy(_renderer, _texture, NULL, NULL); SDL_RenderCopy(_renderer, _texture, NULL, NULL);
// On ajoute toutes les textures ajoutees
cout << "Update MAIN SPRITE +" << _sprites.size() << " added sprites.." << endl;
// for( int i = _sprites.size()-1 ; i >= 0 ; i-- )
for( int i = 0 ; i < _sprites.size() ; i++ )
SDL_RenderCopy(_renderer, _sprites[i], _origins[i], _dests[i]);
// On affiche le resultat /* (4) On ajoute toutes les textures pushees */
cout << "Update MAIN SPRITE +" << _sprites.size() << " added sprites.." << endl;
for( int i = 0 ; i < _sprites.size() ; i++ )
SDL_RenderCopy(_renderer, _sprites[i], _src[i], _dst[i]);
/* (n) On affiche le resultat */
SDL_RenderPresent(_renderer); SDL_RenderPresent(_renderer);
} }
/* [WAITEVENT] Attends un evenement pour executer /* [WAITEVENT] Attends un evenement pour executer

12
SDL#3/sdltl.h
View File

@ -5,6 +5,7 @@
/* [LIBS] Internes /* [LIBS] Internes
=========================================================*/ =========================================================*/
#include "SDL.h" #include "SDL.h"
#include "SDL_image.h"
#include <vector> #include <vector>
/* [LIBS] Externes /* [LIBS] Externes
@ -24,12 +25,13 @@
SDL_Window *window(); SDL_Window *window();
SDL_Renderer *renderer(); SDL_Renderer *renderer();
bool status(); bool status();
bool setBackground(int r=255, int g=255, int b=255); bool setBackground(Uint8 r=0xff, Uint8 g=0xff, Uint8 b=0xff, Uint8 a=0xff);
bool setImage(const char *url); bool setImage(const char *url);
void waitEvent(SDL_EventType t, void(*handler)(SDL_Event*) ); void waitEvent(SDL_EventType t, void(*handler)(SDL_Event*) );
void add(SDL_Texture *t, SDL_Rect *origin, SDL_Rect *dest); void push(SDL_Texture *t, SDL_Rect *origin, SDL_Rect *dest);
void remove(SDL_Texture *t); void pull(SDL_Texture *t);
void update(); void update();
void manageFps(const int fps=0); void manageFps(const int fps=0);
@ -48,8 +50,8 @@
SDL_Texture *_texture; SDL_Texture *_texture;
vector<SDL_Texture*> _sprites; vector<SDL_Texture*> _sprites;
vector<SDL_Rect*> _origins; vector<SDL_Rect*> _src;
vector<SDL_Rect*> _dests; vector<SDL_Rect*> _dst;
}; };