Vytvoříme si jednoduchý časovač (timer), podle kterého budeme střídat snímky animace a ukážeme si, jak nastavit alfa kanál vrstvy...

Pokud chcete v určitém časovém intervalu provádět určitou akci (přičtení proměnné apod.), je asi nejlepší řešení použít systémový timer. Stačí jen nastavit pár parametrů a o nic dalšího se nemusíte starat. V této lekci si však napíšeme vlastní jednoduchý časovač, kterým si demonstrujeme funkci SDL_GetTicks(). Systémový timer si ukážeme až v lekci následující.

Začneme tím, že smažeme řádek na konci funkce main(), který inkrementuje proměnnou frame...

if(frame++ == 3) frame=0;

...a nahradíme jej voláním funkce ChangeFrame(), kterou si za chvíli vytvoříme.

ChangeFrame();

Vytvoříme si globální proměnné nutné pro fungování našeho timeru. Proměnná interval určuje interval timeru v milisekundách. Počáteční hodnotu si sami nastavte podle toho, jak rychle chcete střídat snímky animace. Do proměnné now se při každém opakování funkce ChangeFrame() načte aktuální čas, proměnná previous bude uchovávat čas z minulého volání této funkce a za pomoci proměnné elapsed budeme kontrolovat, zdali už byl překročen interval a můžeme provést danou akci. Typ těchto proměnných je Uint32, což je něco jako int v klasickém C++.

Uint32 interval=300;
Uint32 now;
Uint32 previous;
Uint32 elapsed;

Nyní k slibované funkci ChangeFrame(). Nejprve do proměnné now načteme aktuální čas funkcí SDL_GetTicks(). Tato funkce nevrací přímo čas, ze kterého poznáte, kolik je hodin. Číslo, které vrací, nic konkrétního neznamená. Pro nás je však důležité, že se tato hodnota průběžně mění a přibližně každou milisekundu (tisícinu sekundy) se navýší o jednu.

void ChangeFrame(void){
  now = SDL_GetTicks();

K proměnné elapsed přičteme rozdíl současného času a času z minulého volání funkce ChangeFrame(). Na dalším řádku načteme do proměnné previous současný čas z proměnné now a při dalším volání funkce ChangeFrame() ho budeme používat jako předešlý.

  elapsed += now-previous;
  previous = now;

A na konci funkce ChangeFrame() zjistíme, jestli už hodnota proměnné elapsed nepřekročila interval, a pokud ano, tak inkrementujeme proměnnou frame a proměnnou elapsed vynulujeme. Jednoduše řečeno, pokud od minulé změny snímku uběhl námi určený čas, přejde animace na další snímek a uplynulý čas počítáme odznovu.

  if(elapsed > interval){
    if(frame++ == 3) frame=0;
    elapsed=0;
  }
}

K timeru je to vše. Samozřejmě není na milisekundu přesný, ale pro naše potřeby zatím stačí.

Alfa kanál vrstvy určuje její průsvitnost. Můžete jej nastavit funkcí SDL_SetAlpha(). Vyvoláme si ji opět někde pod funkcí LoadImages(), ikdyž na jejím umístění přímo nezáleží. První parametr je vrstva, která se má zprůhlednit, druhý parametr by měl být pro běžné použití vždy SDL_SRCALPHA a třetí parametr určuje míru průhlednosti (0-255).

SDL_SetAlpha(image, SDL_SRCALPHA, 128);

Tímto kódem jsme si nastavili poloviční průhlednost vrstvy image. Čím je třetí parametr menší, tím je vrstva průhlednější a naopak. Nula tedy znamená úplnou průhlednost a 255 žádnou.

Zde je zdrojový kód lekce:

#include <SDL/SDL.h>
#include <stdio.h>
#include <stdlib.h>

SDL_Surface *screen;
SDL_Surface *image;
SDL_Surface *background;

int image_x, image_y;
int frame=0;

Uint32 interval=300;
Uint32 now;
Uint32 previous;
Uint32 elapsed;

void ChangeFrame(void){
  now = SDL_GetTicks();
  elapsed += now-previous;
  previous = now;
  
  if(elapsed > interval){
    if(frame++ == 3) frame=0;
    elapsed=0;
  }
}

void LoadImages(){
  image = SDL_LoadBMP("image.bmp");
  background = SDL_LoadBMP("bg.bmp");
}

void DrawIMG(SDL_Surface *img, int x, int y){
  SDL_Rect rect;
  rect.x = x;
  rect.y = y;
  SDL_BlitSurface(img, NULL, screen, &rect);
}

void DrawIMG(SDL_Surface *img, int x, int y, int w, int h, int x2, int y2){
  SDL_Rect rect;
  rect.x = x;
  rect.y = y;
  SDL_Rect rect2;
  rect2.x = x2;
  rect2.y = y2;
  rect2.w = w;
  rect2.h = h;
  SDL_BlitSurface(img, &rect2, screen, &rect);
}


void DrawScene(){
  DrawIMG(background, image_x-1, image_y-1, 130, 130, image_x-1, image_y-1);
  DrawIMG(image, image_x, image_y, 128, 128, frame*128, 0);
  SDL_Flip(screen);
}

int main(int argc, char *argv[]){

  Uint8* keys;

  if( SDL_Init(SDL_INIT_VIDEO) < 0 ){
    printf("Inicializace SDL se nezdařila: %s
", SDL_GetError());
    exit(1);
  }

  atexit(SDL_Quit);
  screen = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);

  if ( screen == NULL ){
    printf("Vytvoření okna se nezdařilo: %s
", SDL_GetError());
    exit(1);
  }
  
  LoadImages();
  DrawIMG(background, 0, 0);
  SDL_SetColorKey(image, SDL_SRCCOLORKEY, SDL_MapRGB(image->format, 0, 0, 0));
  SDL_SetAlpha(image, SDL_SRCALPHA, 128);
  
  bool done=false;

  while(done == false){
    SDL_Event event;
    while(SDL_PollEvent(&event)){
      if(event.type == SDL_QUIT) done = true;
      if(event.type == SDL_KEYUP){
        if(event.key.keysym.sym == SDLK_RETURN) done = true;
      }
    }
    
    keys = SDL_GetKeyState(NULL);
    if(keys[SDLK_RIGHT]) image_x += 1;
    if(keys[SDLK_LEFT]) image_x -= 1;
    if(keys[SDLK_DOWN]) image_y += 1;
    if(keys[SDLK_UP]) image_y -= 1;
    
    DrawScene();
    ChangeFrame();
  }

}