Dzisiaj około godziny 9.30 zakończyłem kolejny etap edukacji i z wynikiem celującym uzyskałem tytuł magistra inżyniera informatyki, specjalizacja Projektowanie systemów CAD/CAM.

Zwykle czas refleksji przypada na koniec roku, wraz z rozliczaniem się ze sobą z realizacji powziętych postanowień. Mnie osobiście zawsze łapie to w okresie intensywnego obijania się między Świętami Bożego Narodzenia, a… nie, nie Wielkanocą (chociaż tak długa laba brzmi zachęcająco) tylko Sylwestrem. Wtedy to stawiam sobie dwa pytania: „Cóż to naobiecywałem sobie na ten (kończący się właśnie) rok?” oraz „Czego by tu sobie na ten nowy naobiecywać?” Biję się zatem w piersi i zaczynam przyznawanie się..

[2010]

• Przede wszystkim, poradziłem sobie na studiach magisterskich. Obrona co prawda jeszcze przede mną (o tym w dziale [2011]), ale z perspektywy czasu na szybko podjęta decyzja o wyborze „Projektowania systemów CAD/CAM” jako specjalizacji była trafiona idealnie.
• Ciągle utrzymana praca zawodowa, przynosząca satysfakcję w dziedzinach nieco oderwanych od głównego kierunku studiów, ale wciąż interesująca
• Jeżeli chodzi o devloga, to jestem w miarę zadowolony, co nie znaczy, że nie może być lepiej. Przede wszystkim częstotliwość wpisów powinna być znacznie większa – w roku 2010 opublikowałem ich równo 40, co daje średnią 1 notki na ~9 dni. Inne statystyki są równie obiecujące (dostarczono przez Google Analytics): prawie 7000 odsłon, średnio ponad 2 min spędzone na stronie. Największą popularnością cieszyły się następujące posty (pierwsza piątka w kolejności):
  • Skala szarości i sepia
  • C#: Eksport danych do pliku XLS
  • Osadzanie XNA w Windows Forms
  • XNA – Kamera FPP
  • ILMerge – dołączanie zewnętrznych bibliotek.
• Wziąłem udział w konkursie Maćka Aniserowicza „Daj się poznać”. Niestety, projekt umarł jak zwierzątko w tamagotchi, ponieważ czas pożerała praca magisterska (była w tym lepsza niż wszelkie -Ville razem wzięte). Plusem jest, że kilka rzeczy rozwijanych na potrzeby konkursu przemyciłem do magisterki.
• Życie pozazawodowe / pozauczelniane / pozaprogramistyczne. Pozwiedzałem (UK), pożeglowałem (suwalszczyzna), porowerowałem (Warszawa), poodwiedzałem koncerty (tu i tam ). Rok pod tym względem można uznać za udany.

[2011]

Nowa dekada zaczęła się (mogę to z ręką na sercu powiedzieć) z hukiem ponieważ.. ZARĘCZYŁEM SIĘ Szczęśliwą (mam nadzieję ) Narzeczoną została pewna Programistka. Ślub co prawda planowany jest na rok 2012, ale przygotowania wypada zacząć nieco wcześniej, więc może być gorąco.

Z postanowień noworocznych:

• do posiadanego tytułu inżyniera zdobyć kolejny achievement w postaci tytułu magistra. Szansa na to przyjdzie z końcem stycznia.
• regularniej przelewać swoje myśli w słowa i zapisywać je w postaci notek.
• w związku z powyższym przydałoby się zacząć rozwój jakiegoś pobocznego projektu. Wstępne szkice już są, mam nadzieję, że chęci i umiejętności starczy, żeby doprowadzić to do jakiejś grywalnej (słowo kluczowe w tej zagadce) postaci.

Oby ten rok był jednocześnie najlepszym z dotychczasowych i tylko tłem dla kolejnych!

Początek i otwarcie

Na miejsce przybyłem chwilę przed czasem, miałem więc okazję zobaczyć jak organizatorzy rozkładają przed Małą Aulą Politechniki ekrany, do których miały być podpięte XBOX’y. Wszystko byłoby fajnie, gdyby nie fakt, że.. była 8.45. Szybkie spojrzenie w agendę, tak. Planowane rozpoczęcie o 9.00. Rejestracja była pokazem wyższości O( logN ) nad O( N ) – zarówno lista zarejestrowanych uczestników, jak drukowanych dla każdego imiennych zaświadczeń o udziale w konferencji były nieposortowane alfabetycznie [sic!]. Na szczęście byłem trzeci, więc dość krótko przyszło mi stać w kolejce. Rozpoczęcie chwilę się opóźniło, ale na szczęście nie wpłynęło to na długość kolejnych prelekcji, o których poniżej.

Prelekcje

“Pasja programisty .NET z Xbox 360 & Kinect” Marcin Iwanowski (Microsoft)

