Aby to zadziałało musisz posiadać wersję biblioteki SDL odpowiednią dla systemu operacyjnego, na którym pracujesz. Sposób komunikacji z biblioteką SDL jest taki sam. Wiele rzeczy biblioteka robi za ciebie, dzięki czemu twój program stanie się prostszy i bardziej przejrzysty niż gdyby był pisany pod docelowy system operacyjny. Programy pisane pod SDL są nieco wolniejsze od tych, które bezpośrednio współpracują z systemem, lecz jest to praktycznie niezauważalne – współczesne komputery są zbyt szybkie – a i tak 99% czasu komputer czeka, aż użytkownik coś zrobi.

Biblioteka SDL została napisana w języku C (Unix, Linux i Windows też), jednak wspiera środowisko programowania w C++ (inne języki też, ale tym nie będziemy się tutaj zajmować). Daje niskopoziomowy dostęp do różnych urządzeń (myszka, joystick, kontrolery gier, klawiatura, sprzęt 3D, bufor ekranu, odtwarzanie dźwięku, liczniki czasu, wątki, itp.). SDL było stosowane w wielu grach komputerowych, np. Neverwinter Nights, Second Life. Użyto je przy konwersji do systemu Linuks takich kultowych pozycji jak: Quake 4, Soldier of Fortune  czy Civilisation.  Krąg zastosowań SDL nie ogranicza się jedynie do gier komputerowych. Można je używać wszędzie tam, gdzie potrzebna jest dobra grafika lub obsługa urządzeń wejścia/wyjścia.

Biblioteka SDL składa się z ponad 500 funkcji, których opis znajdziesz w rozdziałach: Interfejs SDL2 wg nazw oraz Interfejs SDL2 wg kategorii.

Aby efektywnie skorzystać z tego kursu, musisz już umieć programować w języku C++. Nauką programowania tutaj się niestety nie zajmujemy, chociaż niektóre zagadnienia wyjaśniam dla początkujących programistów.

Istnieją wersje Code Blocks dla systemów Windows oraz Linuks, które w obu tych systemach wyglądają i działają praktycznie tak samo. Korzystając z podanych niżej instrukcji, zainstaluj na swoim komputerze Code Blocks.

Poniższy opis dotyczy instalacji CodeBlocs 20.03 w systemie Windows 10. Dla innych systemów Windows instalacja jest praktycznie identyczna.

Pobranie instalatora

Przejdź do strony:

http://www.codeblocks.org/downloads

Wybierz opcję:

Download the binary release

Spowoduje to przejście do strony pobierania aplikacji. U samej góry wybierz swój system operacyjny, mianowicie Windows XP / Vista / 7 / 8.x / 10. 

Dla systemu Windows dostępne jest kilka wersji instalatora CodeBlocks. Dla naszych potrzeb należy wybrać instalator z kompilatorem MingW. W przypadku wersji 20.03 będzie to plik o nazwie codeblocks-20.03mingw-setup.exe. Plik ten zawiera kompilator MingW oraz instalator.

Po prawej stronie wybierz źródło ładowania: Sourceforge.net. Przejdziesz w ten sposób do witryny Sourceforge, z której zostanie automatycznie załadowany instalator CodeBlocks. Jeśli twoją przeglądarką sieci jest Firefox, to pojawi się okienko:

Instalacja

