Biblioteka graficzna dla SDL  1.2

W ubiegłych latach na zajęciach koła informatycznego w naszym liceum prowadzone były kursy tworzenia grafiki przy wykorzystaniu biblioteki graficznej SDL. Biblioteka ta jest darmowo dostępna do pobrania z sieci Internet. Sposób instalacji jest w miarę prosty i zależy od używanego środowiska programowania. W przypadku Code::Blocks postępujemy tak:

1. Ze strony projektu SDL pobieramy archiwum dla kompilatora Mingw32. Rozpakowujemy je do dowolnego katalogu na swoim dysku twardym. Powstanie katalog SDL-1.2.14 (nazwa może się nieco różnić, jeśli będziesz miał nowszą wersję).
2. Wewnątrz katalogu SDL-1.2.14 powinny się znajdować między innymi trzy poniższe katalogi:
       bin
       include
       lib
3. W katalogu bin znajduje się biblioteka dynamiczna SDL.dll. Należy ją przekopiować do katalogu C:\Windows\System32. Jeśli jest to niemożliwe (np. nie masz praw dostępu do tego katalogu), to bibliotekę SDL.dll należy umieścić w tym samym katalogu, co program exe - w przypadku Code::Blocks znajduje się on w katalogu bin\Debug lub bin\Release w katalogu projektowym. Biblioteka SDL.dll musi się również znaleźć w pakiecie dystrybucyjnym programu, który z niej korzysta.
4. Katalogi include oraz lib należy przekopiować do katalogu MingGW wewnątrz katalogu CodeBlocks. Po tej operacji w katalogu MingGW\include powinien znaleźć się katalog SDL z plikami nagłówkowymi biblioteki, a w katalogu MingGW/lib powinny się znaleźć trzy nowe pliki:
       libSDL.la
       libSDL.dll.a
       libSDLmain.a

Gdy biblioteka SDL zostanie już zainstalowana, możesz przejść do tworzenia programów. Za każdym razem procedura jest następująca:

1. Utwórz projekt Win32 GUI Project (pakiet Code::Blocks co prawda zawiera projekt SDL, ale lepiej z niego nie korzystaj, jeśli nie chcesz popaść w kłopoty).
2. W menu wybierz Project/Build Options.
3. W okienku dialogowym Project Build Options przejdź na zakładkę Linker settings
4. W prawym polu tekstowym Other linker options wpisz co następuje:
       -lmingw32
       -mwindows
       -lSDLmain
       -lSDL
5. Usuń z edytora szablon aplikacji Win32GUI i zamiast niej wpisz szablon aplikacji SDL:

// Szablon aplikacji SDL
// (C)2008 Koło Informatyczne
// I LO w Tarnowie
//-------------------------------

#include <SDL/SDL.h>

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

  if(!SDL_Init(SDL_INIT_VIDEO))
  {
    atexit(SDL_Quit);

  }
  return 0;
}

Instalację i projekt możesz przetestować na poniższym pliku:

// Test instalacji biblioteki SDL
// (C)2008 Koło Informatyczne
// I LO w Tarnowie
//-------------------------------

#include <SDL/SDL.h>

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

  if(!SDL_Init(SDL_INIT_VIDEO))
  {
    atexit(SDL_Quit);

    SDL_Surface * screen = SDL_SetVideoMode(321, 241, 32, SDL_HWSURFACE);

    Uint32 len = screen -> w;
    Uint32 * p;

    if(SDL_MUSTLOCK(screen)) SDL_LockSurface(screen);

    for(int x = 0; x < 321; x++)
      for(int y = 0; y < 241; y++)
      {
        p = (Uint32 *) screen -> pixels + y * len + x;
        * p = x % 16 ? (((x * 255) / 321)) +
                       ((((321 - x) * 255) / 642) << 8) +
                       (((y * 255) / 241) << 16) :
                       (((x * 255) / 321) << 16) +
                       ((((241 - y) * 255) / 241) << 8);
      }

    for(int x = 0; x < 321; x++)
      for(int y = 0; y < 241; y += 16)
      {
        p = (Uint32 *) screen -> pixels + y * len + x;
        * p = (((x * 255) / 321) << 16) +
              ((((241 - y) * 255) / 241) << 8);
      }

    if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen);

    SDL_UpdateRect(screen, 0, 0, 0, 0);

    int waiting = 0;

    do
    {
      SDL_Event event;
      while (SDL_PollEvent(&event))
        if ((event.type == SDL_QUIT) ||
           ((event.type == SDL_KEYDOWN) &&
            (event.key.keysym.sym == SDLK_ESCAPE))) waiting = 1;
    } while(!waiting);
  }
  return 0;
}