Prezentacja ciekawa, ale oprócz zaprezentowania na żywo gier na Kinect mało porywająca. Dużo banałów (“kto wie co to jest? Otóż, to jest gamepad.”). Marcin w trakcie zapowiedział, że później przejdzie do znacznie trudniejszej – technicznej części prezentacji. Zaświeciły mi się oczy, bo liczyłem na jakieś szczegółowe / tajne / Wikileaks’owe informacje o hardware oraz algorytmach użytych w Kinect. Wstępem do tego był odrębny dokument (nawet nie pamiętam tytułu, czy był przytoczony też nie) – opisy rzeczy, które przed chwilą wymieniłem. Został on jednak przewinięty z szybkością animacji 1080p na netbook’u (czyli jakieś 6-7 slajdów na sekundę), a “trudne rzeczy” zostały sprowadzone do stwierdzeń (tu fragment prezentacji):

1. kinect próbkuje odległości
2. kinect rozpoznaje części ciała
3. kinect odgaduje pozycję ciała (używając algorytmu uczącego z wczytanymi wcześniej danymi)
4. i to wszystko 30 razy na sekundę

Miałem dużo większe oczekiwania.

“Eksploruj Windows Phone 7 z XNA”, Rafał Czupryński (Microsoft)

Prezentację prowadził człowiek pracujący w Microsoft. Miało to swoje dobre i złe strony. Do dobrych oczywiście należy to, że na co dzień w ramach pracy zawodowej (a nie tylko hobby / dorywczo) zajmuje się najnowszymi technologiami oraz ich rozprzestrzenianiem. Zła strona – każdy opowiadający o produktach swojej firmy, chcąc nie chcąc brzmi jak chodząca reklama a w przypadku ludzi z Microsoftu – jak blok reklam w trakcie piątkowego wieczoru na Polsacie.

Niemniej jednak prelekcja była przyjemna, Rafał w przystępny sposób opowiedział o nowym systemie, wymienił też kilka nowinek, o których nie słyszałem wcześniej pomimo udziału w online’owym szkoleniu prowadzonym przez Roba Milesa i Andy’ego Wigley’a. Rob został oczywiście wspomniany jako jeden z największych autorytetów w dziedzinie XNA, jako przykład została zaprezentowana gra “Cheese Lander” – to już drugi raz, kiedy miałem okazję zobaczyć ten kod w ramach prelekcji (dwóch różnych osób, z czego jedna z nich była autorem aplikacji). Pomimo ciekawego tematu (w końcu Windows Phone 7 to poważny kandydat do zamieszania na rynku smartphone’ów) oraz interesujących przykładów zabrakło wg. mnie najważniejszego. Prelegent jako urządzenia “pokazowego” (czyli prezentowania położenia urządzenia w trybie Portrait i Landscape oraz np. symulacji multitouch) używał.. HTC HD2 z Windows Mobile 6.5 [sic!]

Plusami były też obszerne informacje na temat Marketplace, dostępu do tegoż i możliwości zarabiania.

Sesja zdecydowanie na plus, między innymi ze względu na wygraną książkę “Projektowanie gier” Ernesta Adamsa

“Jak szybko i efektywnie dobrać się do bazy danych”, Mariusz Matysek (zaloz-sie.pl)

Spóźniłem się nieco na tą prelekcję ze względu na spotkanie (bardzo owocne) z promotorem pracy magisterskiej oraz (niestety wręcz przeciwnie – bezowocną) wizytę w dziekanacie. Nie straciłem jednak wiele.

Prelegent zaprezentował porównanie najpopularniejszych ORM’ów:

• ADO.NET
• LINQ TO SQL
• Entity Framework
• NHibernate (+Fluent NHibernate)

Prezentacji każdej z nich towarzyszył przykład – aplikacja ASP.NET MVC z zastosowanym danym framework’iem do dostania się do bazy. Niestety, zbyt wiele kodu nie uświadczyłem. Jako, że w agendzie napisano “próba wyłonienia najbardziej efektywnej technologii dostępu do bazy danych” liczyłem na jakieś wyniki testów porównawczych (czasówki dotyczące 1000000-krotnego INSERT-u, SELECT-a z wrednym JOIN-em, etc.), jednak takich nie było. Szkoda.

“Expression Blend – ekspresowe konstruowanie zaawansowanych graficznie interfejsów użytkownika”, Wojciech Kuroczycki (Wydział Elektryczny PW)

Narzędzie i prezentacja – TAK! Prelegent – NIE! No dobra, może zbyt surowo tu oceniam, ale po prelekcji oczekuję, że prowadzący nie będzie co drugie zdanie wtrącał “dobra, to jedziemy dalej z tym koksem”

