Cg to kompletne środowisko programistyczne do szybkiego tworzenia efektów specjalnych i grafiki o kinowej jakości w czasie rzeczywistym dla wielu platform. Ponieważ język jest niezależny od sprzętu, programiści mogą pisać kod dla interfejsów OpenGL, DirectX oraz systemów Windows, Linux, Mac OS X, a także platform konsolowych, (Xbox) bez potrzeby korzystania z języka asemblerowego. Język Cg powstał w firmie NVIDIA Corporation przy bliskiej współpracy z firmą Microsoft® Corporation i jest kompatybilny z OpenGL API oraz językiem HLSL dla biblioteki DirectX 9.

Książka jest podręcznikiem przeznaczonym dla średnio zaawansowanych programistów. Opisuje ona zarówno sam język programowania Cg, jak i metody wielu składników nowoczesnych aplikacji bazujących na grafice trójwymiarowej.

Prezentowane w książce zagadnienia to m.in.:

• Historia języka Cg
• Środowisko programistyczne Cg
• Składnia Cg i słowa kluczowe
• Przekształcenia w przestrzeni trójwymiarowej
• Oświetlenie bazujące na wierzchołkach i pikselach
• Interpolacja ujęć kluczowych i system kości
• Mapowanie środowiska
• Mapowanie nierówności
• Mgła, światła reflektorowe, cienie
• Zwiększanie wydajności

"Książka ważna i na czasie: tworzenie tekstur proceduralnych na poziomie pikseli -- animowanych chmur, ognia, wody i wielu innych sztuczek -- nareszcie z ekranów kin przechodzi pod strzechy. Cała moc jest dostępna dzięki językowi przypominającemu język C, co otwiera nowy rozdział w grafice komputerowej.

Osoby które kupowały "Język Cg. Programowanie grafiki w czasie rzeczywistym", wybierały także:

• Superinteligencja. Scenariusze, strategie, zagro 66,67 zł, (14,00 zł -79%)
• Poradnik design thinking - czyli jak wykorzysta 48,28 zł, (14,00 zł -71%)
• Kosymulacja. Elastyczne projektowanie i symulacja wielodomenowa 38,39 zł, (11,90 zł -69%)
• F# 4.0 dla zaawansowanych. Wydanie IV 96,45 zł, (29,90 zł -69%)
• Systemy reaktywne. Wzorce projektowe i ich stosowanie 65,31 zł, (20,90 zł -68%)

Spis treści

Język Cg. Programowanie grafiki w czasie rzeczywistym -- spis treści

Przedmowa (13)

Wstęp (15)

Rozdział 1. Wprowadzenie (21)

• 1.1. Czym jest Cg? (21)
  • 1.1.1. Języki dla programowalnego sprzętu graficznego (22)
  • 1.1.2. Model przepływu danych w Cg (22)
  • 1.1.3. Specjalizacja a generalizacja procesorów graficznych (23)
  • 1.1.4. Wydajność języka Cg (24)
  • 1.1.5. Współdziałanie z konwencjonalnymi językami (24)
  • 1.1.6. Inne aspekty języka Cg (26)
  • 1.1.7. Ograniczone środowisko wykonywania programów Cg (27)
• 1.2. Wierzchołki, fragmenty i potok grafiki (28)
  • 1.2.1. Ewolucja sprzętu graficznego (28)
  • 1.2.2. Cztery generacje sprzętu graficznego (29)
  • 1.2.3. Sprzętowy potok graficzny (33)
  • 1.2.4. Programowalny potok graficzny (37)
  • 1.2.5. Język Cg zapewnia możliwość programowania jednostek wierzchołków i fragmentów (40)
• 1.3. Historia powstania Cg (40)
  • 1.3.1. Współpraca firm NVIDIA i Microsoft w celu określenia języków Cg i HLSL (42)
  • 1.3.2. Nieinteraktywne języki cieniowania (42)
  • 1.3.3. Interfejsy programistyczne w grafice trójwymiarowej (45)
• 1.4. Środowisko Cg (45)
  • 1.4.1. Standardowe interfejsy programistyczne 3D: OpenGL i Direct3D (45)
  • 1.4.2. Kompilator i biblioteka wykonywania Cg (47)
  • 1.4.3. Narzędzia CgFX i format pliku (49)
• 1.5. Ćwiczenia (53)

Rozdział 2. Najprostsze programy (55)

• 2.1. Prosty program wierzchołków (55)
  • 2.1.1. Struktura wyjścia (56)
  • 2.1.2. Identyfikatory (57)
  • 2.1.3. Elementy struktur (58)
  • 2.1.4. Wektory (58)
  • 2.1.5. Macierze (58)
  • 2.1.6. Semantyka (59)
  • 2.1.7. Funkcje (60)
  • 2.1.8. Różnice w semantyce wejścia i wyjścia (61)
  • 2.1.9. Ciało funkcji (62)