Jeśli wszystko jest zainstalowane prawidłowo, to powinno się pojawić poniższe okienko z grafiką:

Na kole informatycznym stworzyliśmy prostą bibliotekę graficzną, która pracuje w środowisku SDL i udostępnia wiele funkcji graficznych do rysowania po ekranie. Biblioteka ta składa się z dwóch plików:

newgfx.h - definicje stałych oraz prototypy funkcji bibliotecznych

newgfx.cpp - definicje funkcji bibliotecznych

Oba powyższe pliki najlepiej jest umieścić w katalogu projektowym. Plik nagłówkowy newgfx.h dołączamy wtedy do każdego programu za pomocą dyrektywy preprocesora:

#include "newgfx.h"

Nie ma już potrzeby osobnego dołączania pliku SDL.h, ponieważ newgfx.h zawiera to dołączenie.

Pliki newgfx.cpp oraz newgfx.h dołączamy do tworzonego projektu za pomocą opcji menu Project/Add files.

Po zainstalowaniu powyższych plików można w Code::Blocks zapisać szablon projektu, który dostępny będzie poprzez Create a new project/User templates.

Biblioteka newgfx pracuje TYLKO w trybie pikseli 32 bitowych. Inne tryby nie są obsługiwane. Nie stanowi to żadnych ograniczeń, ponieważ tryb 32-bitowy daje pełną gamę kolorów. Wszystkie funkcje biblioteczne mają nazwy rozpoczynające się od gfx w celu łatwej identyfikacji w kodzie programu. Większość funkcji występuje w dwóch odmianach - zwykłej, oraz z dodatkowym parametrem alpha, który określa przeźroczystość. Dla alpha = 0 obiekt jest całkowicie przeźroczysty, dla alpha = 256 jest całkowicie nieprzeźroczysty. Wartości pośrednie powodują prześwitywanie tła.

gfxBoundaryFill(screen,x,y,fcolor,bcolor)

Funkcja wypełnia kolorem fcolor obszar wskazany ziarnem x,y. Obszar jest ograniczony konturem (linią) w kolorze bcolor oraz prostokątem obcinającym screen -> clip_rect. Wszystkie piksele o kolorze różnym od bcolor zostaną pomalowane w obszarze na fcolor.

gfxCircle(screen,xs,ys,r,color)
gfxCircle(screen,xs,ys,r,color,alpha)

Funkcja rysuje okrąg o środku w punkcie (x_s,y_s), promieniu r i kolorze konturu color. Okrąg w całości musi się mieścić na powierzchni graficznej.

gfxClipCircle(screen,xs,ys,r,color)
gfxClipCircle(screen,xs,ys,r,color,alpha)

Funkcja rysuje okrąg o środku w punkcie (x_s,y_s), promieniu r i kolorze konturu color. Okrąg jest obcinany do prostokąta screen->clip_rect.

gfxClipEllipse(screen,xs,ys,rx,ry,color)
gfxClipEllipse(screen,xs,ys,rx,ry,color,alpha)

Funkcja rysuje elipsę o środku w punkcie (x_s,y_s), promieniach r_x, r_y i kolorze konturu color. Elipsa jest obcinana do prostokąta screen->clip_rect.

gfxClipHLine(screen,x,y,color,len)
gfxClipHLine(screen,x,y,color,len,alpha)

Funkcja rysuje odcinek poziomy na obszarze graficznym. Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen.

gfxClipLine(screen,x1,y1,x2,y2,color)
gfxClipLine(screen,x1,y1,x2,y2,color,alpha)

Funkcja rysuje odcinek od punktu początkowego (x₁,y₁) do punktu końcowego (x₂,y₂) wykorzystując algorytm Bresenhama. Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen.

gfxClipLineTo(screen,x,y,color)
gfxClipLineTo(screen,x,y,color,alpha)

Funkcja rysuje odcinek od punktu początkowego ustawionego przez funkcję gfxMoveTo() lub punktu końcowego ostatniego wywołania funkcji gfxLineTo() / gfxClipLineTo() / gfxWuLineTo() / gfxClipWuLineTo() do punktu (x,y). Punkt końcowy (x,y) staje się punktem początkowym dla kolejnego wywołania tej funkcji. Umożliwia to rysowanie łamanych, zbudowanych z odcinków połączonych końcami. Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen.

gfxClipORHLine(screen,x,y,color,len)