Do rzeczy: narzędzie jest potężne. W 1.5 godziny od podstaw stworzony został interfejs użytkownika dla aplikacji nie mającej większego sensu, natomiast wyglądającej na tyle ładnie, że wersję pudełkową za symboliczne 99.99 pln sprzedałby średnio rozgarnięty domokrążca. Animacje, ułożenie elementów na formie, przezroczystość, rotacje, bindowanie danych do kontrolek, szablony wyświetlanych tekstów, możliwość stworzenia prostych kolekcji danych do przetestowania GUI “na sucho”. Bajka. Cytując prowadzącego (i wycinając “dobra” ):

Spokojnie można w tym wyklikać programy na zaliczenie na 1, 2, 3 i.. na 4 rok PW też mi się udało

Sesja in plus.

“Wizja współpracy ze studentami i Uczelniami Wyższymi”, Rafał Czupryński (Microsoft)

Prelekcji nie widziałem. Ale za to chińczyk zamiast niej wypadł bardzo smakowicie

“Rzeczywistość tworzenia gier w XNA – od dokumentu po produkcję” Andrzej Piotrowski (Grupa UPPoznan.net)

Na tą prelekcję miałem największą chrapkę. Proces produkcji gier to to, czego nie da się nauczyć na uczelni. A przynajmniej nie pisania Design-Doc’ów, a także tego co dzieje się w fazie wydawania gry. Odpowiedzi jednak nie uzyskałem. Zostało zaprezentowanych kilka(naście) gier napisanych używając XNA przez prelegenta lub innych ludzi.

Do jednej z gier autor Andrzej pokazał Design-Doc, jednak nie wchodził w szczegóły – zabrakło tego, co w takim dokumencie powinno się znaleźć, jakie inne dokumenty powstają jeszcze PRZED rozpoczęciem kodowania. No i najbardziej zabrakło opisu samego wypuszczania gry na rynek.

Niemniej jednak, kilka z zaprezentowanych tytułów dosyć mogło dosyć mocno zainspirować, pokazało, że nawet prosty (acz kreatywny) pomysł może niewielkim nakładem sił przeobrazić się w grywalną produkcję.

Sesja in plus (ale to przez to, że zgarnąłem kolejną książkę – tym razem "ASP.NET Programowanie" Jessy Liberty, Dan Hurwitz  )

Podsumowanie

Chwała chłopakom z politechnicznych grup .NET za zorganizowanie konferencji, wybranie na temat przewodni właśnie programowania gier i ściągnięcia niezłych sponsorów, dzięki którym w konkursie Kinect’a do wygrania był Xbox 360. Do następnego razu.

Przedstawię szkielet rozwiązania, które może zostać zastosowane praktycznie dla dowolnego problemu o podobnej charakterystyce, może zostać łatwo rozszerzone dla wyższych wymiarów.

Problem

Policzyć pewną właściwość (niech będzie to rezultat wywołania funkcji
int ComputeSmth(int x, int y, int z)) dla każdego elementu trójwymiarowej tablicy
int[,,] tab. Rozmiary tablicy są znane i wynoszą odpowiednio [SizeX, SizeY, SizeZ].

Wersja liniowa

Zamieszczam dla kompletu, żeby było wszystko

for (int i = 0; i < SizeX; ++i)
    for (int j = 0; j < SizeY; ++j)
        for (int k = 0; k &lt; SizeZ; ++k)
            tab[i, j, k] = ComputeSmth(i, j, k);

Zrównoleglanie – krok pierwszy

Użycie Parallel.For wymaga podania trzech argumentów: zakresu przedziału pętli [fromInclusive, toExclusive), czyli pętla wykona się dla (powiedzmy)
i = fromInclusive; i > toExclusive. Trzecim argumentem jest delegat wykonywany w każdej iteracji, który jest obiektem Action. Na początku wprowadzimy potrójną pętlę równoległą, oto kod:

Parallel.For(0, SizeX, i =>
{
    Parallel.For(0, SizeY, j =>
    {
        Parallel.For(0, SizeZ, k =>
        {
            tab[i, j, k] = ComputeSmth(i, j, k);
        });
    });
});

Taki kod wydał mi się jednak brzydki, więc postanowiłem pójść o krok dalej.

Zrównoleglenie – krok drugi

Skorzystałem z własności, że każdą tablicę trójwymiarową można traktować jak jednowymiarową, wystarczy odpowiednio przeliczyć indeksy (działa również dla wyższych wymiarów, ale akurat potrzebowałem wersji 3D). Na szybko powstały dwie metody:

private static int Calculate3Dto1D(int x, int y, int z, int sizeX, int sizeY, int sizeZ)
{
    return z * (sizeX * sizeY) + y * sizeX + x;
}

private static void Calculate1Dto3D(int k, int sizeX, int sizeY, int sizeZ, out int x, out int y, out int z)
{
    z = k / (sizeX * sizeY);
    int tmp = k % (sizeX * sizeY);
    y = tmp / sizeX;
    x = tmp % sizeX;
}