• 2.2. Kompilacja przykładu (64)
  • 2.2.1. Profile programu wierzchołków (64)
  • 2.2.2. Klasy błędów kompilacji programów Cg (66)
  • 2.2.3. Błędy wynikające ze złego profilu (66)
  • 2.2.4. Norma - kilka funkcji wejścia (68)
  • 2.2.5. Pobieranie i konfiguracja programów wierzchołków i fragmentów (68)
• 2.3. Prosty program fragmentów (70)
  • 2.3.1. Profile dla programów fragmentów (71)
• 2.4. Rendering przykładowych programów wierzchołków i fragmentów (72)
  • 2.4.1. Rendering trójkąta w OpenGL (73)
  • 2.4.2. Rendering trójkąta w Direct3D (74)
  • 2.4.3. Uzyskanie tych samych wyników (74)
• 2.5. Ćwiczenia (76)

Rozdział 3. Parametry, tekstury i wyrażenia (77)

• 3.1. Parametry (77)
  • 3.1.1. Parametry jednolite (77)
  • 3.1.2. Kwalifikator typu const (80)
  • 3.1.3. Różnorodność parametrów (80)
• 3.2. Próbkowanie tekstur (82)
  • 3.2.1. Obiekty próbek (82)
  • 3.2.2. Próbki tekstur (83)
  • 3.2.3. Wysyłanie współrzędnych tekstury w trakcie próbkowania tekstury (84)
• 3.3. Wyrażenia matematyczne (85)
  • 3.3.1. Operatory (85)
  • 3.3.2. Typy danych uzależnione od profilu (86)
  • 3.3.3. Funkcje wbudowane w standardową bibliotekę Cg (90)
  • 3.3.4. Skręcanie w dwuwymiarze (93)
  • 3.3.5. Efekt podwójnego widzenia (96)
• 3.4. Ćwiczenia (100)

Rozdział 4. Przekształcenia (101)

• 4.1. Układy współrzędnych (101)
  • 4.1.1. Przestrzeń obiektu (102)
  • 4.1.2. Współrzędne homogeniczne (103)
  • 4.1.3. Przestrzeń świata (103)
  • 4.1.4. Przekształcenie modelu (104)
  • 4.1.5. Przestrzeń oka (105)
  • 4.1.6. Przekształcenie widoku (105)
  • 4.1.7. Przestrzeń przycięcia (106)
  • 4.1.8. Przekształcenie rzutowania (106)
  • 4.1.9. Znormalizowane współrzędne urządzenia (107)
  • 4.1.10. Współrzędne okna (108)
• 4.2. Zastosowanie teorii (108)
• 4.3. Ćwiczenia (109)

Rozdział 5. Oświetlenie (111)

• 5.1. Oświetlenie i związane z nim modele (111)
• 5.2. Implementacja podstawowego modelu oświetlenia opartego na wierzchołkach (113)
  • 5.2.1. Podstawowy model oświetlenia (113)
  • 5.2.2. Program wierzchołków dla prostego oświetlenia opartego na wierzchołkach (119)
  • 5.2.3. Program fragmentów dla modelu oświetlenia wykorzystującego wierzchołki (128)
  • 5.2.4. Efekt modelu oświetlenia opartego na wierzchołkach (128)
• 5.3. Model oświetlenia oparty na fragmentach (129)
  • 5.3.1. Implementacja modelu oświetlenia opartego na fragmentach (130)
  • 5.3.2. Program wierzchołków dla modelu oświetlenia opartego na fragmentach (131)
  • 5.3.3. Program fragmentów dla modelu oświetlenia opartego na fragmentach (131)
• 5.4. Tworzenie funkcji modelu oświetlenia (133)
  • 5.4.1. Deklarowanie funkcji (133)
  • 5.4.2. Funkcja oświetlenia (134)
  • 5.4.3. Struktury (135)
  • 5.4.4. Tablice (136)
  • 5.4.5. Sterowanie wykonywaniem programu (137)
  • 5.4.6. Obliczenie modelu oświetlenia rozproszenia i rozbłysku (138)
• 5.5. Rozszerzenie modelu podstawowego (138)
  • 5.5.1. Zanik światła wraz z odległością (139)
  • 5.5.2. Dodanie efektu reflektora (140)
  • 5.5.3. Światła kierunkowe (145)
• 5.6. Ćwiczenia (145)

Rozdział 6. Animacja (147)

