• kurruk:
  tak się zastanawiałem już jakiś czas temu, tak ci powiem, czy nie nazywać jakoś bardziej z inwencja te iteracje
  techniczna dalej będzie jakaś beta3, ale może masz jakiś pomysł na czym możemy się poopierać, żeby nadać im jakąś bardziej chwytliwa nazwę
• dvl:
  chcesz jak ubuntu nazywać? gibki gibon, jebnięta jaszczurka, słitaśny struś, etc?

Odbieranie komunikatów

Istnieją dwa sposoby odbierania komunikatów okienkowych (ciężki do przetłumaczenia fragment;):

• “odpytywanie” – ang. polling – w każdym przebiegu pętli programu pytamy okno o oczekujące komunikaty
• poprzez funkcje zwrotne – ang. using callback functions – przekazujemy do okna wskaźnik funkcji, którą wywoła kiedy otrzyma komunikat.

SFML używa tego pierwszego sposobu. Funkcja, którą odpytujemy okno, to GetEvent należąca do klasy sf::Event.
Zwraca ona wartość true, jeżeli są jakieś nieprzetworzone komunikaty. Inaczej zwraca wartość false.

sf::Event Event;
if (App.GetEvent(Event))
{
    // Przetwarzanie komunikatu
}

Oczywiście komunikatów w każdej klatce może być więcej jak jeden. Za każdym razem są one odkładane na stosie komunikatów – najświeższy na wierzchu.
Jeżeli przetworzymy tylko jeden – pozostałe nadal będą czekać. Może to doprowadzić do sytuacji, kiedy niektóre komunikaty nigdy nie zostaną przetworzone.
Przy okazji – powinniśmy je obsługiwać na początku pętli głównej aplikacji:

while(Running)
{
sf::Event Event;
while (App.GetEvent(Event))
{
    // Process event
}
App.Display();
}

Przetwarzanie komunikatów

Pierwszą rzeczą jaką powinniśmy zrobić z komunikatem, to sprawdzić jego typ (sf::Event.Type).
SFML definiuje następujące typy:

• Closed – zamknięcie okna
• Resized – zmiana rozmiaru okna, nowy rozmiar jest w Event.Size.Width (szerokość) i Event.Size.Height (wysokość)
• LostFocus – okno przestało być aktywne
• GainedFocus – okno odzyskało aktywność
• TextEntered - został wprowadzony tekst – Event.Text.Unicode (UTF-32)
• KeyPressed - Event.Key.Code – kod wciśniętego klawisza, Event.Key.Alt, Event.Key.Control, Event.Key.Shift – czy były przy tym wciśnięte
• KeyReleased – Event.Key.Code – kod zwolnionego klawisza, Event.Key.Alt, Event.Key.Control, Event.Key.Shift – czy były przy tym wciśnięte
• MouseWheelMoved – poruszenie rolką myszki – Event.MouseWheel.Delta – dodatnia liczba – do przodu, ujemna – wiadomo
• MouseButtonPressed – Event.MouseButton.Button zawiera wciśnięte przyciski myszy
• MouseButtonReleased – j.w. tylko zwolnione
• MouseMoved – poruszenie myszką – Event.MouseMove.X i Event.MouseMove.Y zawierają pozycję kursora (współrzędne lokalne – względem początku okna)
• MouseLeft/MouseEntered – opuszczenie i powrót kursora w obszar okna

Są jeszcze komunikaty obsługujące joystick, ale będą przeze mnie pomijane.

Kody klawiszy, o których była mowa, są zbiorem stałych zdefiniowanych w pliku Events.hpp (można je sobie tam w razie wątpliwości podejrzeć).
Np. sf::Key::F5 czy sf::Key::A.

Klawisze myszy również są zdefiniowane – mamy ich do wyboru pięć: sf::Mouse::Left, sf::Mouse::Right, sf::Mouse::Middle (zazwyczaj wciskana rolka), sf::Mouse::XButton1 and sf::Mouse::XButton2.

Wracając do naszej aplikacji – w końcu możemy obsługiwać komunikaty:

sf::Event Event;
while (App.GetEvent(Event))
{
    // Zamkniecie okna
    if (Event.Type == sf::Event::Closed)
        Running = false;

    // Wcisniecie klawisza ESC
    if ((Event.Type == sf::Event::KeyPressed) && (Event.Key.Code == sf::Key::Escape))
        Running = false;
}

Jeżeli przyglądaliście się wcześniejszej aplikacji – być może zauważyliście, że klikanie w ‘x’ zamykający okno generowało
komunikat Close, jednak okno nie było niszczone. To dlatego, że obsługa zamknięcia okna powinna być obsłużona przez nas – np. mamy okazję upewnić się, że użytkownik nie wcisnął przycisku przypadkiem czy też zaproponować zapisanie stanu gry;)
Zamknięcie okna możemy spowodować usuwając jego instancję lub za pomocą funkcji Close().