Uruchom instalator (musisz mieć uprawnienie administratora). Zaczną się pojawiać kolejne okienka dialogowe instalacji. Poniżej masz przetłumaczoną ich treść. Jest to typowy proces instalacyjny i, jeśli nie masz jakiś specjalnych powodów, to po prostu zatwierdzaj okienka klikając na przycisk Next.

	Witaj w Programie Instalacyjnym CodeBlocks
	Program instalacyjny poprowadzi cię poprzez instalację CodeBlocks. Zalecane jest zamknięcie wszystkich innych aplikacji przed uruchomieniem instalacji. Pozwoli to uaktualnić istotne pliki systemowe bez potrzeby ponownego uruchomienia komputera. Aby kontynuować, kliknij Dalej.
	Dalej >    Anuluj
	Zgoda licencyjna     Proszę przeglądnąć warunki licencji przed instalacją CodeBlocks.
	Naciśnij klawisz PgDn, aby zobaczyć resztę zgody licencyjnej.  Treść licencji GNU Jeśli zgadzasz się na warunki zgody licencyjnej, kliknij przycisk Zgadzam się. Musisz zaakceptować zgodę licencyjną, aby zainstalować CodeBlocks.
	< Wstecz     Zgadzam się    Anuluj
	Wybierz Składniki     Wybierz, które cechy CodeBlocks chcesz zainstalować.
	Zaznacz składniki, które chcesz zainstalować, a skasuj zaznaczenie dla tych, których nie chcesz instalować. Kliknij Dalej, aby kontynuować. Wybierz rodzaj instalacji: Pełna instalacja: wszystkie wtyczki, wszystkie narzędzia, po prostu wszystko Lub wybierz opcjonalne składniki, które chcesz zainstalować  Drzewo składników Wymagane miejsce: 531,5 MB Opis Umieść kursor myszki ponad składnikiem, aby zobaczyć jego opis.
	< Wstecz     Dalej >    Anuluj
	Wybierz Miejsce Instalacji     Wybierz katalog, w którym zostanie zainstalowane CodeBlocks.
	Program instalacyjny zainstaluje CodeBlocks w następującym katalogu. Aby zainstalować w innym, kliknij przycisk Przeglądaj... i wybierz inny katalog. Kliknij przycisk Instaluj, aby rozpocząć instalację. Katalog Docelowy  C:\Program Files\CodeBlocks   Przeglądaj... Wymagane miejsce: 531,5 MB Dostępne miejsce: 1559,2 GB (u ciebie może być inna wartość)
	< Wstecz     Instaluj >    Anuluj
	Instalowanie     Proszę poczekać w trakcie instalacji CodeBlocks.
	< Wstecz     Dalej >    Anuluj
	Instalacja Zakończona Instalacja zakończyła się sukcesem.
	< Wstecz     Dalej >    Anuluj
	Kończenie Instalacji CodeBlocks CodeBlocks zostało zainstalowane na twoim komputerze. Kliknij przycisk Zakończ, aby zakończyć program instalacyjny.
	< Wstecz     Zakończ >    Anuluj

Gdy instalacja się zakończy, należy sprawdzić jej poprawność.

Uruchom CodeBlocks.

Przygotuj na swoim dysku katalog na projekty programów. Ja taki katalog utworzyłem sobie na dysku F:\cprj. Ty możesz wybrać inne miejsce.

Gdy masz już katalog, to w oknie startowym CodeBlocks kliknij opcję Create a new project (utwórz jakiś nowy projekt). Pojawi się okienko tworzenia nowego projektu z szablonu:

Zaznacz Console application i kliknij przycisk Go (naprzód).

W pierwszym oknie wybierasz język programowania. Zaznacz C++, o ile nie jest już zaznaczony.

Kliknij Next. Następne okno ustala nazwę projektu oraz katalog, w którym projekt zostanie utworzony.

W polu Project title (tytuł projektu) wpisz nazwę dla swojego projektu, np. test. W polu Folder to create project in (katalog na projekt) wpisz pełną ścieżkę do katalogu, który wcześniej sobie utworzyłeś na dysku. U mnie jest to F:\cprj, ale u ciebie katalog może być w innym miejscu i mieć inną nazwę. Pozostałych dwóch pól nie zmieniaj, kliknij w przycisk Next.

Następne okienko wybiera kompilator oraz dostępne konfiguracje uruchomieniowe.

Nic tu nie zmieniaj, kliknij Finish.

