Poznaj możliwości DirectX!

DirectX to zestaw funkcji wspierających tworzenie zaawansowanej grafiki w systemie Windows. Historia tego dodatku sięga roku 1995, kiedy po wprowadzeniu na rynek systemu Windows 95 programiści tworzący gry z dużym oporem rozstawali się z systemem DOS. Od tego czasu DirectX jest nieustannie rozwijany, a gry i trójwymiarowe animacje tworzone z wykorzystaniem najnowszej wersji zapierają dech w piersiach. Jeżeli chcesz poznać możliwości tego dodatku i wykorzystać jego potencjał, to trafiłeś na doskonałą publikację!

Żadna inna nie omawia w tak szczegółowy sposób zagadnień związanych z tworzeniem grafiki i animacji przy użyciu DirectX. Książka została podzielona na trzy części. Pierwsza pozwoli Ci zdobyć podstawową wiedzę na temat fundamentów grafiki trójwymiarowej. Nauczysz się lub przypomnisz sobie, jak prowadzić działania na wektorach, przekształcać te wektory i stosować macierze. W części drugiej szczególny nacisk został położony na poznanie Direct3D. Dowiesz się, jak zainicjalizować system, nanosić tekstury oraz cieniować obiekty. Część trzecia zawiera mnóstwo przydatnych informacji na temat widoku pierwszej osoby, prowadzenia kamery, systemu cząstek, zaawansowanego mapowania oraz animowania. Książka ta jest obowiązkową lekturą każdego programisty zajmującego się grafiką 3D!

Dzięki tej książce:

• poznasz fundamenty grafiki 3D — wektory, macierze i ich przekształcenia
• zaznajomisz się z dostępnymi funkcjami oraz sposobem pracy z Direct3D
• dowiesz się, jak korzystać z tekstur i cieni
• wykorzystasz system cząstek
• poznasz potencjał DirectX

Zbuduj wirtualny świat za pomocą DirectX!

Osoby które kupowały "Projektowanie gier 3D. Wprowadzenie do technologii DirectX 11", wybierały także:

• Mastering Game Design with Unity 2021 88,94 zł, (76,49 zł -14%)
• Game Development with Unreal Engine 5 84,28 zł, (80,91 zł -4%)
• Learn Python Game Development with ChatGPT 84,99 zł
• Projektowanie gier 3D. Wprowadzenie do technologii DirectX 11 129,00 zł
• DirectX. Rendering w czasie rzeczywistym 79,00 zł

Spis treści

Projektowanie gier 3D. Wprowadzenie do technologii DirectX 11 eBook -- spis treści

Podziękowania (19)

Wstęp (21)

• Docelowy odbiorca (22)
• Wymagana wiedza (22)
• Potrzebne narzędzia programistyczne i sprzęt (23)
• Biblioteka D3DX (23)
• Dokumentacja SDK i przykładowe aplikacje (23)
• Czytelność (25)
• Przykładowe programy i dodatkowe źródła online (26)
• Przygotowanie projektu aplikacji w Visual Studio 2010 (26)
  • Tworzenie projektu Win32 (26)
  • Dołączanie bibliotek DirectX (27)
  • Ustawianie ścieżek wyszukiwania (28)
  • Wprowadzanie kodu źródłowego i budowa projektu (30)

CZĘŚĆ I. PODSTAWY MATEMATYCZNE

Rozdział 1. Algebra wektorów (35)

• 1.1. Wektory (35)
  • 1.1.1. Wektory i układy współrzędnych (36)
  • 1.1.2. Lewo- i praworęczne układy współrzędnych (38)
  • 1.1.3. Podstawowe działania na wektorach (38)
• 1.2. Długość i wektory jednostkowe (40)
• 1.3. Iloczyn skalarny (42)
  • 1.3.1. Ortogonalizacja (44)
• 1.4. Iloczyn wektorowy (46)
  • 1.4.1. Pseudoiloczyn wektorowy dla przestrzeni dwuwymiarowych (47)
  • 1.4.2. Ortogonalizacja z iloczynem wektorowym (47)
• 1.5. Punkty (48)
• 1.6. Wektory XNA Math (49)
  • 1.6.1. Typy wektorowe (50)
  • 1.6.2. Metody ładujące i metody zapisujące (51)
  • 1.6.3. Przekazywanie argumentów (52)
  • 1.6.4. Stałe wektorowe (53)
  • 1.6.5. Przeciążone operatory (54)
  • 1.6.6. Przydatne funkcje (54)
  • 1.6.7. Funkcje ustawiające (55)
  • 1.6.8. Funkcje wektorowe (56)
  • 1.6.9. Błąd obliczeń zmiennoprzecinkowych (59)