Funkcja rysuje odcinek poziomy na obszarze graficznym. Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen. Kolor jest łączony z tłem za pomocą funkcji OR.

gfxClipORLine(screen,x1,y1,x2,y2,color)

Funkcja rysuje odcinek od punktu początkowego (x₁,y₁) do punktu końcowego (x₂,y₂) wykorzystując algorytm Bresenhama. Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen. Kolor jest dodawany do tła za pomocą funkcji OR.

gfxClipORLineTo(screen,x,y,color)

Funkcja rysuje odcinek od punktu początkowego ustawionego przez funkcję gfxMoveTo() lub punktu końcowego ostatniego wywołania funkcji gfxLineTo() / gfxClipLineTo() / gfxWuLineTo() / gfxClipWuLineTo() do punktu (x,y). Punkt końcowy (x,y) staje się punktem początkowym dla kolejnego wywołania tej funkcji. Umożliwia to rysowanie łamanych, zbudowanych z odcinków połączonych końcami. Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen. Kolor jest dodawany do tła za pomocą funkcji OR.

gfxClipORPlot(screen,x,y,color)

Funkcja rysuje jeden punkt na powierzchni graficznej. Jeśli punkt (x,y) znajduje się poza prostokątem obcinającym w strukturze screen, nie będzie rysowany. Kolor jest dodawany do tła za pomocą funkcji OR.

gfxClipORPoly(s,f,color)

Funkcja rysuje łamaną zdefiniowaną przez listę f. Konstrukcja listy jest opisana przy funkcji gfxFillPoly(). Reaguje na prostokąt obcinania screen -> clip_rect. Kolor jest dodawany do tła za pomocą funkcji OR.

gfxClipORVLine(screen,x,y,color,len)

Funkcja rysuje odcinek pionowy na obszarze graficznym.  Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen. Kolor jest łączony z tłem za pomocą funkcji OR.

gfxClipPlot(screen,x,y,color)
gfxClipPlot(screen,x,y,color,alpha)

Funkcja rysuje jeden punkt na powierzchni graficznej. Jeśli punkt (x,y) znajduje się poza prostokątem obcinającym w strukturze screen, nie będzie rysowany.

gfxClipPoly(s,f,color)
gfxClipPoly(s,f,color,alpha)

Funkcja rysuje łamaną zdefiniowaną przez listę f. Konstrukcja listy jest opisana przy funkcji gfxFillPoly(). Reaguje na prostokąt obcinania screen -> clip_rect.

gfxClipRect(screen,r,color)
gfxClipRect(screen,r,color,alpha)

Funkcja rysuje prostokątną ramkę zdefiniowaną strukturą SDL_Rect. Ramka jest obcinana do prostokąta obcinającego w strukturze screen.

gfxClipVLine(screen,x,y,color,len)
gfxClipVLine(screen,x,y,color,len,alpha)

Funkcja rysuje odcinek pionowy na obszarze graficznym.  Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen.

gfxClipWuLine(screen,x1,y1,x2,y2,color)

Funkcja rysuje odcinek od punktu początkowego (x₁,y₁) do punktu końcowego (x₂,y₂) wykorzystując algorytm Xiaolin Wu. Punkty pośrednie są wygładzane. Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen.

gfxClipWuLineTo(screen,x,y,color)

Funkcja rysuje odcinek od punktu początkowego ustawionego przez funkcję gfxMoveTo() lub punktu końcowego ostatniego wywołania funkcji gfxLineTo() / gfxClipLineTo() / gfxWuLineTo() / gfxClipWuLineTo() do punktu (x,y). Punkt końcowy (x,y) staje się punktem początkowym dla kolejnego wywołania tej funkcji. Umożliwia to rysowanie łamanych, zbudowanych z odcinków połączonych końcami. Odcinek jest obcinany do prostokąta obcinającego zdefiniowanego w strukturze screen.

gfxClipWuPoly(s,f,color)

Funkcja rysuje wygładzoną łamaną zdefiniowaną przez listę f. Konstrukcja listy jest opisana przy funkcji gfxFillPoly(). Reaguje na prostokąt obcinania screen -> clip_rect.

gfxEllipse(screen,xs,ys,rx,ry,color)
gfxEllipse(screen,xs,ys,rx,ry,color,alpha)

Funkcja rysuje elipsę o środku w punkcie (x_s,y_s), promieniach r_x, r_y i kolorze konturu color. Elipsa w całości musi się mieścić na powierzchni graficznej.

