SDL - 2. lekce

V této lekci se naučíte vykreslit na pozici X a Y barevný pixel podle stupnice RGB...

Ještě než se pustíme do vykreslení bitmapy, ukážu vám funkci pro vykreslení barevného pixelu na určitou pozici. Budeme k tomu potřebovat kód z první lekce, a proto jej nyní najděte a otevřete.

Ikdyž se vykreslení pixelu může zdát jako jednoduchá věc, je to poměrně složitá záležitost. Ale my si nyní napíšeme funkci, která vše udělá za vás. Dovolil jsem si ji půjčit z tutoriálů od Mariuse Andry, kterému ještě jednou děkuji. Nemusíte všemu v této funkci rozumět, stačí pouze když ji opíšete. Napište tuto funkci nejlépe někde před hlavní funkci main(), nemusíte potom dělat ani prototyp funkce:

void DrawPixel(SDL_Surface *screen, int x, int y,
                       Uint8 R, Uint8 G, Uint8 B){

  Uint32 color = SDL_MapRGB(screen->format, R, G, B);
  switch (screen->format->BytesPerPixel)
  {
    case 1:
      {
        Uint8 *bufp;
        bufp = (Uint8 *)screen->pixels + y*screen->pitch + x;
        *bufp = color;
      }
      break;
    case 2:
      {
        Uint16 *bufp;
        bufp = (Uint16 *)screen->pixels + y*screen->pitch/2 + x;
        *bufp = color;
      }
      break;
    case 3:
      {
        Uint8 *bufp;
        bufp = (Uint8 *)screen->pixels + y*screen->pitch + x * 3;
        if(SDL_BYTEORDER == SDL_LIL_ENDIAN)
        {
          bufp[0] = color;
          bufp[1] = color >> 8;
          bufp[2] = color >> 16;
        } else {
          bufp[2] = color;
          bufp[1] = color >> 8;
          bufp[0] = color >> 16;
        }
      }
      break;
    case 4:
      {
        Uint32 *bufp;
        bufp = (Uint32 *)screen->pixels + y*screen->pitch/4 + x;
        *bufp = color;
      }
      break;
  }
}

Kód je tak dlouhý, protože to vykresluje různě podle hodnoty BPP (barevná hloubka). První parametr funkce je vrstva (surface), na kterou se pixel vykreslí. Druhý parametr je pro pozici na ose X daného pixelu a třetí pro osu Y. Čtvrtý, pátý a šestý parametr určuje hodnotu červené, zelené a modré barvy pixelu od 0 do 255.

Ikdyž už máme funkci pro vykreslení pixelu, ještě to není vše. U některých grafických karet totiž při vykreslování musíme vrstvu "zamknout", a proto si ještě napíšeme dvě funkce. Jedna vrstvu v případě nutnosti zamkne a druhá ji pak po vykreslení odemkne. Tyto funkce opět napište kamkoli před hlavní funkci main():

void Lock(SDL_Surface *screen){
  if ( SDL_MUSTLOCK(screen) ){
    if ( SDL_LockSurface(screen) < 0 ){
      exit(1);
    }
  }
}

void Unlock(SDL_Surface *screen){
  if ( SDL_MUSTLOCK(screen) ){
    SDL_UnlockSurface(screen);
  }
}

Funkce Lock() zjistí, zda-li je nutno vrstvu zamknout a pokud ano, tak to provede funkcí SDL_LockSurface(). Pokud má tato funkce návratovou hodnotu 0, je vše vpořádku a vrstva je odemknuta, ale pokud je návratová hodnota menší než 0, program se chybově ukončí. Funkce Unlock() opět zjistí, jestli je zamknutí nutné (a tím pádem jestli je vrstva zamčena) a v tom případě vrstvu odemkne.

A nyní už k vykreslování. Pro přehlednost si vytvoříme funkci DrawScene(), do které vše budeme vykreslovat. Buďte si ale jisti, že je tato funkce umístěna hned před funkci main(), tentokrát je to důležité. Umíme sice vykreslit jen jeden pixel, ale my si jich pomocí cyklu for vykreslíme celé okno a uděláme zajímavý barevný efekt. Takže funkce DrawScene() může vypadat třeba takto:

void DrawScene(SDL_Surface *screen){
  Lock(screen);

  for(int x=0; x<800; x++){
    for(int y=0; y<600; y++){
      DrawPixel(screen, x, y, x/4, y/3, x/8 + y/6);
    }
  }

  Unlock(screen);
  SDL_Flip(screen);
}

Naše funkce má i jeden parametr, a to vrstvu, kterou zamkneme, vykreslíme na ní pixely a pak odemkneme. Po zamknutí vrstvy se spustí cyklus, který vykreslí na každou pozici v našem okně pixel o různých barvách podle hodnot X a Y. Protože má naše okno rozměry 800×600, tak se pixel na ose Y vykreslí 600× a toto vykreslení na ose Y se opakuje 800× po ose X. Tím zaplníme pixely celé okno. Hodnoty červené, zelené a modré barvy jednotlivých pixelů jsou dány různě podle současné pozice pixelů a jsou vyděleny přibližně tak, aby nepřesahovaly maximální hodnotu 255. Nakonec vrstvu zamkneme. A jelikož používáme doublebuffering, bylo všechno zatím vykreslováno jen do paměti a na obrazovku musíme vše teprve vykreslit pomocí příkazu SDL_Flip().

A nyní už jen funkci DrawScene() s parametrem našeho okna screen připíšeme do hlavní smyčky našeho programu ve funkci main() z minulé lekce. Také bych chtěl ještě vyřešit problém se zavíráním okna, připsáním pár řádků s událostmi do této smyčky, avšak vysvětlím vám to až v lekci, kdy budeme brát ovládání klávesnicí. Zatím to prostě jen opište:

while(done == false){
  SDL_Event event;
  while( SDL_PollEvent(&event) ){
    if( event.type == SDL_QUIT ) done=true;
  }

  DrawScene(screen);
}

Toť z této lekce vše. Pokud je vše v pořádku, mělo by se vám otevřít barevné okno a mělo by jít normálně zavřít. Příště si ukážeme vykreslování BMP obrázků.

A tady je zdrojový kód celé lekce:

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

void DrawPixel(SDL_Surface *screen, int x, int y,
                       Uint8 R, Uint8 G, Uint8 B){

  Uint32 color = SDL_MapRGB(screen->format, R, G, B);
  switch (screen->format->BytesPerPixel)
  {
    case 1:
      {
        Uint8 *bufp;
        bufp = (Uint8 *)screen->pixels + y*screen->pitch + x;
        *bufp = color;
      }
      break;
    case 2:
      {
        Uint16 *bufp;
        bufp = (Uint16 *)screen->pixels + y*screen->pitch/2 + x;
        *bufp = color;
      }
      break;
    case 3:
      {
        Uint8 *bufp;
        bufp = (Uint8 *)screen->pixels + y*screen->pitch + x * 3;
        if(SDL_BYTEORDER == SDL_LIL_ENDIAN)
        {
          bufp[0] = color;
          bufp[1] = color >> 8;
          bufp[2] = color >> 16;
        } else {
          bufp[2] = color;
          bufp[1] = color >> 8;
          bufp[0] = color >> 16;
        }
      }
      break;
    case 4:
      {
        Uint32 *bufp;
        bufp = (Uint32 *)screen->pixels + y*screen->pitch/4 + x;
        *bufp = color;
      }
      break;
  }
}

void Lock(SDL_Surface *screen){
  if ( SDL_MUSTLOCK(screen) ){
    if ( SDL_LockSurface(screen) < 0 ){
      exit(1);
    }
  }
}

void Unlock(SDL_Surface *screen){
  if ( SDL_MUSTLOCK(screen) ){
    SDL_UnlockSurface(screen);
  }
}

void DrawScene(SDL_Surface *screen){
  Lock(screen);

  for(int x=0;x<800;x++){
    for(int y=0;y<600;y++){
      DrawPixel(screen, x, y, x/4, y/3, x/8 + y/6);
    }
  }

  Unlock(screen);
  SDL_Flip(screen);
}

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

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

  atexit(SDL_Quit);

  SDL_Surface *screen;
  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);
  }

  bool done=false;

  while(done == false){
    SDL_Event event;
    while( SDL_PollEvent(&event) ){
      if( event.type == SDL_QUIT ) done=true;
    }
    
    DrawScene(screen);
  }

}