Konfiguracja Debug (odpluskwianie) jest używana przy testowaniu programu. Standardowo zostaje ona ustawiona na początku pracy nad projektem (później możesz ją sobie zmienić). W tym trybie kompilator umieszcza w kodzie programu różne dodatkowe informacje (np. nazwy zmiennych i funkcji) dla Debuggera, czyli programu uruchomieniowego, który pozwala śledzić wykonywanie programu i w ten sposób wyszukiwać w nim błędy. W konfiguracji Release (wydawnicza) informacje te nie są umieszczane, przez co kod programu jest krótszy i zwykle pracuje szybciej. Jednakże program nie może być śledzony za pomocą Debuggera. Konfigurację tą stosuje się, gdy błędy zostały już usunięte i program jest gotowy do dystrybucji.

Projekt został utworzony. Okno robocze CodeBlocks podzielone jest na kilka obszarów.

U góry znajduje się standardowo menu oraz różne paski narzędziowe. Z lewej strony jest panel Management (zarządzanie) z różnymi elementami (jeśli nie widzisz tego panelu, to wciśnij klawisze Shift+F2). Standardowo widać tutaj drzewo projektu (na zakładce Projects). Na spodzie jest panel Logs & others, w którym środowisko wyświetla komunikaty i logi (jeśli brak panelu, naciśnij klawisz F2). Główną część okna zajmuje edytor kodu. Na początku okno edytora jest puste.

W panelu Management kliknij w znak + obok Sources (źródła). Gałąź się rozwinie i powinieneś zobaczyć plik źródłowy main.cpp (główny plik tekstu programu w C++):

Kliknij w ten plik dwukrotnie lewym przyciskiem myszki. Plik zostanie otwarty w edytorze:

Zmień napis w cudzysłowach z "Hello world!" na "Witaj w CodeBlocks!". Edytor koloruje składnię poleceń w języku C++, dzięki czemu program wygląda bardziej czytelnie. U ciebie kolory mogą być inne, nie jest to ważne – ma się zgadzać treść programu, a nie kolory jego literek (starzy programiści w ogóle nie lubią kolorowania, bo są przyzwyczajeni do prostych edytorów tekstowych, w których kiedyś pisało się programy - mi ono nie przeszkadza i sądzę, że jest nawet pomocne). Zwróć uwagę, że słowo Witaj w cudzysłowach jest podkreślone czerwonym wężykiem. Edytor ma włączone sprawdzanie pisowni i słowa Witaj nie rozpoznaje, bo ma zainstalowany słownik angielski. Sprawdzanie pisowni jest czasami użyteczne. Jeśli jednak cię denerwuje, to możesz je łatwo wyłączyć. Z menu wybierz opcję Settings → Editor... Pojawi się okno dialogowe ustawień edytora. W bocznym panelu po lewej stronie wybierz sekcję Spellchecker (sprawdzanie pisowni) i wyłącz trzy opcję sprawdzania pisowni, które znajdują się u góry okienka:

Zatwierdź zmiany kliknięciem w przycisk OK. Podkreślenie powinno zniknąć z tekstu programu w edytorze (alternatywą jest zainstalowanie polskiego słownika, ale w to nie będziemy się tu bawić).

Naciśnij klawisz F9. Program zostanie skompilowany i uruchomiony. Jeśli wszystko jest w porządku, pojawi się okno konsoli z napisem:

Jeśli tak się stało, środowisko CodeBlocks masz gotowe do pracy. Teraz przejdź do dalszej części rozdziału, gdzie jest opisany sposób instalacji SDL 2.

Jeśli tak się nie stało, to wróć na początek tego podrozdziału i wykonaj dokładnie opisane operacje. TO MUSI ZADZIAŁAĆ!

Jeśli chcesz sprawdzić, którą dokładnie wersję Ubuntu masz na swoim komputerze, to otwórz terminal (Ctr+lewy Alt+T) i wpisz:

lsb_release -a

Komputer wyświetli w terminalu tekst:

No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 22.04 LTS
Release:	22.04
Codename:	jammy

Pakiet CodeBlocks można zainstalować w Ubuntu 22.04 na kilka sposobów. Tutaj podamy sposób instalacji za pomocą polecenia apt-get.

Najpierw uaktualniamy bazę danych apt za pomocą następującego polecenia w terminalu:

sudo apt-get update

Gdy baza danych apt zostanie uaktualniona, wpisujemy w terminalu kolejne polecenie:

sudo apt-get -y install codeblocks-dev

To powinno już zainstalować CodeBlocks, a na pasku startowym pojawi się ikona startowa aplikacji:

Jeśli taka ikona się nie pojawi, to uruchom CodeBlocks z terminala, wpisując polecenie:

codeblocks

Gdy CodeBlocks się uruchomi, kliknij prawym przyciskiem myszki w jego ikonę na pasku startowym i z menu kontekstowego wybierz opcję Dodaj do ulubionych:

To umożliwi ci szybkie uruchamianie środowiska.

Gdy aplikacja CodeBlock się uruchomi, wybierz w menu opcję: Settings → Environment...

Następnie w okienku dialogowym w polu Terminal to launch console programs (terminal do uruchamiania programów konsolowych) zamień wpis:

xterm -T $TITLE -e

na

gnome-terminal $TITLE -x

Dostaniesz terminal Gnome, który wygląda graficznie o wiele lepiej od standardowego terminala xterm.

Teraz przygotujemy sobie miejsce na dysku na przyszłe projekty. Uruchom menadżera plików. W panelu bocznym wybierz Katalog domowy i utwórz w nim nowy folder o nazwie prj (lub o jakiejś innej, która ci się podoba, lecz musisz ją zapamiętać na przyszłość).

Po tej operacji możesz zamknąć menadżera plików. Wróć do CodeBlocks. Na stronie głównej wybierz Create a new project (utwórz jakiś nowy projekt). Otworzy się okienko wyboru typu projektu z szablonu.

Zaznacz Console application i kliknij przycisk Go. Aplikacja konsoli pracuje w terminalu, czyli w okienku tekstowym. Jest to najprostszy tryb pracy aplikacji, dlatego używa się go przy nauce programowania, ponieważ uczeń nie musi walczyć z zawiłościami interfejsu graficznego tworzonej przez siebie aplikacji.

W następnym okienku dialogowym wybieramy język programowania, w którym chcemy napisać swój program. Tutaj zaznacz C++ i kliknij w Next.

W kolejnym oknie dialogowym wpisz w polu Project title (nazwa/tytuł projektu) wybraną przez siebie nazwę dla projektu, np. test. W drugim polu Folder to create project in (katalog do utworzenia w nim projektu) wpisz ścieżkę do katalogu, który wcześniej utworzyłeś w katalogu domowym na projekty programów w C++. Podana ścieżka dotyczy mojego komputera. U ciebie może być inna. Jeśli nie pamiętasz tej ścieżki, to kliknij w przycisk [   ] (po prawej stronie drugiego pola tekstowego) i wybierz właściwy katalog w menadżerze plików:

Pozostałych pól nie zmieniaj (są one wypełniane automatycznie przez CodeBlocks), kliknij w Next.

Na tej stronie określa się kompilator dla projektu oraz dostępne konfiguracje: uruchomieniową Debug oraz ostateczną Release. Na razie nie ma to większego znaczenia, zatem nic nie zmieniaj, kliknij w przycisk Finish. Spowoduje to utworzenie projektu o nazwie test. W każdym projekcie znajduje się plik źródłowy, w którym umieszcza się program startowy, czyli taki, który będzie wykonywany po uruchomieniu programu. Standardowo plik ten nosi nazwę main.cpp (główny). Aby się do niego dostać, rozwiń gałąź Sources (Źródła) w lewym panelu:

Kliknij dwukrotnie myszką nazwę main.cpp. Plik zostanie załadowany do edytora i będziesz miał możliwość jego edycji.

Program kompilujesz i uruchamiasz przez naciśnięcie klawisza F9. Jeśli wszystko jest w porządku, to pojawi się okno terminala z napisem:

To kończy instalację CodeBlocks, przejdź dalej w tym rozdziale, aby doinstalować bibliotekę SDL 2.

Opis dotyczy instalacji biblioteki SDL 2 dla środowiska CodeBlocks z kompilatorem MinGW w systemie Windows.

Przejdź do strony o poniższym adresie:

https://libsdl.org/download-2.0.php