• 1.7. Podsumowanie (60)
• 1.8. Ćwiczenia (61)

Rozdział 2. Algebra macierzy (65)

• 2.1. Definicja (65)
• 2.2. Mnożenie macierzy (67)
  • 2.2.1. Definicja (67)
  • 2.2.2. Mnożenie macierzy przez wektor (68)
  • 2.2.3. Łączność (69)
• 2.3. Macierz transponowana (69)
• 2.4. Macierz jednostkowa (70)
• 2.5. Wyznacznik macierzy (71)
  • 2.5.1. Macierze zredukowane (72)
  • 2.5.2. Definicja (72)
• 2.6. Macierz dołączona (74)
• 2.7. Macierz odwrotna (74)
• 2.8. Macierze XNA (76)
  • 2.8.1. Typy macierzowe (76)
  • 2.8.2. Funkcje macierzowe (78)
  • 2.8.3. Przykładowy program z macierzami XNA (78)
• 2.9. Podsumowanie (80)
• 2.10. Ćwiczenia (81)

Rozdział 3. Przekształcenia (85)

• 3.1. Przekształcenia liniowe (85)
  • 3.1.1. Definicja (85)
  • 3.1.2. Reprezentacja macierzowa (86)
  • 3.1.3. Skalowanie (87)
  • 3.1.4. Obrót (89)
• 3.2. Przekształcenia afiniczne (91)
  • 3.2.1. Współrzędne jednorodne (91)
  • 3.2.2. Definicja i reprezentacja macierzowa (92)
  • 3.2.3. Przesunięcie (93)
  • 3.2.4. Macierze afiniczne dla skalowania i obrotu (95)
  • 3.2.5. Interpretacja geometryczna macierzy przekształcenia afinicznego (95)
• 3.3. Składanie przekształceń (97)
• 3.4. Przekształcenia zamiany współrzędnych (98)
  • 3.4.1. Wektory (99)
  • 3.4.2. Punkty (100)
  • 3.4.3. Reprezentacja macierzowa (101)
  • 3.4.4. Łączność i macierze zamiany współrzędnych (102)
  • 3.4.5. Macierze odwrotne i macierze zamiany współrzędnych (102)
• 3.5. Macierz przekształcenia kontra macierz zamiany współrzędnych (103)
• 3.6. Funkcje przekształcające XNA Math (105)
• 3.7. Podsumowanie (106)
• 3.8. Ćwiczenia (107)

CZĘŚĆ II. PODSTAWY DIRECT3D

Rozdział 4. Inicjalizacja Direct3D (115)

• 4.1. Uwagi wstępne (115)
  • 4.1.1. Przegląd Direct3D (115)
  • 4.1.2. Technologia COM (116)
  • 4.1.3. Tekstury i formaty zasobów (116)
  • 4.1.4. Łańcuch wymiany i stronicowanie (117)
  • 4.1.5. Buforowanie głębokości (118)
  • 4.1.6. Widoki zasobów tekstury (121)
  • 4.1.7. Teoria wielokrotnego próbkowania (122)
  • 4.1.8. Wielokrotne próbkowanie w Direct3D (124)
  • 4.1.9. Możliwości sprzętu (124)
• 4.2. Inicjalizacja Direct3D (125)
  • 4.2.1. Tworzenie urządzenia i kontekstu (126)
  • 4.2.2. Sprawdzenie obsługiwanego poziomu jakości antyaliasingu z 4-krotnym próbkowaniem (128)
  • 4.2.3. Opis łańcucha wymiany (129)
  • 4.2.4. Tworzenie łańcucha wymiany (130)
  • 4.2.5. Tworzenie widoku celu renderowania (131)
  • 4.2.6. Tworzenie bufora i widoku głębokości/szablonu (132)
  • 4.2.7. Powiązanie widoków z etapem łączenia wyników (135)
  • 4.2.8. Ustawienie okna widoku (135)
• 4.3. Czas i animacja (137)
  • 4.3.1. Licznik wydajności (137)
  • 4.3.2. Klasa GameTimer (138)
  • 4.3.3. Okresy między klatkami (139)
  • 4.3.4. Czas całkowity (140)
