532 lines
12 KiB
C++
532 lines
12 KiB
C++
/* [CONSTRUCTOR] Constructeur de la classe
|
|
=========================================================*/
|
|
xManager::xManager(const char *t, int w, int h){
|
|
// default values
|
|
_lasttick = SDL_GetTicks();
|
|
_fpstime = 1000/60;
|
|
_window = NULL;
|
|
_renderer = NULL;
|
|
_texture = NULL;
|
|
|
|
_debug = (SDL_Rect){0, 0, 0, 0};
|
|
|
|
// Initialisation des sous-sys. SDL
|
|
SDL_Init( SDL_INIT_VIDEO | SDL_INIT_TIMER );
|
|
|
|
|
|
// Creation de la fenetre
|
|
_window = SDL_CreateWindow(
|
|
t,
|
|
SDL_WINDOWPOS_CENTERED,
|
|
SDL_WINDOWPOS_CENTERED,
|
|
w,
|
|
h,
|
|
SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_BORDERLESS | SDL_WINDOW_OPENGL
|
|
);
|
|
|
|
// Gestion erreur
|
|
if( _window == NULL )
|
|
return;
|
|
|
|
cerr << "WINDOW CREATED" << endl;
|
|
|
|
|
|
// On enregistre les dimensions de la fenetre
|
|
_winrect.x = 0; _winrect.y = 0;
|
|
_winrect.w = w; _winrect.h = h;
|
|
SDL_GetWindowSize(_window, &_winrect.w, &_winrect.h);
|
|
|
|
// Creation du renderer
|
|
_renderer = SDL_CreateRenderer(
|
|
_window,
|
|
-1,
|
|
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC
|
|
);
|
|
|
|
// Gestion erreur
|
|
if( _renderer == NULL )
|
|
return;
|
|
|
|
cerr << "RENDERER CREATED" << endl;
|
|
|
|
}
|
|
|
|
/* [DESTROYER] Destructeur de la classe
|
|
=========================================================*/
|
|
xManager::~xManager(){
|
|
SDL_DestroyTexture(_texture);
|
|
SDL_DestroyRenderer(_renderer);
|
|
SDL_DestroyWindow( _window );
|
|
SDL_Quit();
|
|
}
|
|
|
|
/* [STATUS] Retourne le status
|
|
=========================================================*/
|
|
bool xManager::status(){
|
|
return _window != NULL && _renderer != NULL;
|
|
}
|
|
|
|
|
|
/* [WINDOW] Retourne la fenetre
|
|
=========================================================*/
|
|
SDL_Window* xManager::window(){ return _window; }
|
|
|
|
|
|
/* [SCREEN] Retourne la fenetre
|
|
=========================================================*/
|
|
SDL_Renderer* xManager::renderer(){ return _renderer; }
|
|
|
|
|
|
/* [SETBACKGROUND] Modifie la couleur de fond
|
|
=========================================================*/
|
|
bool xManager::setBackground(Uint8 r, Uint8 g, Uint8 b, Uint8 a){
|
|
if( !this->status() ) return false;
|
|
|
|
|
|
SDL_SetRenderDrawColor( _renderer, r, g, b, a );
|
|
|
|
return true;
|
|
}
|
|
|
|
/* [SETIMAGE] Met une image en fond
|
|
=========================================================*/
|
|
bool xManager::setImage(const char *url){
|
|
if( !this->status() ) return false;
|
|
|
|
// On cree la texture associee
|
|
_texture = IMG_LoadTexture( _renderer, url );
|
|
|
|
return _texture != NULL;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* [HIT] Retourne si une texture est en collision avec une autre
|
|
=========================================================*/
|
|
// bool xManager::hit(SDL_Texture *current, int movex, int movey){
|
|
// // Anti conflit inter-thread
|
|
// _mutex_hit.try_lock();
|
|
|
|
|
|
// /* (1) On recupere le SDL_Rect destination du sprite courant */
|
|
// int xIndex = -1;
|
|
// for( int i = 0 ; i < _sprites.size() ; i++ )
|
|
// if( _sprites[i] == current )
|
|
// xIndex = i;
|
|
|
|
// if( xIndex == -1 ){
|
|
// _mutex_hit.unlock();
|
|
// return false;
|
|
// }
|
|
|
|
|
|
// SDL_Rect a = (SDL_Rect){
|
|
// (*_dst[xIndex]).x+movex,
|
|
// (*_dst[xIndex]).y+movey,
|
|
// (*_dst[xIndex]).w,
|
|
// (*_dst[xIndex]).h
|
|
// };
|
|
// SDL_Rect b;
|
|
|
|
// /* (2) On regarde si en dehors de la fenetre */
|
|
// for( int y = a.y ; y < a.y+a.h ; y++ )
|
|
// for( int x = a.x ; x < a.x+a.w ; x++ )
|
|
// if( x < _winrect.x || x > _winrect.x+_winrect.w || y < _winrect.y || y>_winrect.y+_winrect.h ){
|
|
// // On debloque la ressource
|
|
// _mutex_hit.unlock();
|
|
// return true;
|
|
// }
|
|
|
|
|
|
// /* (3) On compare avec toutes les autres textures */
|
|
// for( int i = 0 ; i < _sprites.size() ; i++ ){
|
|
|
|
// // Si c'est pas le sprite courant
|
|
// if( _sprites[i] != current ){
|
|
|
|
// // taille du sprite en cours
|
|
// b.x = (*_dst[i]).x;
|
|
// b.y = (*_dst[i]).y;
|
|
// b.w = (*_dst[i]).w;
|
|
// b.h = (*_dst[i]).h;
|
|
|
|
// for( int y = a.y ; y < a.y+a.h ; y++ )
|
|
// for( int x = a.x ; x < a.x+a.w ; x++ )
|
|
// if( x>=b.x && x<=b.x+b.w && y>=b.y && y<=b.y+b.h ){
|
|
// // On debloque la ressource
|
|
// _mutex_hit.unlock();
|
|
// return true;
|
|
// }
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
// // On debloque la ressource
|
|
// _mutex_hit.unlock();
|
|
// return false;
|
|
// }
|
|
|
|
|
|
|
|
/* [COLLIDE] Retourne si 2 objets sont en collision
|
|
=========================================================*/
|
|
bool xManager::collide(SDL_Rect a, SDL_Rect b){
|
|
if( !this->status() ) return true;
|
|
|
|
bool notCollide =
|
|
(a.x >= b.x+b.w ) // Inclus a droite
|
|
|| (a.x+a.w <= b.x ) // Inclus a gauche
|
|
|| (a.y >= b.y+b.h ) // Inclus en haut
|
|
|| (a.y+a.h <= b.y ); // Inclus en bas
|
|
|
|
// bool collide = (
|
|
// ( ( a.x > b.x && a.x < b.x+b.w )
|
|
// || ( a.x+a.w > b.x && a.x+a.w < b.x+b.w ) )
|
|
// &&
|
|
// ( ( a.y > b.y && a.y < b.y+b.h )
|
|
// || ( a.y+a.h > b.y && a.y+a.h < b.y+b.h ) )
|
|
// );
|
|
|
|
return !notCollide;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* [HIT] Retourne si une texture est en collision avec une autre
|
|
=========================================================*/
|
|
bool xManager::hit(xSprite* current, int movex, int movey){
|
|
if( !this->status() ) return true;
|
|
|
|
|
|
// Anti conflit inter-thread
|
|
_mutex_hit.try_lock();
|
|
|
|
/* (1) On recupere le SDL_Rect destination du sprite courant */
|
|
int xIndex = -1;
|
|
for( int i = 0 ; i < _sprites.size() ; i++ )
|
|
if( _sprites[i] == current ){
|
|
xIndex = i;
|
|
break;
|
|
}
|
|
|
|
if( xIndex == -1 ){
|
|
_mutex_hit.unlock();
|
|
return false;
|
|
}
|
|
|
|
|
|
SDL_Rect a = *current->dst();
|
|
a.x += movex;
|
|
a.y += movey;
|
|
|
|
// Contiendra le sens de collision
|
|
vector<int> collideFrom;
|
|
collideFrom.push_back( (movex!=0) ? (int)( movex / abs(movex) ) : 0 );
|
|
collideFrom.push_back( (movey!=0) ? (int)( movey / abs(movey) ) : 0 );
|
|
|
|
vector<int> collideTo;
|
|
collideTo.push_back( -collideFrom[0] );
|
|
collideTo.push_back( -collideFrom[1] );
|
|
|
|
|
|
/* (2) On regarde si en dehors de la fenetre */
|
|
if( (a.x < _winrect.x ) // Inclus a droite
|
|
|| (a.x+a.w > _winrect.x+_winrect.w ) // Inclus a gauche
|
|
|| (a.y < _winrect.y ) // Inclus en haut
|
|
|| (a.y+a.h > _winrect.y+_winrect.h ) // Inclus en bas
|
|
){
|
|
// Si on tombe, on meurt
|
|
if( a.y+a.h > _winrect.y+_winrect.h )
|
|
state = 2;
|
|
|
|
cerr << _indexes[xIndex] << " collide with WINDOW" << endl;
|
|
_mutex_hit.unlock();
|
|
return true;
|
|
}
|
|
|
|
|
|
/* (3) On compare avec toutes les autres textures */
|
|
for( int i = 0 ; i < _sprites.size() ; i++ ){
|
|
|
|
// Si c'est pas le sprite courant
|
|
if( _sprites[i] != current ){
|
|
|
|
// On verifie que le sprite n'entre pas en collision
|
|
if( this->collide(a, *(_sprites[i])->dst()) ){
|
|
|
|
|
|
// On lance les listeners de collision
|
|
_sprites[i]->onCollide(collideFrom, current);
|
|
current->onCollide(collideTo, _sprites[i]);
|
|
|
|
_debug = *(_sprites[i])->dst();
|
|
|
|
_mutex_hit.unlock();
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// On debloque la ressource
|
|
_mutex_hit.unlock();
|
|
return false;
|
|
}
|
|
|
|
|
|
/* [HIT] Retourne si une texture est en collision avec une autre
|
|
=========================================================*/
|
|
bool xManager::hit(string current, int movex, int movey){
|
|
if( !this->status() ) return true;
|
|
|
|
_mutex_hit.try_lock();
|
|
|
|
/* (1) On recupere le SDL_Rect destination du sprite courant */
|
|
xSprite *sprite = NULL;
|
|
sprite = this->get(current);
|
|
|
|
// Gestion erreur
|
|
if( sprite == NULL ){
|
|
_mutex_hit.unlock();
|
|
return false;
|
|
}
|
|
|
|
// Retour du resultat
|
|
_mutex_hit.unlock();
|
|
return this->hit(sprite, movex, movey);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* [GET] Renvoie le sprite
|
|
=========================================================*/
|
|
xSprite *xManager::get(string index){
|
|
if( !this->status() ) return NULL;
|
|
|
|
|
|
// On cherche la texture avec l'index
|
|
for( int i = 0 ; i < _indexes.size() ; i++ )
|
|
if( _indexes[i] == index )
|
|
return _sprites[i];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* [PUSH] Ajoute une texture au rendu principal
|
|
=========================================================*/
|
|
void xManager::push(string index, xSprite* sprite){
|
|
if( !this->status() ) return;
|
|
|
|
// On bloque l'acces inter-thread
|
|
_mutex_push.try_lock();
|
|
|
|
_indexes.push_back( index );
|
|
_sprites.push_back( sprite );
|
|
|
|
// On debloque l'acces
|
|
_mutex_push.unlock();
|
|
}
|
|
|
|
|
|
/* [PULL] Retire une texture du rendu principal
|
|
=========================================================*/
|
|
void xManager::pull(string index){
|
|
if( !this->status() ) return;
|
|
|
|
// On bloque l'acces inter-thread
|
|
_mutex_pull.try_lock();
|
|
|
|
// On cherche l'indice de la texture
|
|
int xIndex = -1;
|
|
|
|
for( int i = 0 ; i < _indexes.size() ; i++ )
|
|
if( _indexes[i] == index ) xIndex = i;
|
|
|
|
// Si on a rien trouve
|
|
if( xIndex == -1 )
|
|
return;
|
|
|
|
// On supprime la texture et ses dimensions
|
|
_indexes.erase( _indexes.begin() + xIndex );
|
|
_sprites.erase( _sprites.begin() + xIndex );
|
|
|
|
// On debloque l'acces
|
|
_mutex_pull.unlock();
|
|
}
|
|
|
|
|
|
/* [PULL] Retire une texture du rendu principal
|
|
=========================================================*/
|
|
void xManager::pull(xSprite* sprite){
|
|
if( !this->status() ) return;
|
|
|
|
// On bloque l'acces inter-thread
|
|
_mutex_pull.try_lock();
|
|
|
|
// On cherche l'indice de la texture
|
|
int xIndex = -1;
|
|
|
|
for( int i = 0 ; i < _sprites.size() ; i++ )
|
|
if( _sprites[i] == sprite ) xIndex = i;
|
|
|
|
// Si on a rien trouve
|
|
if( xIndex == -1 )
|
|
return;
|
|
|
|
// On supprime la texture et ses dimensions
|
|
_indexes.erase( _indexes.begin() + xIndex );
|
|
_sprites.erase( _sprites.begin() + xIndex );
|
|
|
|
// On debloque l'acces
|
|
_mutex_pull.unlock();
|
|
}
|
|
|
|
|
|
|
|
|
|
/* [CLEARALL] Supprime toutes les sprites
|
|
=========================================================*/
|
|
void xManager::clearAll(){
|
|
_indexes.erase( _indexes.begin(), _indexes.end() );
|
|
_sprites.erase( _sprites.begin(), _sprites.end() );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* [MANAGEFTP] Gestion de la vitesse de boucle
|
|
=========================================================*/
|
|
void xManager::manageFps(const int fps){
|
|
if( !this->status() ) return;
|
|
|
|
/* (1) Definition de fps */
|
|
if( fps != 0 )
|
|
_fpstime = 1000/fps;
|
|
|
|
if( _lasttick == 0 )
|
|
_lasttick = SDL_GetTicks()-_fpstime;
|
|
|
|
/* (2) Utilisation en fin de boucle */
|
|
|
|
// 1 > Si trop rapide, on attends
|
|
if( SDL_GetTicks()-_lasttick < _fpstime )
|
|
SDL_Delay( _fpstime - (SDL_GetTicks()-_lasttick) );
|
|
|
|
// On enregistre le temps actuel
|
|
_lasttick = SDL_GetTicks();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* [UPDATE] Mise a jour du rendu
|
|
=========================================================*/
|
|
void xManager::update(){
|
|
if( !this->status() ) return;
|
|
|
|
|
|
// cout << "Update MAIN SPRITE +" << _sprites.size() << " added sprites.." << endl;
|
|
// On bloque l'acces inter-thread
|
|
_mutex_update.try_lock();
|
|
|
|
/* (1) On efface le rendu */
|
|
SDL_RenderClear(_renderer);
|
|
|
|
|
|
/* (2) On applique la couleur de fond */
|
|
SDL_RenderDrawRect(_renderer, &_winrect);
|
|
|
|
|
|
/* (3) On ajoute le rendu principal (si existe) */
|
|
if( _texture != NULL)
|
|
SDL_RenderCopy(_renderer, _texture, NULL, NULL);
|
|
|
|
|
|
/* (4) On ajoute toutes les textures pushees */
|
|
for( int i = 0 ; i < _sprites.size() ; i++ )
|
|
SDL_RenderCopy(
|
|
_renderer,
|
|
_sprites[i]->texture(),
|
|
_sprites[i]->src(),
|
|
_sprites[i]->dst()
|
|
);
|
|
|
|
// DEBUG
|
|
_debug = (SDL_Rect){_debug.x-1, _debug.y-1, _debug.w+2, _debug.h+2};
|
|
SDL_RenderDrawRect(_renderer, &_debug);
|
|
|
|
/* (n) On affiche le resultat */
|
|
SDL_RenderPresent(_renderer);
|
|
|
|
// On debloque l'acces
|
|
_mutex_update.unlock();
|
|
}
|
|
|
|
/* [ATTACHEVENT] Ajoute une fonction a un type d'evenement
|
|
=========================================================*/
|
|
void xManager::attachEvent(SDL_EventType t, void(*handler)(SDL_Event*)){
|
|
if( !this->status() ) return;
|
|
|
|
|
|
// On attache le type d'evenement a la fonction
|
|
_events.push_back( t );
|
|
_handlers.push_back( handler );
|
|
}
|
|
|
|
|
|
|
|
|
|
/* [MANAGEEVENTS] Gestion des evenements
|
|
=========================================================*/
|
|
void xManager::manageEvents(SDL_Event *event){
|
|
if( !this->status() ) return;
|
|
|
|
// On lance les evenements en fonction de leur type
|
|
for( int i = 0 ; i < _events.size() ; i ++ )
|
|
if( event->type == _events[i] ) // si type ok
|
|
(*_handlers[i])(event); // on execute le handler
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* [DEBUG] Visualisation des donnees
|
|
=========================================================*/
|
|
void xManager::debug(){
|
|
for( int i = 0 ; i < _sprites.size() ; i++ ){
|
|
cerr << "INDEX: " << _indexes[i] << " AT " << i << endl;
|
|
cerr << " (" << (*_sprites[i]->dst()).x <<","<<(*_sprites[i]->dst()).y<<") -> (" << (*_sprites[i]->dst()).w << ", " << (*_sprites[i]->dst()).h << ")" << endl;
|
|
}
|
|
} |