W sekcji Development Libraries wyszukaj plik dla kompilatora MinGW i pobierz go na swój dysk:

Otwórz pobrane archiwum zip:

Wewnątrz znajduje się katalog ze wszystkimi elementami niezbędnymi do programowania przy pomocy biblioteki SDL 2:

Nas będzie interesował katalog x86-w64-mingw32. Zawiera on biblioteki oraz pliki nagłówkowe dla 64/32-bitowego kompilatora MinGW w 64-bitowym środowisku Windows. Od wersji  CodeBlocks 20.03 produkowane są automatycznie programy 64-bitowe. Cały katalog x86-w64-mingw32 przekopiuj do katalogu, który utworzyłeś na projekty. U mnie jest to katalog F:\cprj. Teraz otwórz ten katalog (u mnie F:\cprj\x86-w64-mingw32). Wewnątrz znajdziesz 4 katalogi:

Otwórz katalog include. Wewnątrz znajdziesz katalog SDL2. Wejdź do tego katalogu i zaznacz wszystkie pliki (Ctrl+A), które tam się znajdują:

Skopiuj zaznaczone pliki do schowka (Ctrl+C). Wróć do katalogu include i wklej pliki ze schowka (kliknij prawym przyciskiem myszki w puste miejsce pod katalogiem SDL2 i z menu kontekstowego wybierz opcję Wklej):

Możesz zastanawiać się, po co te kombinacje. Otóż kreator projektu SDL2 spodziewa się plików nagłówkowych w katalogu include, dlatego je tam umieszczamy.

Uruchom CodeBlocks i wejdź do opcji menu Settings → Global variables... Pojawi się okno edytora zmiennych globalnych:

Utworzymy zmienną globalną sdl2, która będzie wskazywała na katalog nasz x86-w64-mingw32 i na jego podkatalogi. Kliknij przycisk New (nowa zmienna). W okienku, które się pojawi, wpisz nazwę zmiennej sdl2 i kliknij przycisk OK:

Teraz musimy zdefiniować kilka pól tej zmiennej. Najpierw katalog bazowy. Kliknij w przycisk z trzema kropkami obok pola tekstowego base:

Pojawi się okno wyboru położenia. W oknie tym wybierz katalog x86_64-w64-mingw32 (który umieściłeś w katalogu projektów, u mnie jest to F:\cprj) i kliknij w przycisk Wybierz folder. W polu base ma się pojawić pełna ścieżka dostępu do katalogu z biblioteką SDL2:

W identyczny sposób definiujesz pola include, lib oraz bin, tak aby wskazywały właściwy podkatalog wewnątrz katalogu bazowego:

Pozostałe pola nas nie interesują i zostawiamy je puste. Zamknij edytor kliknięciem w przycisk Close. Wrócisz na stronę startową CodeBlocks.

Teraz utwórz nowy projekt SDL2 i kliknij w przycisk Go:

Pojawi się okienko powitalne kreatora projektu SDL2:

Tekst w oknie jest następujący:

Kliknij zatem w przycisk Next i pojawi się kolejna strona:

W polu Project title wpisz nazwę swojego projektu (ja wybrałem sdl_prj). Pole Folder to create project in (Katalog, w którym ma być utworzony projekt) powinno zawierać już ścieżkę do katalogu projektowego (u mnie F:\cprj\), ponieważ Codeblock zapamiętuje katalog, w którym ostatnio był tworzony projekt (a to zrobiliśmy przy instalacji). Gdyby jednak nie było tam katalogu projektowego, to kliknij przycisk z 3 kropkami znajdujący się obok pola i wybierz właściwy katalog. Pozostałych dwóch pól nie zmieniaj. Kliknij przycisk Next.

Na następnej stronie kreatora należy wpisać ścieżkę do biblioteki SDL2. W moim przypadku jest to F:\cprj\x86_64-w64-mingw32. Tekst w okienku jest następujący:

Wpisz w polu odpowiednią ścieżkę lub kliknij przycisk z 3 kropkami i wybierz właściwy katalog. Następnie kliknij w przycisk Next.