• 4.4. Szkielet przykładowych aplikacji (143)
  • 4.4.1. D3DApp (144)
  • 4.4.2. Metody niezwiązane ze szkieletem (145)
  • 4.4.3. Metody szkieletu (146)
  • 4.4.4. Statystyki klatek (147)
  • 4.4.5. Obsługa komunikatów (148)
  • 4.4.6. Tryb pełnoekranowy (150)
  • 4.4.7. Aplikacja "Init Direct3D" (151)
• 4.5. Wykrywanie błędów w aplikacjach Direct3D (152)
• 4.6. Podsumowanie (154)
• 4.7. Ćwiczenia (155)

Rozdział 5. Potok renderowania (159)

• 5.1. Złudzenie trójwymiarowości (159)
• 5.2. Reprezentacja modelu (162)
• 5.3. Kolory w grafice komputerowej (163)
  • 5.3.1. Działania na kolorach (165)
  • 5.3.2. Kolor 128-bitowy (165)
  • 5.3.3. Kolor 32-bitowy (166)
• 5.4. Etapy potoku renderowania (168)
• 5.5. Etap zbierania danych (168)
  • 5.5.1. Wierzchołki (168)
  • 5.5.2. Topologia prymitywów (168)
  • 5.5.3. Indeksy (173)
• 5.6. Etap cieniowania wierzchołków (175)
  • 5.6.1. Przestrzeń lokalna i przestrzeń świata (175)
  • 5.6.2. Przestrzeń widoku (179)
  • 5.6.3. Rzutowanie i jednorodna przestrzeń obcinania (182)
• 5.7. Etapy teselacji (190)
• 5.8. Etap cieniowania geometrii (191)
• 5.9. Obcinanie (191)
• 5.10. Etap rasteryzacji (193)
  • 5.10.1. Przekształcenie okna widoku (193)
  • 5.10.2. Usuwanie niewidocznych powierzchni (194)
  • 5.10.3. Interpolacja atrybutów wierzchołków (195)
• 5.11. Etap cieniowania pikseli (197)
• 5.12. Etap łączenia wyników (197)
• 5.13. Podsumowanie (197)
• 5.14. Ćwiczenia (198)

Rozdział 6. Rysowanie w Direct3D (203)

• 6.1. Wierzchołki i formaty wejścia (203)
• 6.2. Bufory wierzchołków (208)
• 6.3. Indeksy i bufory indeksów (212)
• 6.4. Przykładowy shader wierzchołków (215)
• 6.5. Bufor stały (218)
• 6.6. Przykładowy shader pikseli (219)
• 6.7. Stany renderowania (221)
• 6.8. Efekty (224)
  • 6.8.1. Pliki efektów (224)
  • 6.8.2. Kompilacja shaderów (226)
  • 6.8.3. Łączenie efektów z aplikacją C++ (229)
  • 6.8.4. Rysowanie za pomocą efektów (230)
  • 6.8.5. Wczesna kompilacja efektu (231)
  • 6.8.6. Framework efektów jako "generator shaderów" (233)
  • 6.8.7. Kod asemblera (237)
• 6.9. Aplikacja "Box" (242)
• 6.10. Aplikacja "Hills" (248)
  • 6.10.1. Generowanie wierzchołków siatki (248)
  • 6.10.2. Generowanie indeksów siatki (251)
  • 6.10.3. Funkcja wyznaczająca wysokość (252)
• 6.11. Aplikacja "Shapes" (254)
  • 6.11.1. Tworzenie siatki walca (255)
  • 6.11.2. Tworzenie siatki sfery (259)
  • 6.11.3. Tworzenie siatki sfery geodezyjnej (259)
  • 6.11.4. Kod aplikacji (262)
• 6.12. Ładowanie geometrii z pliku (266)
• 6.13. Dynamiczne bufory wierzchołków (266)
• 6.14. Podsumowanie (269)
• 6.15. Ćwiczenia (271)

Rozdział 7. Oświetlenie (275)

• 7.1. Interakcja między światłem i materiałem (276)
• 7.2. Wektory normalne (277)
  • 7.2.1. Obliczanie wektorów normalnych (279)
  • 7.2.2. Przekształcenia wektorów normalnych (280)
• 7.3. Prawo Lamberta (283)
• 7.4. Światło rozproszone (283)
• 7.5. Światło otoczenia (285)
• 7.6. Światło odbite (285)
• 7.7. Podsumowanie modelu (288)
• 7.8. Określanie kolorów materiałów (289)
• 7.9. Światła równoległe (291)
• 7.10. Światła punktowe (291)
  • 7.10.1. Wygaszanie (292)
  • 7.10.2. Zasięg (293)