gfxFillCircle(screen,xs,ys,r,color)
gfxFillCircle(screen,xs,ys,r,color,alpha)

Funkcja rysuje wypełnione kolorem color koło = o środku w punkcie (x_s,y_s) i promieniu r. Koło jest obcinane do prostokąta screen->clip_rect.

gfxFillEllipse(screen,xs,ys,rx,ry,color)
gfxFillEllipse(screen,xs,ys,rx,ry,color,alpha)

Funkcja rysuje owal o środku w punkcie (x_s,y_s), promieniach r_x, r_y i kolorze konturu color. Owal jest obcinany do prostokąta screen->clip_rect.

gfxFillPoly(s,f,color)
gfxFillPoly(s,f,color,alpha)

Funkcja wypełnia kolorem color obiekt wektorowy zbudowany z listy łamanych. Reaguje na prostokąt obcinania screen -> clip_rect.

Każda łamana rozpoczyna się od liczby określającej liczbę wierzchołków. Jeśli liczba ta ma wartość 0, to oznacza to koniec listy łamanych. Za liczbą wierzchołków następują pary współrzędnych x,y określające położenie wierzchołków na płaszczyźnie graficznej.

Przykład:

3 12 1 14 5 1 1 2 5 3 4 7 0

Ten obiekt składa się z dwóch łamanych:

 3  12 1 14 5 1 1    2  5 3 4 7   0

Pierwsza łamana posiada trzy wierzchołki: (12,1), (14,5) i (1,1).
Druga łamana posiada tylko dwa wierzchołki: (5,3) i (4,7).
Ostatnie zero oznacza koniec listy łamanych.

Listę łamanych można utworzyć w tablicy o odpowiedniej wielkości. Na przykład tak:

Sint32 obj[] = {3, 12, 1, 14, 5, 1, 1, 2, 5, 3, 4, 7, 0};

gfxFloodFill(screen,x,y,fcolor)

Funkcja wypełnia kolorem fcolor obszar wskazany ziarnem x,y. Obszar posiada jednolity kolor oraz jest ograniczony obszarami w innych kolorach i prostokątem obcinającym screen -> clip_rect.

gfxGetPixel(screen,x,y)

Funkcja zwraca 32 bitowy kod koloru piksela umieszczonego na pozycji x,y powierzchni graficznej. Współrzędne x i y muszą zawierać się w obszarze graficznym.

gfxHLine(screen,x,y,color,len)
gfxHLine(screen,x,y,color,len,alpha)

Funkcja rysuje odcinek poziomy na obszarze graficznym. Odcinek w całości powinien się zawierać w tym obszarze.

gfxLibVersion()

Funkcja zwraca tekst z numerem wersji biblioteki graficznej newgfx. Istnieje tylko dla celów testowych w trakcie instalacji oprogramowania.

gfxLine(screen,x1,y1,x2,y2,color)
gfxLine(screen,x1,y1,x2,y2,color,alpha)

Funkcja rysuje odcinek od punktu początkowego (x₁,y₁) do punktu końcowego (x₂,y₂) wykorzystując algorytm Bresenhama. Punkt początkowy i końcowy musi zawierać się w powierzchni graficznej.

gfxLineTo(screen,x,y,color)
gfxLineTo(screen,x,y,color,alpha)

Funkcja rysuje odcinek od punktu początkowego ustawionego przez funkcję gfxMoveTo() lub punktu końcowego ostatniego wywołania funkcji gfxLineTo() / gfxClipLineTo() / gfxWuLineTo() / gfxClipWuLineTo() do punktu (x,y). Punkt końcowy (x,y) staje się punktem początkowym dla kolejnego wywołania tej funkcji. Umożliwia to rysowanie łamanych, zbudowanych z odcinków połączonych końcami. Punkt początkowy i końcowy rysowanego odcinka muszą zawierać się w powierzchni graficznej screen.

gfxMoveTo(x,y)

Funkcja współpracuje z gfxLineTo() / gfxClipLineTo() / gfxWuLineTo() / gfxClipWuLineTo(). Ustawia punkt początkowy odcinka

gfxORFillPoly(s,f,color)

Funkcja wypełnia kolorem color obiekt wektorowy zbudowany z listy łamanych. Reaguje na prostokąt obcinania screen -> clip_rect. Kolor jest łączony z tłem za pomocą funkcji OR.

gfxORHLine(screen,x,y,color,len)

Funkcja rysuje odcinek poziomy na obszarze graficznym. Odcinek w całości powinien się zawierać w tym obszarze. Kolor jest łączony z tłem za pomocą funkcji OR.