Kod jest raczej prosty, przeliczanie indeksu jednowymiarowego na trójwymiarowy najlepiej rozrysować sobie na kartce – to mój najlepszy (w parze z ołówkiem) doradca ds. algorytmów Obie metody są symetryczne – jedna służy do przeliczania współrzędnych z 3D do 1D, druga odwrotnie (nazwy są samoopisujące się), w dalszej części będziemy używać tylko jednej z nich, ale obie lepiej oddają ideę tej metody. Poza tym zdziwić może nieużywanie w ciele metod parametru sizeZ. Tak naprawdę do przeliczania potrzebne są nam tylko dwa pierwsze wymiary kostki, ale dla jasności kodu (w wersji produkcyjnej można spokojnie usunąć ten parametr) zostawiłem go w obu metodach.

Kiedy wiemy już jak przeliczać indeksy, można uzyskać pożądany efekt przy użyciu tylko jednego wywołania metody Parallel.For. Kod źródłowy:

const int n = SizeX * SizeY * SizeZ;
Parallel.For(0, n, i =>
{
    int x, y, z;
    Calculate1Dto3D(i, SizeX, SizeY, SizeZ, out x, out y, out z);
    tab[x, y, z] = ComputeSmth(x, y, z);
});

Podsumowanie

Nie zagłębiałem się jeszcze we właściwości tych klas i nie wiem jak w teorii wypada wydajność i rozłożenie wątków przy zagnieżdżonych wywołaniach Parallel.For, jednak testy pokazują, że najlepiej radzi sobie wersja ostatnia (czasy w formacie Min:Sec:Milisec).

Poza samą różnicą w czasie działania wersji równoległych, najbardziej cieszy mnie przyspieszenie osiągnięte w stosunku do wersji początkowej.

Mam nadzieję, że zachęciłem do zapoznania się z możliwościami nowego C# i korzyściami z tego płynącymi.

Z czego jestem zadowolony:

• przez dłuższy czas byłem zmobilizowany do blogowania, czego skutkiem jest kilka popełnionych postów więcej (i mam nadzieję, że ta tendencja się utrzyma, jeżeli nie wzrośnie),
• podczas researchu tematów opisywanych w ramach konkursu, sporą część z nich przemyciłem do pracy magisterskiej,
• ruch na blogu znacznie się poprawił, do średnio 40-50 unikalnych wizyt dziennie,
• 9 postów zostało „wydotnetomaniakowanych”,
• czytając inne blogi dowiedziałem się wielu ciekawych rzeczy – wg mnie wszyscy wykonali kawał dobrej roboty.

Posty związane z konkursem:

1. „Daj się poznać” – 63. uczestnik (41 odwiedzin)
2. Osadzanie XNA 4.0 w Windows Forms (360 odwiedzin)
3. [XNA] Kamera FPP (267 odwiedzin)
4. Deus ex adfectus machina – menedżer stanów (96 odwiedzin)
5. Pomysły, pomysły, pomysły.. (44 odwiedzin)
6. ThemeFestival na wybiegu, czyli modele (34 odwiedzin)
7. Okiełznać mysz w XNA + WF (111 odwiedzin)
8. [XNA] Picking, czyli zaznaczanie modeli (102 odwiedzin)
9. VS2010 + AnkhSVN (185 odwiedzin)
10. Graf sceny (129 odwiedzin)
11. [XNA] Rysowanie bez modelu (67 odwiedzin)

Projekt ThemeFestival nie umarł, został raczej przesunięty na bliżej nieokreśloną przyszłość i inną platformę sprzętową (z zachowaniem tych samych technologii).

Wszystkim zakwalifikowanym do dalszego etapu konkursu życzę powodzenia i gratuluję

Wierzchołki

Pierwszą rzeczą, na którą należy się zdecydować, to format wierzchołka. Biblioteka XNA dostarcza 4 typy, ale definiowanie własnych nie stanowi większego problemu.

Te typy to (nazwy odpowiadają polom definiującym pojedynczy wierzchołek):

• VertexPositionColor
• VertexPositionTexture
• VertexPositionColorTexture
• VertexPositionNormalTexture

Zabrakło mi w tym zestawie typu wierzchołka przechowującego pozycję, wektor normalny oraz kolor (bez współrzędnych tekstury), poniżej klasa opisująca właśnie taki typ:

public struct VertexPositionNormalColor : IVertexType
{
    public Vector3 Position;
    public Color Color;
    public Vector3 Normal;

    public VertexPositionNormalColor(Vector3 position, Vector3 normal, Color color)
    {
        Position = position;
        Normal  = normal;
        Color = color;
    }

    public static int SizeInBytes = (3 + 3 + 1) * 4; // 3 floats for Position + 3 floats for Normal + 4 bytes for Color