• 7.11. Światła reflektorowe (293)
• 7.12. Implementacja (294)
  • 7.12.1. Struktury oświetlenia (294)
  • 7.12.2. Upakowanie struktur (296)
  • 7.12.3. Implementacja świateł kierunkowych (298)
  • 7.12.4. Implementacja świateł punktowych (299)
  • 7.12.5. Implementacja świateł reflektorowych (300)
• 7.13. Aplikacja "Lighting" (301)
  • 7.13.1. Plik efektu (301)
  • 7.13.2. Kod aplikacji C++ (304)
  • 7.13.3. Obliczanie normalnych (306)
• 7.14. Aplikacja "Lit Skull" (307)
• 7.15. Podsumowanie (309)
• 7.16. Ćwiczenia (310)

Rozdział 8. Tekstury (313)

• 8.1. Podsumowanie wiadomości na temat tekstur i zasobów (313)
• 8.2. Współrzędne tekstury (316)
• 8.3. Tworzenie i włączanie obsługi tekstury (318)
• 8.4. Filtry (320)
  • 8.4.1. Powiększanie (320)
  • 8.4.2. Pomniejszanie (323)
  • 8.4.3. Filtrowanie anizotropowe (324)
• 8.5. Próbkowanie tekstur (324)
• 8.6. Tekstury i materiały (326)
• 8.7. Aplikacja "Crate" (326)
  • 8.7.1. Określanie współrzędnych tekstury (326)
  • 8.7.2. Tworzenie tekstury (327)
  • 8.7.3. Ustawianie tekstury (327)
  • 8.7.4. Aktualizacja efektu bazowego (328)
• 8.8. Tryby adresowania (332)
• 8.9. Przekształcanie tekstur (335)
• 8.10. Aplikacja "Land Tex" (335)
  • 8.10.1. Generowanie współrzędnych tekstury dla siatki (336)
  • 8.10.2. Kafelkowanie (337)
  • 8.10.3. Animacja tekstury (338)
• 8.11. Formaty kompresji tekstur (338)
• 8.12. Podsumowanie (341)
• 8.13. Ćwiczenia (341)

Rozdział 9. Mieszanie kolorów (345)

• 9.1. Równanie mieszania (346)
• 9.2. Operacje mieszania (347)
• 9.3. Współczynniki mieszania (347)
• 9.4. Stan mieszania (348)
• 9.5. Przykłady (351)
  • 9.5.1. Mieszanie bez zapisu koloru (351)
  • 9.5.2. Dodawanie i odejmowanie kolorów (352)
  • 9.5.3. Mnożenie kolorów (352)
  • 9.5.4. Przezroczystość (353)
  • 9.5.5. Mieszanie kolorów a bufor głębokości (354)
• 9.6. Kanały alfa (355)
• 9.7. Obcinanie pikseli (356)
• 9.8. Mgła (360)
• 9.9. Podsumowanie (365)
• 9.10. Ćwiczenia (366)

Rozdział 10. Szablonowanie (369)

• 10.1. Formaty buforów głębokości/szablonu i ich czyszczenie (370)
• 10.2. Test szablonu (371)
• 10.3. Blok stanu głębokości/szablonu (372)
  • 10.3.1. Ustawienia głębi (372)
  • 10.3.2. Ustawienia szablonu (373)
  • 10.3.3. Tworzenie i wiązanie stanu głębokości/szablonu (374)
  • 10.3.4. Stany głębokości/szablonu w plikach efektów (375)
• 10.4. Implementacja luster płaskich (376)
  • 10.4.1. Symulowanie lustra (376)
  • 10.4.2. Definiowanie stanów głębokości/szablonu lustra (378)
  • 10.4.3. Rysowanie sceny (379)
  • 10.4.4. Kolejność nawijania i odbicia (381)
• 10.5. Implementacja cieni płaskich (382)
  • 10.5.1. Cienie świateł równoległych (382)
  • 10.5.2. Cienie świateł punktowych (385)
  • 10.5.3. Uogólniona macierz cienia (386)
  • 10.5.4. Zapobieganie podwójnemu mieszaniu przy użyciu bufora szablonowego (386)
  • 10.5.5. Kod cienia (387)
• 10.6. Podsumowanie (388)
• 10.7. Ćwiczenia (389)