Teraz nasza główna pętla powinna wyglądać tak:

while(App.IsOpened())
{
	sf::Event Event;

	while(App.GetEvent(Event))
	{
		// Zamkniecie okna
		if (Event.Type == sf::Event::Closed)
			App.Close();

		// Wcisniecie klawisza ESC
		if ((Event.Type == sf::Event::KeyPressed) && (Event.Key.Code == sf::Key::Escape))
			App.Close();
	}
}

Reagowanie na zdarzenia w czasie rzeczywistym

Powyższy sposób sprawdzania zdarzeń dobrze sprawdza się w przypadku pojedynczych wciśnięć klawiszy czy zamknięcia okna.
Jeżeli chcemy obsługiwać bardziej skomplikowane i czułe zdarzenia – np. sterowanie postacią – może okazać się, że wystąpią niedopuszczalne opóźnienia.

Lepszym rozwiązaniem w takim przypadku jest ustawianie zmiennej typ bool wartością true lub false – w zależności od tego czy interesujący nas klawisz jest wciśnięty lub puszczony.
Jeżeli taka zmienna jest ustawiona, wtedy po prostu co przebieg pętli poruszamy postać.
Taką funkcjonalność zapewnia nam klasa sf::Input.

Tworząc instancję tej klasy musimy ją powiązać z naszym oknem:

const sf::Input& Input = App.GetInput();

Dzięki temu mamy dostęp do klawiatury i myszki (pomijanego joysticka również) w każdej chwili, na przykład:

bool         LeftKeyDown     = Input.IsKeyDown(sf::Key::Left);
bool         RightButtonDown = Input.IsMouseButtonDown(sf::Mouse::Right);
unsigned int MouseX          = Input.GetMouseX();
unsigned int MouseY          = Input.GetMouseY();

Przykładowy kod aplikacji mógłby wyglądać tak:

#include <SFML/Window.hpp>

int main()
{
    // Tworzymy okno
    sf::Window App(sf::VideoMode(800, 600, 32), "SFML - obsluga zdarzen");

    // Tworzymy referencje do menagera obsługi zdarzen powiązanego z naszym oknem
    const sf::Input& Input = App.GetInput();

    // Petla glowna
    while (App.IsOpened())
    {
        // Przetwarzamy komunikaty
        sf::Event Event;
        while (App.GetEvent(Event))
        {
            // Zamkniecie okna przyciskiem na belce tytulowej lub z paska zadan
            if (Event.Type == sf::Event::Closed)
                App.Close();

            // Zamkniecie okna klawiszem ESC
            if ((Event.Type == sf::Event::KeyPressed)
                 && (Event.Key.Code == sf::Key::Escape))
                App.Close();
        }

        // Przykladowe zmienne do pobierania stanu
		// urzadzen wejsciowych w czasie rzeczywistym
        bool LeftKeyDown = Input.IsKeyDown(sf::Key::Left);
        bool RightButtonDown = Input.IsMouseButtonDown(sf::Mouse::Right);
        unsigned int MouseX = Input.GetMouseX();
        unsigned int MouseY = Input.GetMouseY();

        // Wyswietlanie okna
        App.Display();
    }

    return EXIT_SUCCESS;
}

Jak widać dzięki SFML obsługa zdarzeń jest całkiem prosta i przyjemna:)

W następnej części – obsługa czasu.

Na wstępie zaznaczę – póki omawiam podstawy SFML, bez konkretnego większego przykładu zastosowania (n.p. gra) tutoriale zawarte w moim blogu są zazwyczaj luźnymi, „użytkowymi” tłumaczeniami ze strony http://www.sfml-dev.org/tutorials/. Nie widzę potrzeby wynajdywania koła na nowo – skoro coś jest dobre, to warto tego użyć.

W dzisiejszej części zajmiemy się tworzeniem okna wchodzącego w skład modułu Window.

Okno

Tworzone przez nas okno jest typu sf::Window. Parametry okna możemy podać już przy deklaracji obiektu:

int main
{
sf::Window App(sf::VideoMode(800,600,32),”Okno SFML”);
}

jak i później:

int main
{
sf::Window App;

App.Create(sf::VideoMode(800,600,32),”Okno SFML”);
}

Jak widzimy konstruktor oraz metoda Create przyjmują dwa parametry:

• sf::VideoMode – jak nietrudno się domyślić rozdzielczość ekranu (szerokość, wysokość, głębia koloru)
• std::string – nazwa okna