    public static VertexElement[] VertexElements = new[]
    {
        new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
        new VertexElement(sizeof(float) * 3, VertexElementFormat.Color, VertexElementUsage.Color, 0),
        new VertexElement(sizeof(float) * 4, VertexElementFormat.Vector3, VertexElementUsage.Normal, 0),
    };

    public VertexDeclaration VertexDeclaration
    {
        get { return new VertexDeclaration(VertexElements); }
    }
}

Różne sposoby rysowania prymitywów graficznych (punkty, linie, trójkąty) opisuje świetny artykuł na MSDN.

Zielonym do.. dołu.

Drzewa w informatyce rosną w dół. Korzeń znajduje się u szczytu, kolejne gałęzie, węzły (wierzchołki posiadające dzieci) i liście (wierzchołki, nie posiadające dzieci) są umieszczane niżej.

Przykładowe drzewo binarne (takie, w którym każdy wierzchołek może mieć co najwyżej dwoje dzieci) jest przedstawione na rysunku (źródło: Wikipedia).

Koncepcja

Drzewo (bądź graf sceny, będę używał tych określeń zamiennie) posłuży do zorganizowania hierarchii sceny. Każdy z wierzchołków będzie obiektem klasy dziedziczącej po abstrakcyjnej klasie GraphNode.

Będzie ona przechowywać macierz świata dla danego wierzchołka, listę jego dzieci, oraz informację o rodzicu. Pozwoli również na uaktualnienie stanu wierzchołka oraz narysowanie jego zawartości (przy obu metodach skorzystamy z polimorfizmu).

Węzeł (wierzchołek)

Klasa węzła przedstawia się następująco:

public class GraphNode
{
    #region Variables
    private readonly Dictionary<string, GraphNode> children;
    protected Matrix world;
    protected GraphNode parent;
    protected bool Visible;
    public string Name { get; set; }
    public GraphNode Parent { get { return parent; } }
    #endregion

    public GraphNode this[string name]
    {
        get
        {
            if (children.ContainsKey(name))
                return children[name];

            foreach (GraphNode node in children.Values)
            {
                GraphNode res = node[name];
                if (res != null)
                    return res;
            }
            return null;
        }
    }

    public GraphNode()
    {
        parent = null;
        children = new Dictionary<string, GraphNode>();
        world = Matrix.Identity;
        Visible = true;
    }

    public void AddChild(GraphNode child)
    {
        child.parent = this;
        if (children.ContainsKey(child.Name))
            return;
        children.Add(child.Name, child);
    }

    public void RemoveChild(GraphNode child)
    {
        children.Remove(child.Name);
    }

    public virtual void Update(GameTime gameTime)
    {
        foreach (GraphNode child in children.Values)
            child.Update(gameTime);
    }

    public virtual void Draw(GameTime gameTime, Matrix _world)
    {
        foreach (GraphNode child in children.Values)
        {
            if (!child.Visible)
                continue;

            child.Draw(gameTime, _world);
        }
    }
}

Kilka wyjaśnień na temat zorganizowania klasy:

• Każdy węzeł ma swoją nazwę, pozwoli to na odwoływanie się do konkretnego węzła przez odwołanie tylko do korzenia.
• Ze względu na poprzedni punkt, można użyć słownika do przechowywania listy dzieci – to implikuje metody do dodawania i usuwania dzieci.
• Rodzic (pole parent) jest równe null tylko dla korzenia drzewa.
• metody Draw oraz Update są oznaczone jako virtual – będziemy je nadpisywać w klasach pochodnych.

Klasy pochodne będą reprezentować model oraz transformację względem rodzica. Pozwoli to na intuicyjne poruszanie się po grafie.

Węzeł reprezentujący model

Klasa ta jest mało złożona:

public class ModelNode : GraphNode
{
    #region Variables
    private MyModel geometry;
    #endregion

    public MyModel Geometry
    {
        get { return geometry; }
        set { geometry = value; }
    }

    public ModelNode(MyModel geometry)
    {
        this.geometry = geometry;
    }

    public override void Draw(GameTime gameTime, Matrix _world, Matrix view, Matrix projection)
    {
        geometry.Draw(_world, view, projection);
        base.Draw(gameTime, _world, view, projection);
    }
}

Nadpisaliśmy tu tylko metodę odpowiedzialną za odrysowanie siatki.

Węzeł reprezentujący transformację

Kod mówi sam za siebie – uaktualniana jest macierz świata.

public class TransformationNode : GraphNode
{
    public TransformationNode(Matrix transformation)
    {
        world = transformation;
    }

    public void Apply(Matrix transformation)
    {
        world *= transformation;
    }

    public Quaternion Rotation
    {
        get
        {
            Quaternion rotation;
            Vector3 scale;
            Vector3 translation;
            world.Decompose(out scale, out rotation, out translation);
            return rotation;
        }
    }