• 6.1. Ruch w czasie (147)
• 6.2. Pulsujący obiekt (148)
  • 6.2.1. Program wierzchołków (149)
  • 6.2.2. Obliczanie przemieszczenia (150)
• 6.3. Systemy cząsteczek (152)
  • 6.3.1. Warunki początkowe (153)
  • 6.3.2. Wektoryzacja obliczeń (153)
  • 6.3.3. Parametry systemu cząsteczek (154)
  • 6.3.4. Program wierzchołków (154)
  • 6.3.5. Ubieramy system cząsteczek (156)
• 6.4. Interpolacja ujęć kluczowych (157)
  • 6.4.1. Teoria ujęć kluczowych (157)
  • 6.4.2. Rodzaje interpolacji (160)
  • 6.4.3. Prosta interpolacja ujęć kluczowych (160)
  • 6.4.4. Interpolacja ujęć kluczowych z oświetleniem (162)
• 6.5. System skóry dla wierzchołków (163)
  • 6.5.1. Teoria systemu skóry dla wierzchołków (163)
  • 6.5.2. System skóry w programie wierzchołków (166)
• 6.6. Ćwiczenia (167)

Rozdział 7. Mapowanie środowiska (169)

• 7.1. Mapowanie środowiska (169)
  • 7.1.1. Tekstury map sześciennych (170)
  • 7.1.2. Generowanie map sześciennych (171)
  • 7.1.3. Koncepcja mapowania środowiska (171)
  • 7.1.4. Obliczenie wektorów odbicia (172)
  • 7.1.5. Założenia mapowania środowiska (173)
• 7.2. Mapowanie odbić (174)
  • 7.2.1. Parametry określane przez aplikację (175)
  • 7.2.2. Program wierzchołków (175)
  • 7.2.3. Program fragmentów (179)
  • 7.2.4. Mapy sterujące (180)
  • 7.2.5. Program wierzchołków a program fragmentów (180)
• 7.3. Mapowanie załamań (181)
  • 7.3.1. Zjawisko załamania światła (182)
  • 7.3.2. Program wierzchołków (184)
  • 7.3.3. Program fragmentów (186)
• 7.4. Efekt Fresnela i rozszczepienie chromatyczne (187)
  • 7.4.1. Efekt Fresnela (187)
  • 7.4.2. Rozszczepienie chromatyczne (188)
  • 7.4.3. Parametry zależne od aplikacji (189)
  • 7.4.4. Program wierzchołków (190)
  • 7.4.5. Program fragmentów (191)
• 7.5. Ćwiczenia (193)

Rozdział 8. Mapowanie nierówności (195)

• 8.1. Mapowanie nierówności ceglanej ściany (195)
  • 8.1.1. Mapa normalnych ceglanej ściany (196)
  • 8.1.2. Przechowywanie map nierówności jako map normalnych (197)
  • 8.1.3. Proste mapowanie nierówności dla ceglanego muru (200)
  • 8.1.4. Mapowanie nierówności dla rozbłysku (203)
  • 8.1.5. Mapowanie nierówności na innej geometrii (206)
• 8.2. Mapowanie nierówności ceglanej podłogi (208)
  • 8.2.1. Program wierzchołków dla renderingu obrazu ceglanej podłogi (210)
• 8.3. Mapowanie nierówności dla torusa (213)
  • 8.3.1. Matematyka dotycząca torusa (213)
  • 8.3.2. Program wierzchołków dla torusa z mapowaniem nierówności (216)
• 8.4. Mapowanie nierówności dla teksturowanych siatek wielokątnych (218)
  • 8.4.1. Algorytm dla pojedynczego trójkąta (218)
  • 8.4.2. Możliwe problemy (220)
  • 8.4.3. Uogólnienie do siatek z wielokątów (222)
• 8.5. Połączenie mapowania nierówności z innymi efektami (223)
  • 8.5.1. Standardowe tekstury (223)
  • 8.5.2. Mapy połysku (223)
  • 8.5.3. Rzucanie cieni na samego siebie (224)
• 8.6. Ćwiczenia (225)

Rozdział 9. Zagadnienia zaawansowane (227)

• 9.1. Mgła (227)
  • 9.1.1. Mgła jednorodna (228)
  • 9.1.2. Atrybuty mgły (229)
  • 9.1.3. Matematyka mgły (229)
  • 9.1.4. Dostosowanie równań do zachowania zgodnego z intuicją (232)
  • 9.1.5. Tworzenie jednorodnej mgły w programie Cg (233)
• 9.2. Rendering nierealistyczny (235)
  • 9.2.1. Cieniowanie jak w kreskówkach (235)
  • 9.2.2. Implementacja cieniowania kreskówkowego (236)
  • 9.2.3. Łączymy wszystko razem (239)
  • 9.2.4. Problemy związane z tym rozwiązaniem (241)