Rozdział 11. Cieniowanie geometrii (395)

• 11.1. Programowanie shaderów geometrii (396)
• 11.2. Aplikacja "Tree Billboards" (400)
  • 11.2.1. Założenia (400)
  • 11.2.2. Struktura wierzchołka (403)
  • 11.2.3. Plik efektu (403)
  • 11.2.4. Obiekt SV_PrimitiveID (408)
• 11.3. Tablice tekstur (409)
  • 11.3.1. Założenia (409)
  • 11.3.2. Próbkowanie tablicy tekstur (410)
  • 11.3.3. Ładowanie tablic tekstur (410)
  • 11.3.4. Podzasoby tekstury (414)
• 11.4. Technika alpha-to-coverage (415)
• 11.5. Podsumowanie (416)
• 11.6. Ćwiczenia (418)

Rozdział 12. Shader obliczeniowy (421)

• 12.1. Wątki i grupy wątków (422)
• 12.2. Prosty shader obliczeniowy (425)
• 12.3. Zasoby danych wejściowych i wyjściowych (426)
  • 12.3.1. Wejściowe tekstury (426)
  • 12.3.2. Tekstury wyjściowe i widoki nieuporządkowanego dostępu (UAV) (426)
  • 12.3.3. Indeksowanie i próbkowanie tekstur (428)
  • 12.3.4. Zasoby ustrukturyzowanych buforów (430)
  • 12.3.5. Kopiowanie wyników shadera obliczeniowego do pamięci systemowej (433)
• 12.4. Wartości systemowe identyfikujące wątki (436)
• 12.5. Bufor dopisywania i bufor konsumowany (437)
• 12.6. Pamięć współdzielona i synchronizacja (439)
• 12.7. Aplikacja "Blur" (440)
  • 12.7.1. Algorytm rozmywania (440)
  • 12.7.2. Renderowanie do tekstury (443)
  • 12.7.3. Implementacja rozmycia (445)
  • 12.7.4. Program shadera obliczeniowego (449)
• 12.8. Inne źródła (454)
• 12.9. Podsumowanie (455)
• 12.10. Ćwiczenia (457)

Rozdział 13. Etapy teselacji (459)

• 13.1. Typy prymitywów teselacji (460)
  • 13.1.1. Teselacja i shader wierzchołków (461)
• 13.2. Shader powłoki (461)
  • 13.2.1. Stały shader powłoki (461)
  • 13.2.2. Shader powłoki punktów kontrolnych (463)
• 13.3. Etap teselatora (465)
  • 13.3.1. Przykłady teselacji czworokątnej łaty (465)
  • 13.3.2. Przykłady teselacji trójkątnej łaty (466)
• 13.4. Shader dziedziny (466)
• 13.5. Teselacja czworokąta (468)
• 13.6. Czworokątne łaty Béziera trzeciego stopnia (471)
  • 13.6.1. Krzywe Béziera (471)
  • 13.6.2. Powierzchnie Béziera trzeciego stopnia (474)
  • 13.6.3. Kod do obliczeń powierzchni Béziera trzeciego stopnia (475)
  • 13.6.4. Określanie geometrii łat (476)
• 13.7. Podsumowanie (478)
• 13.8. Ćwiczenia (479)

CZĘŚĆ III. TEMATY

Rozdział 14. Kamera pierwszej osoby (483)

• 14.1. Przekształcenie widoku (483)
• 14.2. Klasa kamery (485)
• 14.3. Implementacje wybranych metod (486)
  • 14.3.1. Metody zwracające wartość XMVECTOR (486)
  • 14.3.2. Metoda SetLens (487)
  • 14.3.3. Dodatkowe informacje o ostrosłupie widzenia (487)
  • 14.3.4. Przekształcanie kamery (488)
  • 14.3.5. Budowa macierzy widoku (489)
• 14.4. Użycie klasy kamery (490)
• 14.5. Podsumowanie (491)
• 14.6. Ćwiczenia (492)

Rozdział 15. Instancjonowanie i usuwanie powierzchni poza ostrosłupem widzenia (493)

• 15.1. Instancjonowanie sprzętowe (493)
  • 15.1.1. Shader wierzchołków (494)
  • 15.1.2. Przesyłanie strumieniowe danych instancji (495)
  • 15.1.3. Rysowanie danych instancji (496)
  • 15.1.4. Tworzenie bufora instancji (497)