    public Vector3 Translation
    {
        get
        {
            Quaternion rotation;
            Vector3 scale;
            Vector3 translation;
            world.Decompose(out scale, out rotation, out translation);
            return translation;
        }
    }

    public Matrix Transformation
    {
        get { return world; }
        set { world = value; }
    }

    public override void Draw(GameTime gameTime, Matrix _world, Matrix view, Matrix projection)
    {
        Matrix tmp = _world * world;
        base.Draw(gameTime, tmp, view, projection);
    }
}

Przykład zastosowania

Modelowym przykładem zastosowania grafu sceny jest Układ Słoneczny. Planety krążą wokół Słońca (każda z różną prędkością), dodatkowo każda z nich obraca się wokół własnej osi (każda z nich z różną prędkością), dodatkowo wokół nich krążą satelity (księżyce), które również się obracają.. ufff… sporo tego -> uporządkujmy to. Najpierw rysunek powered by MS Paint:

Prostokąty reprezentują węzły zawierające model do narysowania, okręgi – transformacje. Poszczególne transformacje przedstawiają się następująco („I” to przekształcenie identycznościowe – macierz jednostkowa) :

1. Rotacja wokół osi Z (skierowanej w górę układu współrzędnych) – rotacja Marsa wokół własnej osi.
2. Translacja wzdłuż osi X o odległość Marsa od Słońca.
3. Rotacja wokół osi Z – rotacja Marsa wokół Słońca.
4. Rotacja wokół osi Z (skierowanej w górę układu współrzędnych) – rotacja Ziemi wokół własnej osi.
5. Translacja wzdłuż osi X o odległość Ziemi od Słońca.
6. Rotacja wokół osi Z – rotacja Ziemi wokół Słońca.
7. itd. itd. itd.

Jak będzie wyglądało rysowanie sceny?

1. Zaczynamy od korzenia (transformacja: macierz jednostkowa)
2. Wywołujemy Draw dla pierwszego dziecka (niech będzie to transformacja 1); macierz świata = rotacja wokół Z
3. Wywołujemy Draw dla pierwszego (i, jak się okazuje, jedynego) dziecka węzła z 2) – macierz świata = rotacja wokół Z * translacja
4. Wywołujemy Draw dalej dla dziecka; macierz świata = rotacja wokół Z * translacja * rotacja wokół Z
5. Wywołujemy Draw dla modelu Marsa, ustawiamy odpowiednią macierz świata (ustawiającą model planety w dobre położenie) i rysujemy model, voila!
6. Wracamy z przechodzeniem drzewa do korzenia (ponieważ węzeł z modelem Marsa jest liściem); macierz świata = macierz jednostkowa
7. Wywołujemy Draw dla kolejnego dziecka (transformacja 4); macierz świata = rotacja Ziemi wokół osi Z
8. itd. itd.

Jako, że transformacje są przechowywane względem rodzica (analogia do budowy modelu), transformujemy je do układu globalnego przez kolejne mnożenia macierzy. W ten sposób możemy intuicyjnie zbudować nawet dość skomplikowaną scenę.

Podsumowanie i możliwości rozszerzeń

Przedstawiony graf sceny służy jedynie do odpowiedniego rozmieszczenia obiektów na potrzeby rysowania. Jako rozszerzenie można zamknąć scenę w jakąś strukturę danych do hierarchicznego podziału przestrzeni (np. Octree) aby usprawnić liczenie kolizji między obiektami, lub łatwo eliminować je z rysowania przeprowadzając wstępne testy widoczności obiektu. Ale to już materiał na jedno z innych spotkań.

Jednak po przeniesieniu się na Visual Studio 2010 i tradycyjnej instalacji wtyczki, nie dało się z niej skorzystać. Otóż VS 2010 posiada wbudowane narzędzie do wersjonowania kodu, bug trackingu itp. – Team Foundation Server.

Aby zacząć korzystać z AnkhSVN, należy w opcjach Source Control ustawić korzystanie z opensource’owej wtyczki:

Zaznaczanie, czyli kolizja

Zaznaczanie można zrealizować na kilka sposobów. Można np. rysować każdy z obiektów sceny obiekty unikalnym kolorem do bufora. Potem po pobraniu koloru z interesującego nas miejsca możemy stwierdzić który obiekt został „trafiony”. Tu jednak skupimy się na innym podejściu.

Ideą będzie raycasting, czyli rzucanie promienia. Nasza kamera ma dwie interesujące nas właściwości: położenie i kierunek patrzenia. Chcemy stworzyć promień, który wychodzi z punktu położenia kamery, podąża wzdłuż wektora kierunku patrzenia i sprawdza kolizje z kolejnymi obiektami na scenie. W zależności od potrzeb, będzie nas interesował tylko pierwszy obiekt „uderzony” przez promień lub też cała ich kolekcja. Jednak to już bardziej odległa sprawa, na razie zacznijmy od tego, od czego zaczynać się powinno, czyli od początku.