• 9.3. Rzutowanie tekstur (241)
  • 9.3.1. W jaki sposób działa rzutowanie tekstur? (242)
  • 9.3.2. Implementacja rzutowania tekstury (244)
  • 9.3.3. Kod rzutowania tekstury (245)
• 9.4. Mapowanie cieni (248)
• 9.5. Łączenie (250)
  • 9.5.1. Mapowanie pikseli z wejścia na wyjście (251)
  • 9.5.2. Podstawowe operacje dotyczące łączenia (252)
• 9.6. Ćwiczenia (254)

Rozdział 10. Profile i wydajność (257)

• 10.1. Opis profili (257)
  • 10.1.1. Profil shadera wierzchołków dla DirectX 8 (257)
  • 10.1.2. Podstawowy profil programu wierzchołków dla kart NVIDIA i OpenGL (258)
  • 10.1.3. Profil programu wierzchołków ARB dla OpenGL (259)
  • 10.1.4. Profil shadera wierzchołków dla DirectX 9 (259)
  • 10.1.5. Zaawansowany profil programu wierzchołków dla kart NVIDIA i OpenGL (259)
  • 10.1.6. Profile shadera pikseli dla DirectX 8 (260)
  • 10.1.7. Podstawowy profil programu fragmentów NVIDIA dla OpenGL (261)
  • 10.1.8. Profile shadera pikseli dla DirectX9 (261)
  • 10.1.9. Profil programu fragmentów ARB dla OpenGL (262)
  • 10.1.10. Zaawansowany profil programu fragmentów NVIDIA dla OpenGL (262)
• 10.2. Wydajność (263)
  • 10.2.1. Korzystanie ze standardowej biblioteki Cg (263)
  • 10.2.2. Zalety parametrów jednorodnych (264)
  • 10.2.3. Program fragmentów a program wierzchołków (264)
  • 10.2.4. Typy danych i ich wpływ na wydajność (265)
  • 10.2.5. Wykorzystanie zalet wektoryzacji (265)
  • 10.2.6. Kodowanie funkcji w teksturach (266)
  • 10.2.7. Intensywnie wykorzystanie przemieszania i negacji (267)
  • 10.2.8. Cieniujemy tylko te fragmenty, które musimy (267)
  • 10.2.9. Krótszy kod asemblerowy nie zawsze jest szybszy (268)
• 10.3. Ćwiczenia (268)

Dodatek A Narzędzia Cg (269)

• A.1. Pobieranie przykładów prezentowanych w niniejszej książce (269)
• A.2. Pobieranie narzędzia Cg Toolkit (269)

Dodatek B Biblioteka wykonywania Cg (271)

• B.1. Czym jest biblioteka wykonywania Cg? (271)
• B.2. Dlaczego warto używać biblioteki wykonywania Cg? (271)
  • B.2.1. Dostosowanie do nowszych procesorów graficznych (271)
  • B.2.2. Brak problemów z zależnościami (272)
  • B.2.3. Zarządzanie parametrami wejściowymi (272)
• B.3. W jaki sposób działa biblioteka wykonywania Cg? (273)
  • B.3.1. Pliki nagłówkowe (274)
  • B.3.2. Tworzenie kontekstu (274)
  • B.3.3. Kompilacja programu (274)
  • B.3.4. Wczytanie programu (275)
  • B.3.5. Modyfikacja parametrów programu (276)
  • B.3.6. Wykonanie programu (276)
  • B.3.7. Zwalnianie zasobów (277)
  • B.3.8. Obsługa błędów (277)
• B.4. Dodatkowe informacje (278)

Dodatek C Format pliku CgFX (279)

• C.1. Czym jest CgFX? (279)
• C.2. Opis formatu (280)
  • C.2.1. Techniki (280)
  • C.2.2. Przebiegi (281)
  • C.2.3. Stany renderingu (281)
  • C.2.4. Zmienne i semantyka (282)
  • C.2.5. Przypisy (282)
  • C.2.6. Przykładowy plik CgFX (283)
• C.3. Moduły Cg obsługujące format CgFX (284)
• C.4. Dodatkowe informacje o CgFX (285)

Dodatek D Słowa kluczowe języka Cg (287)

• D.1. Lista słów kluczowych języka Cg (287)

Dodatek E Funkcje standardowej biblioteki Cg (289)

• E.1. Funkcje matematyczne (290)
• E.2. Funkcje geometryczne (293)
• E.3. Funkcje mapowania tekstur (294)
• E.4. Funkcje pochodnych (295)
• E.5. Funkcja testowania (296)

Skorowidz 297