gfxORLine(screen,x1,y1,x2,y2,color)

Funkcja rysuje odcinek od punktu początkowego (x₁,y₁) do punktu końcowego (x₂,y₂) wykorzystując algorytm Bresenhama. Punkt początkowy i końcowy musi zawierać się w powierzchni graficznej. Kolor jest dodawany do tła funkcją OR.

gfxORLineTo(screen,x,y,color)

Funkcja rysuje odcinek od punktu początkowego ustawionego przez funkcję gfxMoveTo() lub punktu końcowego ostatniego wywołania funkcji gfxLineTo() / gfxClipLineTo() / gfxWuLineTo() / gfxClipWuLineTo() do punktu (x,y). Punkt końcowy (x,y) staje się punktem początkowym dla kolejnego wywołania tej funkcji. Umożliwia to rysowanie łamanych, zbudowanych z odcinków połączonych końcami. Punkt początkowy i końcowy rysowanego odcinka muszą zawierać się w powierzchni graficznej screen. Kolor jest dodawany do tła funkcją OR.

gfxORPlot(screen,x,y,color)

Funkcja rysuje jeden punkt na powierzchni graficznej. Punkt musi się zawierać w tej powierzchni, tzn jego współrzędne nie mogą wykraczać poza marginesy, w przeciwnym wypadku może dojść do zamknięcia aplikacji z powodu naruszenia praw dostępu do chronionych obszarów pamięci. Kolor jest dodawany do tła funkcją OR.

gfxORPoly(s,f,color)

Funkcja rysuje łamaną zdefiniowaną przez listę f. Konstrukcja listy jest opisana przy funkcji gfxFillPoly(). Łamana w całości musi się mieścić na obszarze graficznym. Kolor jest dodawany do tła funkcją OR.

gfxORVLine(screen,x,y,color,len)

Funkcja rysuje odcinek pionowy na obszarze graficznym. Odcinek w całości powinien się zawierać w tym obszarze. Kolor jest łączony z tłem za pomocą funkcji OR.

gfxPlot(screen,x,y,color)
gfxPlot(screen,x,y,color,alpha)

Funkcja rysuje jeden punkt na powierzchni graficznej. Punkt musi się zawierać w tej powierzchni, tzn jego współrzędne nie mogą wykraczać poza marginesy, w przeciwnym wypadku może dojść do zamknięcia aplikacji z powodu naruszenia praw dostępu do chronionych obszarów pamięci.

gfxPoly(s,f,color)
gfxPoly(s,f,color,alpha)

Funkcja rysuje łamaną zdefiniowaną przez listę f. Konstrukcja listy jest opisana przy funkcji gfxFillPoly(). Łamana w całości musi się mieścić na obszarze graficznym.

gfxRect(screen,r,color)
gfxRect(screen,r,color,alpha)

Funkcja rysuje prostokątną ramkę zdefiniowaną strukturą SDL_Rect. Ramka w całości musi się zawierać w obszarze graficznym.

gfxVLine(screen,x,y,color,len)
gfxVLine(screen,x,y,color,len,alpha)

Funkcja rysuje odcinek pionowy na obszarze graficznym. Odcinek w całości powinien się zawierać w tym obszarze.

gfxWuLine(screen,x1,y1,x2,y2,color)

Funkcja rysuje odcinek od punktu początkowego (x₁,y₁) do punktu końcowego (x₂,y₂) wykorzystując algorytm Xiaolin Wu. Punkt początkowy i końcowy musi zawierać się w powierzchni graficznej. Punkty pośrednie są wygładzane.

gfxWuLineTo(screen,x,y,color)

Funkcja rysuje wygładzony odcinek od punktu początkowego ustawionego przez funkcję gfxMoveTo() lub punktu końcowego ostatniego wywołania funkcji gfxLineTo() / gfxClipLineTo() / gfxWuLineTo() / gfxClipWuLineTo() do punktu (x,y). Punkt końcowy (x,y) staje się punktem początkowym dla kolejnego wywołania tej funkcji. Umożliwia to rysowanie łamanych, zbudowanych z odcinków połączonych końcami. Punkt początkowy i końcowy rysowanego odcinka muszą zawierać się w powierzchni graficznej screen.

gfxWuPoly(s,f,color)

Funkcja rysuje łamaną zdefiniowaną przez listę f. Konstrukcja listy jest opisana przy funkcji gfxFillPoly(). Łamana w całości musi się mieścić na obszarze graficznym.