Tworzenie promienia

XNA (jak zwykle) załatwia większą część pracy za nas, dostarczając nieocenionej metody Vector3 Viewport.Unproject(Vector3 source, Matrix projection, Matrix view, Matrix world); Odwraca ona ciąg przekształceń, który przechodzi każdy punkt sceny; ten ciąg to:

1. przemnożenie przez macierz świata (przekształcenie do przestrzeni świata)
2. przemnożenie przez macierz widoku (przekształcenie do przestrzeni kamery)
3. przemnożenie przez macierz projekcji (rzutowanie na ekran).

W przypadku Unproject, podając punkt na ekranie (we współrzędnych ekranowych) otrzymujemy wektor w przestrzeni świata, krótko mówiąc jest to zamiana współrzędnych 2D na 3D. Aby wyznaczyć kierunek potrzebujemy dwóch takich punktów (trzeba jednocześnie wiedzieć, który z nich jest „bliżej” a który „dalej” jeszcze przed przekształceniem. Stwórzmy więc takie wektory, wyłuskajmy z nich ich pozycje 3D i stwórzmy wektor kierunku patrzenia kamery.

private Ray CalculateCursorRay(float X, float Y, Matrix world, Matrix view, Matrix projection)
{
    Vector3 nearSource = new Vector3(X, Y, 0f);
    Vector3 farSource = new Vector3(X, Y, 1f);

    Vector3 nearPoint = GraphicsDevice.Viewport.Unproject(nearSource, projection, view, world);
    Vector3 farPoint = GraphicsDevice.Viewport.Unproject(farSource, projection, view, world);

    Vector3 direction = farPoint - nearPoint;
    direction.Normalize();

    return new Ray(nearPoint, direction);
}

Klasa Ray, obiektem której jest wynik działania powyższej metody, jest również częścią biblioteki XNA.

Model w kuli, czyli BoundingSphere

Po załadowaniu modelu z pliku (przy użyciu Content.Load()) dla każdej siatki (mesh’a) liczona jest tzw. BoundingSphere. Jak sama nazwa klasy wskazuje, przechowuje ona sferę otaczającą całą siatkę. Jest to podstawowy etap optymalizacji zagadnienia zaznaczania.

Dla każdej siatki sfera otaczająca przechowywana jest w tzw. Mesh space (pozycja względem odpowiedniej siatki), czyli należy przekształcić jej środek i promień przez odpowiednią kość (and. bone, więcej o tym w notce o modelach). Rozbudujmy klasę MyModel o metodę za to odpowiedzialną:

private static BoundingSphere TransformBoundingSphere(BoundingSphere sphere, Matrix transform)
{
    BoundingSphere transformedSphere;
    Vector3 scale3 = new Vector3(sphere.Radius, sphere.Radius, sphere.Radius);

    // transform, do not include translation
    scale3 = Vector3.TransformNormal(scale3, transform);

    // choose maximal scale to fit whole mesh inside sphere
    transformedSphere.Radius = Math.Max(scale3.X, Math.Max(scale3.Y, scale3.Z));
    transformedSphere.Center = Vector3.Transform(sphere.Center, transform);
    return transformedSphere;
}

Skoro przekształcenia BoundingSphere mamy gotowe, możemy zająć się clue całego przedsięwzięcia, czyli faktycznym sprawdzeniem kolizji promienia z kulą otaczającą.

Kolizje, przecięcia..

Podsumujmy fakty:

• mamy dane promienia lecącego przez scenę wzdłuż kierunku patrzenia kamery
• mamy dane kul otaczających każdą siatkę każdego modelu

Jedyne co musimy zrobić to policzyć ich kolizje, policzenie przecięcia promienia (czyli de facto półprostej w przestrzeni 3D) ze sferą nie jest zadaniem specjalnie skomplikowanym, jednak i to XNA rozwiązało za nas, dostarczając narzędzia. Uogólnimy trochę liczenie przecięć tworząc metodę zwracającą informację o kolizji promienia z modelem. Oto ona (umieszczona w klasie MyModel)

public bool Insersects(Ray ray, Matrix world)
{
    // check every mesh of MyModel
    foreach (ModelMesh mesh in model.Meshes)
    {
        // get transformation from Mesh space to world space
        Matrix w = bones[mesh.ParentBone.Index] * world;

        // get BoundingSphere in world space coordinates
        BoundingSphere sphere = TransformBoundingSphere(mesh.BoundingSphere, w);

        // use Intersects method
        if (sphere.Intersects(ray) != null)
        return true;
    }

    // no mesh intersects
    return false;
}

Zastosowaliśmy metodę Intersects() zwracającą nullable float (o typach nullable pisałem tu). Jeżeli wynik metody nie jest null-em, zawiera odległość od początku promienia do punktu przecięcia, ta informacja jednak nie jest nam potrzebna.

Uwagi

Powyższa metoda jest dobra na początek, jednak przy dalszych zastosowaniach może być niewystarczająca. Dlaczego? Z powodu mniejszej, niż wymagana dokładności. Otóż, jeżeli metoda Intersects() zwróci false to wiemy na pewno, że do kolizji nie doszło. Natomiast nie możemy być pewni, czy rzeczywiście trafiliśmy w siatkę, jeżeli Intersects() zwróci true. W tym przypadku jest to dobry początek do dalszych obliczeń.

Receptami na ten problem mogą być: złożenie modelu z większej ilości małych siatek lub zastosowanie algorytmów do aproksymacji siatek kulami (postaram się przynajmniej jeden taki opisać).

Mysz w XNA

Dobranie się do pozycji myszy w czystym XNA jest niezmiernie łatwo. Służy do tego obiekt klasy MouseState, który wypełniamy bieżącymi informacjami fragmentem kodu:

MouseState mouseState = Mouse.GetState();

Po wykonaniu takiej operacji obiekt mouseState zawiera aktualną pozycję myszy (pola X oraz Y), stan przycisków (lewy, prawy, środkowy – stany wciśnięty lub nie) oraz np. wartość rolki (Scroll). Sprawdzenie tego będzie proste:

• do klasy dodajemy pole Vector2 position;
• w metodzie Update() pobieramy pozycję myszy i zapamiętujemy ją w position
• w metodzie Draw() rysujemy w miejscu wskazanym przez position krzyż oznaczający kursor: . Skorzystamy tu z informacji z poprzedniego wpisu do załadowania tekstury.

w metodzie LoadContent()

cursor = Content.Load<Texture2D>("Textures\\cursor");

w metodzie Update()

private Vector2 position;

protected override void Update(GameTime gameTime)
{
    MouseState ms = Mouse.GetState();
    position = new Vector2(ms.X, ms.Y);
}

metoda Draw()

protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);

    spriteBatch.Begin();
    Vector2 textureCenter = new Vector2(cursor.Width / 2.0f, cursor.Height / 2.0f);
    spriteBatch.Draw(cursor, position, null, Color.White, 0.0f, textureCenter, 1.0f, SpriteEffects.None, 0.0f);
    spriteBatch.End();

    base.Draw(gameTime);
}