Ostatnia strona wybiera kompilator oraz konfiguracje Debug i Release.

Nie zmieniaj tutaj niczego, kliknij przycisk Finish. Projekt SDL2 zostanie utworzony. Kreator tworzy plik main.cpp z przykładowym programem SDL2. W panelu Management otwórz gałąź Sources i załaduj do edytora plik main.cpp podwójnym kliknięciem lewym przyciskiem myszki.

#include <exception>
#include <string>
#include <iostream>
#include <SDL.h>

class InitError : public std::exception
{
    std::string msg;
public:
    InitError();
    InitError( const std::string & );
    virtual ~InitError() throw();
    virtual const char * what() const throw();
};

InitError::InitError() :
    exception(),
    msg( SDL_GetError() )
{
}

InitError::InitError( const std::string & m ) :
    exception(),
    msg( m )
{
}

InitError::~InitError() throw()
{
}

const char * InitError::what() const throw()
{
    return msg.c_str();
}

class SDL
{
    SDL_Window * m_window;
    SDL_Renderer * m_renderer;
public:
    SDL( Uint32 flags = 0 );
    virtual ~SDL();
    void draw();
};

SDL::SDL( Uint32 flags )
{
    if ( SDL_Init( flags ) != 0 )
        throw InitError();

    if ( SDL_CreateWindowAndRenderer( 640, 480, SDL_WINDOW_SHOWN,
                                      &m_window, &m_renderer ) != 0 )
        throw InitError();
}

SDL::~SDL()
{
    SDL_DestroyWindow( m_window );
    SDL_DestroyRenderer( m_renderer );
    SDL_Quit();
}

void SDL::draw()
{
    // Clear the window with a black background
    SDL_SetRenderDrawColor( m_renderer, 0, 0, 0, 255 );
    SDL_RenderClear( m_renderer );

    // Show the window
    SDL_RenderPresent( m_renderer );

    int rgb[] = { 203, 203, 203, // Gray
                  254, 254,  31, // Yellow
                    0, 255, 255, // Cyan
                    0, 254,  30, // Green
                  255,  16, 253, // Magenta
                  253,   3,   2, // Red
                   18,  14, 252, // Blue
                    0,   0,   0  // Black
                };

    SDL_Rect colorBar;
    colorBar.x = 0; colorBar.y = 0; colorBar.w = 90; colorBar.h = 480;

    // Render a new color bar every 0.5 seconds
    for ( int i = 0; i != sizeof rgb / sizeof *rgb; i += 3, colorBar.x += 90 )
    {
        SDL_SetRenderDrawColor( m_renderer, rgb[i], rgb[i + 1], rgb[i + 2], 255 );
        SDL_RenderFillRect( m_renderer, &colorBar );
        SDL_RenderPresent( m_renderer );
        SDL_Delay( 500 );
    }
}

int main( int argc, char * argv[] )
{
    try
    {
        SDL sdl( SDL_INIT_VIDEO | SDL_INIT_TIMER );
        sdl.draw();

        return 0;
    }
    catch ( const InitError & err )
    {
        std::cerr << "Error while initializing SDL:  "
                  << err.what()
                  << std::endl;
    }

    return 1;
}

Skompiluj i uruchom program przez naciśnięcie klawisza F9 lub kliknięcie ikony .  Jeśli wszystko zostało zrobione prawidłowo, to program się skompiluje i uruchomi. Na ekranie pojawi się okienko z prostą animacją:

W wyniku tej operacji w katalogu projektu zostanie utworzony katalog bin\Debug, a w nim znajdzie się skompilowany program oraz biblioteka dynamiczna SDL2.dll. Plik biblioteki jest kopiowany automatycznie z katalogu F:\cprj\x86_64-w64-mingw32\bin. Musisz pamiętać, aby przy przekazywaniu swojego programu exe dostarczać wraz z nim plik SDL2.dll, ponieważ bez niego program nie będzie działał.

Zastąp program w edytorze poniższym kodem (w celu sprawdzenia, czy dadzą się skompilować przykładowe programy zawarte w tym artykule):

// Test SDL2