• 15.2. Bryły brzegowe i ostrosłupy widzenia (498)
  • 15.2.1. Biblioteka XNA Collision (498)
  • 15.2.2. Prostopadłościany (498)
  • 15.2.3. Sfery (503)
  • 15.2.4. Ostrosłupy widzenia (503)
• 15.3. Usuwanie powierzchni poza ostrosłupem widzenia (508)
• 15.4. Podsumowanie (511)
• 15.5. Ćwiczenia (512)

Rozdział 16. Wskazywanie obiektów (515)

• 16.1. Przekształcenie ekranu do okna rzutu (517)
• 16.2. Promień wskazujący w przestrzeni świata/lokalnej (520)
• 16.3. Przecięcie promienia i siatki obiektu (521)
  • 16.3.1. Przecięcie promienia i prostopadłościanu AABB (522)
  • 16.3.2. Przecięcie promienia i sfery (523)
  • 16.3.3. Przecięcie promienia i trójkąta (524)
• 16.4. Aplikacja demonstracyjna (526)
• 16.5. Podsumowanie (527)
• 16.6. Ćwiczenia (527)

Rozdział 17. Mapowanie sześcienne (529)

• 17.1. Mapowanie sześcienne (529)
• 17.2. Tekstury otoczenia (531)
  • 17.2.1. Ładowanie i używanie tekstur sześciennych w Direct3D (534)
• 17.3. Teksturowanie nieba (535)
• 17.4. Modelowanie odbić (537)
• 17.5. Dynamiczne tekstury sześcienne (539)
  • 17.5.1. Budowa tekstury sześciennej i widoków celu renderowania (539)
  • 17.5.2. Budowa bufora głębokości i okna widoku (542)
  • 17.5.3. Ustawianie kamery (543)
  • 17.5.4. Rysowanie do tekstury sześciennej (544)
• 17.6. Dynamiczne tekstury sześcienne w shaderze geometrii (545)
• 17.7. Podsumowanie (547)
• 17.8. Ćwiczenia (548)

Rozdział 18. Mapowanie normalnych i mapowanie przemieszczeń (551)

• 18.1. Do czego nam to potrzebne? (551)
• 18.2. Mapy normalnych (552)
• 18.3. Przestrzeń tekstury (przestrzeń styczna) (555)
• 18.4. Przestrzeń styczna do wierzchołka (557)
• 18.5. Przekształcanie z przestrzeni stycznej do przestrzeni obiektu (558)
• 18.6. Mapowanie normalnych w kodzie shadera (559)
• 18.7. Mapowanie przemieszczeń (563)
• 18.8. Mapowanie przemieszczeń w kodzie shadera (565)
  • 18.8.1. Typ prymitywu (565)
  • 18.8.2. Shader wierzchołków (566)
  • 18.8.3. Shader powłoki (567)
  • 18.8.4. Shader dziedziny (569)
• 18.9. Podsumowanie (570)
• 18.10. Ćwiczenia (571)

Rozdział 19. Renderowanie terenu (575)

• 19.1. Mapy wysokości (575)
  • 19.1.1. Tworzenie mapy wysokości (577)
  • 19.1.2. Ładowanie pliku RAW (578)
  • 19.1.3. Wygładzanie (579)
  • 19.1.4. Widok zasobu shadera mapy wysokości (582)
• 19.2. Teselacja terenu (583)
  • 19.2.1. Budowa siatki (583)
  • 19.2.2. Shader wierzchołków terenu (586)
  • 19.2.3. Współczynniki teselacji (587)
  • 19.2.4. Mapowanie przemieszczeń (589)
  • 19.2.5. Szacowanie wektora stycznego i normalnego (590)
• 19.3. Usuwanie łat poza ostrosłupem widzenia (591)
• 19.4. Teksturowanie (596)
• 19.5. Wysokość terenu (598)
• 19.6. Podsumowanie (601)
• 19.7. Ćwiczenia (602)

Rozdział 20. Systemy cząsteczek i wyjście strumieniowe (605)

• 20.1. Reprezentacja cząsteczek (605)
• 20.2. Ruch cząsteczek (607)
• 20.3. Losowość (609)
• 20.4. Mieszanie kolorów i systemy cząsteczek (611)
• 20.5. Wyjście strumieniowe (613)
  • 20.5.1. Tworzenie shadera geometrii dla wyjścia strumieniowego (613)
  • 20.5.2. Wyjście strumieniowe bez renderowania (614)
  • 20.5.3. Tworzenie bufora wierzchołków dla wyjścia strumieniowego (616)
  • 20.5.4. Wiązanie z etapem wyjścia strumieniowego (616)
  • 20.5.5. Odwiązywanie od etapu wyjścia strumieniowego (616)
  • 20.5.6. Automatyczne rysowanie (617)
  • 20.5.7. Przełączanie buforów wierzchołków (617)