Tryby graficzne

W poprzednich przykładach nie przejmowaliśmy się specjalnie obsługą trybów graficznych, ponieważ uruchamialiśmy aplikację w oknie, gdzie można użyć właściwie każdego. Uruchomienie aplikacji w trybie pełnoekranowym już nie pozwala na taką beztroskę. Obsługiwane tryby pełnoekranowe możemy odczytać w następujący sposób:

unsigned int VideoModesCount = sf::VideoMode::GetModesCount();
for(unsigned int i = 0; i < VideoModesCount; ++i)
{
sf::VideoMode Mode = sf::VideoMode::GetMode(i);
}

Listowane tryby będą posortowane od najwyższego obsługiwanego. Czyli – jeżeli chcemy otworzyć okno w najwyższej dostępnej na danym sprzęcie rozdzielczości i głębi kolorów – utworzymy je w ten sposób:

App.Create(sf::VideoMode::GetMode(0), „Okno SFML”, sf::Style::Fullscreen);

(jak widać użyliśmy tutaj trzeciego parametru dla metody Create – sf::Style::Fullscreen – o stylach będzie szerzej w przyszłości)

Jeżeli jednak będziemy tworzyć okno ręcznie lub wczytywać jego parametry z pliku – warto sprawdzić, czy zadany tryb jest obsługiwany:

sf::VideoMode Mode = ReadModeFromFile();
if(!Mode.IsValid())
{
// komunikat o błędzie
}

SFML umożliwia także w prosty sposób pobranie aktualnej rozdzielczości pulpitu:

sf::VideoMode DesktopMode = sf::VideoMode::GetDesktopMode();

Główna pętla

Umiemy już utworzyć okno, więc możemy napisać podstawowy program wyświetlający okno:

#include <SFML/Window.hpp>

int main()
{
    sf::Window App(sf::VideoMode(800, 600, 32), "Okno SFML”);

    bool Running = true;
    while (Running)
    {
        App.Display();
    }

    return EXIT_SUCCESS;
}

Uwagi:
metodę Display wywołujemy tylko raz, w głównej pętli i najlepiej na samym jej końcu
gdyby ktoś sprawdzał kody wyjścia programu – użyliśmy tutaj EXIT_SUCCESS, który = 0, w przypadku błędu możemy użyć EXIT_FAILURE = -1.

Oczywiście nie ma jeszcze „normalnej” obsługi zamknięcia okna – ale dojdziemy do tego później. W tej chwili wystarczy zamknąć okienko konsoli.

W następnym odcinku – obsługa komunikatów:)

Na wstępie zaznaczę – póki omawiam podstawy SFML, bez konkretnego większego przykładu zastosowania (n.p. gra) tutoriale zawarte w moim blogu są zazwyczaj luźnymi, „użytkowymi” tłumaczeniami ze strony http://www.sfml-dev.org/tutorials/. Nie widzę potrzeby wynajdywania koła na nowo – skoro coś jest dobre, to warto tego użyć.

Na początku prac nad SPA używaliśmy SDL, jednak w którymś momencie okazało się, że w połączeniu z OpenGL i kartą ATI Kurruka dawał nam niezły slideshow. Podobno nic nowego/nierozwiązany problem. W związku z tym byliśmy zmuszeni poszukać jakiejś alternatywy – wybór padł na SFML.

Minęło od tamtej chwili już sporo czasu, ale ostatnio przyszło mi do głowy żeby zrobić serię małych, prostych tutoriali.
Po części będą to luźne tłumaczenia, po części luźne wariacje na temat konkretnych podzespołów SFML – pod kątem szybkiego robienia małych aplikacji. Cały czas patrzę na SFML jako świetne narzędzie pomagające w prototypowaniu. Może nawet przy okazji tutoriali napiszę na forum małą gierkę, którą wymyśliłem kiedyś na 2h Warsztatowe compo, ale nie zdążyłem jej skończyć w terminie;)

Czym jest SFML?

W skrócie szybką i łatwą w użyciu biblioteką multimedialną napisaną w C++.
Główne cechy:

• przenośna (Win/Linux/MacOS)
• zaprojektowana i napisana obiektowo
• łatwa w użyciu
• elastyczna (poszczególnych modułów można używać osobno)
• można ją łączyć z OpenGL
• obsługa myszy/klawiatury/joysticka
• obsługa dźwięku w wielu popularnych formatach
• obsługa sieci

Przygotowanie środowiska pracy

Jako środowisko posłuży nam Visual C++ 2008 Express (gdyby ktoś miał problem z jakimś innym środowiskiem – niech da znać;)