#include <SDL.h>
#include <iostream>

using namespace std;

//Rozmiar okienka
const int SCREEN_WIDTH = 320;
const int SCREEN_HEIGHT = 240;

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

	// Okno robocze
	SDL_Window * window = NULL;

	// Powierzchnia graficzna okna
	SDL_Surface * screenSurface = NULL;

	// Inicjujemy SDL
	if(SDL_Init(SDL_INIT_VIDEO) < 0 )
	{
		cout << "SDL niezainicjowane! SDL_Error: " << SDL_GetError() << endl;
	}
	else
	{
		// Tworzymy okno
		window = SDL_CreateWindow("Okienko SDL", SDL_WINDOWPOS_CENTERED,
                      SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
		if(!window)
		{
			cout << "Okno nieutworzone! SDL_Error: " << SDL_GetError() << endl;
		}
		else
		{
			// Uzyskujemy dostęp do powierzchni graficznej okna
			screenSurface = SDL_GetWindowSurface(window);

			// Wypełniamy ją kolorem czerwonym
			SDL_FillRect(screenSurface, NULL, SDL_MapRGB(screenSurface->format, 0xFF, 0, 0));

			// Uaktualniamy powierzchnię
			SDL_UpdateWindowSurface(window);

			// Czekamy 3 sekundy
			SDL_Delay(3000);
		}
	}

	// Usuwamy okno
	SDL_DestroyWindow(window);

	//Kończymy pracę z SDL
	SDL_Quit();

	return 0;
}

Skompiluj i uruchom program przez naciśnięcie klawisza F9 lub kliknięcie ikony . Jeśli nie popełniłeś błędu, to na ekranie powinno na trzy sekundy pojawić się małe okno z czerwonym tłem:

Podsumowując, aby dostosować środowisko CodeBlocks do współpracy z SDL2, należy:

1. Utworzyć na dysku katalog projektowy. U mnie jest to F:\cprj.
2. Pobrać z witryny https://libsdl.org/download-2.0.php skompresowaną bibliotekę SDL2 dla kompilatora MingW. Obecnie jest to plik SDL2-devel-2.0.22-mingw.zip.
3. Otworzyć pobrane archiwum zip i przekopiować z niego katalog x86_64-w64-mingw32 do katalogu projektowego (u mnie jest to F:\cprj).
4. Wewnątrz katalogu 86_64-w64-mingw32 przekopiować wszystkie pliki z katalogu include\SDL2 do include.
5. Uruchomić CodeBlocks i utworzyć zmienną globalną sdl2 (opcja menu Settings/Global variables...). Ustawić ścieżkę bazową w utworzonej zmiennej sdl2 na katalog x86_64-w64-mingw32 (u mnie jest to F:\cprj\x86_64-w64-mingw32). Ustawić adresy w zmiennej sdl2 dla include, lib i bin.

Aby utworzyć program z biblioteką SDL2 (po wcześniejszym ustawieniu CodeBlocks), należy:

1. Utworzyć projekt SDL2 za pomocą kreatora.
2. W kreatorze ustawić prawidłową ścieżkę do katalogu 86_64-w64-mingw32, jeśli to będzie potrzebne.
3. Załadować do edytora przykładowy program utworzony przez kreator (plik main.cpp).
4. Skompilować i uruchomić przykładowy program.
5. Jeśli nie będzie problemów, zastąpić przykładowy program własnym. Dalej postępujemy tak samo, jak z każdym innym programem w C++. W programie mamy dostęp do wszystkich elementów biblioteki SDL2.

Utworzony w ten sposób program wymaga dodatkowo pliku SDL2.dll. Plik ten może znajdować się w tym samym katalogu, co uruchamiany program.

To wszystko, możesz rozpocząć naukę programowania w SDL2. Zapraszam.

Uruchom terminal (Ctrl+Alt+T).

Wpisz:

sudo apt-get install libsdl2-dev

Polecenie zainstaluje bibliotekę SDL2 wraz ze wszystkimi niezbędnymi składnikami do programowania. Teraz musimy jedynie skonfigurować odpowiednio środowisko CodeBlocks.