Efekt zastosowania powyższego kodu widać na obrazku poniżej (UWAGA, jest to kod TYLKO dla XNA, bez umieszczania renderingu na formie Windows Forms)

Jako, że ani PrintScreen ani Fraps nie rejestrują kursora myszy przy robieniu screenshot’a będę go zaznaczał czerwoną kropką.

Ten sam kod zastosujmy przy użyciu Windows Forms – rendering odbywa się na formie, pozycja kursora odczytywana jest przez Mouse.GetState();

Houston, we have a problem..

Mysz z Windows Forms

Rozwiązaniem okazało się użycie pozycji myszy pobranej z Windows Forms, z przetransformowaniem jej do współrzędnych okna. Stworzyłem drugą teksturę (czerwony krzyżyk), aby wyświetlić ją w miejscu obliczonym drugim sposobem i do porównania wyników, kod poniżej:

w metodzie LoadContent()

redCursor = Content.Load<Texture2D>("Textures\\cursor2");

w metodzie Update()

private Vector2 position;
private Vector2 wfPosition;

protected override void Update(GameTime gameTime)
{
    MouseState ms = Mouse.GetState();
    position = new Vector2(ms.X, ms.Y);

    System.Drawing.Point mousePos = form.PointToClient(Form.MousePosition);
    wfPosition = new Vector2(mousePos.X, mousePos.Y);
}

metoda Draw()

protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);

    spriteBatch.Begin();
    Vector2 textureCenter = new Vector2(cursor.Width / 2.0f, cursor.Height / 2.0f);
    spriteBatch.Draw(cursor, position, null, Color.White, 0.0f, textureCenter, 1.0f, SpriteEffects.None, 0.0f);
    spriteBatch.Draw(redCursor, wfPosition, null, Color.White, 0.0f, new Vector2(redCursor.Width, redCursor.Height), 1.0f, SpriteEffects.None, 0.0f);
    spriteBatch.End();

    base.Draw(gameTime);
}

Efekt poniżej:

Jeżeli dokładnie nie widać czerwonej kropki – jest ona w okolicach środka czerwonego krzyża

Podsumowanie

Przy zaznaczaniu będzie trzeba zastosować podejście łączone – pozycję myszy pobierać przy użyciu Windows Forms (Form.MousePosition + Form.PointToClient()) natomiast informacje o wciśnięciu przycisku z obiektu MouseState.