• 20.6. System cząsteczek bazujący na procesorze graficznym (618)
  • 20.6.1. Efekty cząsteczkowe (618)
  • 20.6.2. Klasa ParticleSystem (618)
  • 20.6.3. Emitery (620)
  • 20.6.4. Inicjalizacja bufora wierzchołków (620)
  • 20.6.5. Metoda Update/Draw (621)
• 20.7. Ogień (623)
• 20.8. Deszcz (627)
• 20.9. Podsumowanie (632)
• 20.10. Ćwiczenia (633)

Rozdział 21. Mapowanie cieni (635)

• 21.1. Renderowanie głębokości sceny (635)
• 21.2. Rzutowanie ortograficzne (638)
• 21.3. Współrzędne rzutowe tekstury (640)
  • 21.3.1. Implementacja (642)
  • 21.3.2. Punkty poza ostrosłupem widzenia (643)
  • 21.3.3. Rzutowanie ortograficzne (643)
• 21.4. Mapowanie cieni (644)
  • 21.4.1. Opis algorytmu (644)
  • 21.4.2. Obciążanie głębokości i aliasing (645)
  • 21.4.3. Filtrowanie PCF (648)
  • 21.4.4. Budowa mapy cieni (652)
  • 21.4.5. Współczynnik cienia (656)
  • 21.4.6. Test zacienienia (657)
  • 21.4.7. Renderowanie mapy cieni (661)
• 21.5. Duże jądra PCF (661)
  • 21.5.1. Funkcje DDX i DDY (662)
  • 21.5.2. Rozwiązanie problemu dużego jądra PCF (663)
  • 21.5.3. Alternatywne rozwiązanie problemu dużego jądra PCF (665)
• 21.6. Podsumowanie (666)
• 21.7. Ćwiczenia (667)

Rozdział 22. Okluzja otoczenia (669)

• 22.1. Okluzja otoczenia na podstawie śledzenia promieni (669)
• 22.2. Okluzja otoczenia przestrzeni ekranu (674)
  • 22.2.1. Przebieg renderowania normalnych i głębokości (674)
  • 22.2.2. Przebieg okluzji otoczenia (675)
  • 22.2.3. Przebieg rozmycia (683)
  • 22.2.4. Wykorzystanie mapy okluzji otoczenia (686)
• 22.3. Podsumowanie (689)
• 22.4. Ćwiczenia (689)

Rozdział 23. Siatki (693)

• 23.1. Format .m3d (694)
  • 23.1.1. Nagłówek (694)
  • 23.1.2. Materiały (695)
  • 23.1.3. Podzbiory (696)
  • 23.1.4. Wierzchołki i indeksy trójkątów (697)
• 23.2. Geometria siatki (699)
• 23.3. Klasa BasicModel (700)
• 23.4. Aplikacja "Mesh Viewer" (701)
• 23.5. Podsumowanie (701)
• 23.6. Ćwiczenia (702)

Rozdział 24. Kwaterniony (703)

• 24.1. Liczby zespolone (704)
  • 24.1.1. Definicje (704)
  • 24.1.2. Interpretacja geometryczna (705)
  • 24.1.3. Postać biegunowa i obroty (705)
• 24.2. Algebra kwaternionów (707)
  • 24.2.1. Definicja i podstawowe działania (707)
  • 24.2.2. Wzory skróconego mnożenia (708)
  • 24.2.3. Własności (708)
  • 24.2.4. Konwersje (709)
  • 24.2.5. Sprzężenie i norma (709)
  • 24.2.6. Kwaterniony odwrotne (710)
  • 24.2.7. Postać biegunowa (711)
• 24.3. Kwaterniony jednostkowe i obroty (712)
  • 24.3.1. Operator obrotu (712)
  • 24.3.2. Kwaternionowy operator obrotu w postaci macierzy (714)
  • 24.3.3. Zapis macierzy w postaci kwaternionowego operatora obrotu (716)
  • 24.3.4. Złożenie (717)