Uruchom CodeBlocks.

Kliknij w Create a new project.

W kreatorze zaznacz opcję SDL2 project i kliknij w przycisk Go.

Wybierz nazwę dla projektu (Project title) oraz miejsce do utworzenia dla niego katalogu (Folder to create project in), po czym kliknij w Next:

W ostatnim oknie nic nie zmieniaj, kliknij w przycisk Finish.

Projekt zostanie utworzony. W panelu Management rozwiń gałąź Sources i załaduj do edytora plik main.cpp (trzeba go dwukrotnie kliknąć myszką):

Kreator tworzy przykładowy program SDL2 z kolorową animacją. Uruchom go klawiszem F9.

Jeśli program się skompilował i uruchomił, to znaczy, iż prawidłowo wszystko zainstalowałeś i skonfigurowałeś. Teraz sprawdzimy, czy będą działały programy z naszego artykułu. Skopiuj poniższy program do schowka, przejdź do edytora i naciśnij sekwencję klawiszy (Ctrl+A, Ctrl+V). W edytorze program powinien zostać podmieniony. Naciśnij klawisz F9, aby go skompilować i uruchomić.

// Test SDL2

#include <SDL.h>
#include <iostream>

using namespace std;

//Rozmiar okienka
const int SCREEN_WIDTH = 320;
const int SCREEN_HEIGHT = 320;

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

	// Okno robocze
	SDL_Window * window = NULL;

	// Powierzchnia graficzna okna
	SDL_Surface * screenSurface = NULL;

	// Inicjujemy SDL
	if(SDL_Init(SDL_INIT_VIDEO) < 0 )
	{
		cout << "SDL niezainicjowane! Błąd SDL: " << SDL_GetError() << endl;
	}
	else
	{
		// Tworzymy okno
		window = SDL_CreateWindow("Okienko SDL", SDL_WINDOWPOS_CENTERED,
                      SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
		if(!window)
		{
			cout << "Okno nieutworzone! Błąd SDL: " << SDL_GetError() << endl;
		}
		else
		{
			// Uzyskujemy dostęp do powierzchni graficznej okna
			screenSurface = SDL_GetWindowSurface(window);

			// Wypełniamy ją kolorem czerwonym
			SDL_FillRect(screenSurface, NULL, SDL_MapRGB(screenSurface->format, 0xFF, 0xFF, 0));

			// Uaktualniamy powierzchnię
			SDL_UpdateWindowSurface(window);

			// Czekamy 3 sekundy
			SDL_Delay(3000);
		}
	}

	// Usuwamy okno
	SDL_DestroyWindow(window);

	//Kończymy pracę z SDL
	SDL_Quit();

	return 0;
}

Jeśli pojawi się żółte okienko, to wszystko jest w porządku:

Podsumowując, aby programować w Ubuntu (dla innych dystrybucji jest podobnie) z wykorzystaniem biblioteki SDL2, należy:

1. Zainstalować pakiet libsdl2-dev.
2. W CodeBlocks utworzyć projekt SDL2
3. Tworzyć program C++ wg zasad opisanych w tym artykule. Są one prawie identyczne w Linuxie i w Windows.

Problemem będzie, jeśli zechcesz podzielić się z kimś swoim programem. Programy korzystają dynamicznie z bibliotek SDL2, które pojawiają się w systemie po zainstalowaniu SDL2. Oczywiście zawsze możesz samodzielnie skompilować wszystkie biblioteki, tak aby były statyczne, wtedy program będzie je miał w swoim kodzie. Jednak tym się tutaj nie zajmuję i nie polecam tego rozwiązania. Alternatywą jest stworzenie pakietu instalacyjnego, który sprawdzi dostępność wymaganych bibliotek i w razie braku doinstaluje je. Tym też się nie będę zajmował. Wszystko jest opisane w sieci, a skoro pracujesz w Linuksie. to powinieneś takie rzeczy poznać. W ostateczności użytkownik zawsze może sobie zainstalować najnowszy pakiet libsdl2-dev i sprawa będzie załatwiona.