Język Cg. Programowanie grafiki w czasie rzeczywistym

Język-Cg-Programowanie-grafiki-w-czasie-rzeczywistym.jpg,     Randima-Fernando-Mark-J-Kilgard.jpg, Arik-pl-Księgarnia-Akademicka.jpg
  • promocja
Dostępność: średnia ilość
Wysyłka w: 48 godzin
Dostawa: Cena nie zawiera ewentualnych kosztów płatności sprawdź formy dostawy
Cena: 95,00 zł
zawiera 5.00% VAT, bez kosztów dostawy

Cena regularna: 109,00 zł

95.00
Najniższa cena od wprowadzenia towaru: 100,00 zł
ilość szt.
Zyskujesz 9 pkt [?]

towar niedostępny

dodaj do przechowalni
Pin It

Opis

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.

Ken Perlin, Uniwersytet w Nowym Jorku

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

Koszty dostawy Cena nie zawiera ewentualnych kosztów płatności

Kraj wysyłki:

Opinie o produkcie (0)

do góry
Sklep jest w trybie podglądu
Pokaż pełną wersję strony
Sklep internetowy Shoper.pl