Zakładam, że czytelnik zna w miarę VC++ – tylko w tym pierwszym tutorialu rozpisuję co i gdzie dokładnie kliknąć przy konfiguracji środowiska. Przy następnych będę takie rzeczy mocno streszczał!

Pierwszą rzeczą (po zainstalowaniu VC++ oczywiście) jest pobranie bibliotek SFML. Kategoria SFML development files (headers / libraries / external libraries). Najświeższa wersja w tej chwili, to 1.6.
Pobrany plik rozpakowujemy w wybrane miejsce. Dalej mamy dwie drogi do wyboru:

• kopiujemy zawartość SFML-1.6/include do katalogu include Visual C++, podobnie robimy z katalogiem lib

lub

• cały katalog umieszczamy w dogodnym miejscu i dokonujemy odpowiednich zmian w środowisku:
• wchodzimy w Tools->Options->Projects and Solutions->VC++ Directories, po prawej wybieramy Show directories for:
• Include files – dodajemy nową pozycję (żółta ikonka) i wskazujemy na folder include z naszej lokalizacji
• Library files – jak wyżej, tylko wskazujemy folder lib

Pierwszy program

W VC++ tworzymy nowy, pusty projekt typu Win32 console application. Dodajemy standardowy plik main.cpp – poniżej zawartość:
(przykładowy kod z oficjalnego tutoriala):

#include <SFML/System.hpp>
#include <iostream>

int main()
{
    sf::Clock Clock;
    while (Clock.GetElapsedTime() < 5.f)
    {
        std::cout << Clock.GetElapsedTime() << std::endl;
        sf::Sleep(0.5f);
    }

    return 0;
}

Program odliczy 5s od uruchomienia i zakończy swoje działanie.

Poznajemy tutaj klasę Clock oraz funkcję Sleep wchodzące w skład modułu System.
Przy okazji należy zapamiętać, że wszystkie składniki SFML należą do przestrzeni nazw "sf".

To jeszcze nie wszystko - zanim zbudujemy projekt musimy wskazać linkerowi biblioteki SFML - w tym przypadku tylko jedną.
Klikamy Project->Nazwa projektu Properties->Configuration Properties->Linker->Additional Dependencies i dopisujemy sfml-system.lib.

W przypadku pracy w konfiguracji debug zalecane jest wskazanie pliku sfml-system-d.lib, w przypadku dołączania bibliotek statycznie - sfml-system-s.lib. W przypadku pozostałych bibliotek będzie obowiązywała ta sama zasada.

Teraz możemy skompilować projekt - jeżeli wszystko zostało zrobione jak opisałem nie powinno być niespodzianek. Poza jedną:)
Zanim uruchomimy program - a kompilowaliśmy z bibliotekami dołączanymi dynamicznie - musimy tam, gdzie pojawił się plik wynikowy skopiować sfml-system.dll - jest w rozpakowanym katalogu SFML w lib.

I to wszystko - mamy pierwszy program wykorzystujący klasę Clock.

W następnym odcinku - otwieranie okna w trybie graficznym.

Swoją niewiedzę usprawiedliwię przedstawiając się jako fan jego twórczości, a nie gość zaglądający mu do kuchni;)

A EP “How To Destroy Angels” bardzo mi się podoba – do pobrania za free:)

Jak widać na powyższym zdjęciu prace posuwają się powoli, lżej mi teraz pokombinować z grafiką do SPA jak klepać kod.
W sieci wygrzebałem w związku z tym rewelacyjny tutorial – “Stwórz fajne, gwiaździste niebo” w GiMPie. Poniżej efekt pierwszego zastosowania tegoż samouczka:)

Uprawa pieczarek (ang. Mushroom management): Styl zarządzania podobny do uprawy pieczarek. Pieczarki trzymane są w ciemnościach, w oborniku (ang. bullshit), a gdy trochę urosną – obcina się im głowy. W zarządzaniu przekłada się to na podejmowanie decyzji bez konsultacji z personelem, którego dotyczą te decyzje, lub wręcz nie informowanie personelu aż do czasu, gdy decyzje zapadną i będą odczuwalne. Zjawisko spotykane jest najczęściej w organizacjach o hierarchicznej strukturze, z barierami komunikacyjnymi pomiędzy poszczególnymi szczeblami. Antywzorzec ten dotyczy także projektów informatycznych, a dokładniej braku komunikacji pomiędzy klientami lub architektami systemu, a programistami, którzy implementują system. Programiści nie mają bezpośredniego kontaktu z klientem i mogą polegać tylko na stworzonej dokumentacji, która z kolei jest często traktowana niezobowiązująco przez klienta (np. klient traktuje ją “po macoszemu”, jako zło konieczne).

(źródło: http://pl.wikipedia.org/wiki/Antywzorzec_projektowy)