• 24.4. Interpolacja kwaternionów (718)
• 24.5. Funkcje kwaternionowe XNA Math (723)
• 24.6. Aplikacja "Quaternions" (723)
• 24.7. Podsumowanie (728)
• 24.8. Ćwiczenia (729)

Rozdział 25. Animacja postaci (731)

• 25.1. Hierarchie układów odniesienia (731)
  • 25.1.1. Ujęcie matematyczne (733)
• 25.2. Siatki-skóry (735)
  • 25.2.1. Definicje (735)
  • 25.2.2. Przekształcenie kość - szkielet (736)
  • 25.2.3. Przekształcenie siatka - kość (736)
  • 25.2.4. Animacja szkieletu (737)
  • 25.2.5. Obliczanie przekształcenia finalnego (738)
• 25.3. Uśrednianie wierzchołków (740)
• 25.4. Ładowanie danych animacji w formacie .m3d (743)
  • 25.4.1. Dane wierzchołka skóry (743)
  • 25.4.2. Przekształcenia siatka - kość (744)
  • 25.4.3. Hierarchia (745)
  • 25.4.4. Dane animacji (746)
  • 25.4.5. Klasa M3DLoader (748)
• 25.5. Aplikacja "Skinned Mesh" (749)
• 25.6. Podsumowanie (750)
• 25.7. Ćwiczenia (751)

Dodatek A. Wprowadzenie do programowania Windows (753)

• A.1. Zagadnienia podstawowe (754)
  • A.1.1. Zasoby (754)
  • A.1.2. Zdarzenia, kolejka komunikatów, komunikaty i pętla komunikatów (754)
  • A.1.3. Interfejs graficzny (755)
  • A.1.4. Unicode (755)
• A.2. Prosta aplikacja Windows (755)
• A.3. Analiza prostej aplikacji Windows (760)
  • A.3.1. Dołączanie plików, zmienne globalne i prototypy (761)
  • A.3.2. Funkcja WinMain (761)
  • A.3.3. Struktura WNDCLASS i jej rejestracja (762)
  • A.3.4. Tworzenie i wyświetlanie okna (763)
  • A.3.5. Pętla komunikatów (765)
  • A.3.6. Procedura okna (766)
  • A.3.7. Funkcja MessageBox (768)
• A.4. Ulepszona pętla komunikatów (768)
• A.5. Podsumowanie (769)
• A.6. Ćwiczenia (770)

Dodatek B. Język HLSL (771)

• Typy zmiennych (771)
  • Typy skalarne (771)
  • Typy wektorowe (771)
  • Typy macierzowe (772)
  • Tablice (773)
  • Struktury (774)
  • Słowo kluczowe typedef (774)
  • Modyfikatory zmiennych (774)
  • Rzutowanie typów (775)
• Słowa zastrzeżone i operatory (775)
  • Słowa kluczowe (775)
  • Operatory (775)
• Przepływ programu (777)
• Funkcje (778)
  • Funkcje użytkownika (778)
  • Funkcje wbudowane (779)

Dodatek C. Wybrane zagadnienia geometrii analitycznej (783)

• C.1. Promienie, proste i odcinki (783)
• C.2. Równoległoboki (784)
• C.3. Trójkąty (785)
• C.4. Płaszczyzny (786)
  • C.4.1. Płaszczyzny XNA Math (787)
  • C.4.2. Wzajemne położenie punktu i płaszczyzny (787)
  • C.4.3. Obliczanie płaszczyzny (788)
  • C.4.4. Normalizacja płaszczyzny (789)
  • C.4.5. Przekształcanie płaszczyzny (789)
  • C.4.6. Najbliższy punkt na płaszczyźnie względem danego punktu (789)
  • C.4.7. Przecięcie promienia i płaszczyzny (790)
  • C.4.8. Odbijanie wektorów (791)
  • C.4.9. Odbijanie punktów (791)
  • C.4.10. Macierz odbicia (792)
• C.5. Ćwiczenia (793)

Dodatek D. Rozwiązania wybranych ćwiczeń (795)

• Rozdział 1. (795)
• Rozdział 2. (798)
• Rozdział 3. (802)
• Rozdział 5. (810)
• Rozdział 8. (816)
• Rozdział 10. (818)
• Rozdział 11. (819)
• Rozdział 12. (819)
• Rozdział 14. (819)
• Rozdział 15. (820)
• Rozdział 18. (823)
• Rozdział 21. (823)
• Rozdział 24. (825)
• Dodatek C (832)

Bibliografia (837)

Skorowidz (841)