Katalog książek

Wydawnictwo Helion

Helion SA
ul. Kościuszki 1c
44-100 Gliwice
tel. (32) 230-98-63




© Helion 1991-2016

Lauret zaufanych opinii
Język Cg. Programowanie grafiki ...

Język Cg. Programowanie grafiki w czasie rzeczywistym

Autorzy: ,

Język Cg. Programowanie grafiki w czasie rzeczywistym
Ocena:
   5.5/6  Opinie  (5)
Stron: 312
Ksiazka drukowana Druk (oprawa: miękka)
Wydawca: Helion
Cena:
89,00 zł

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

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
Najczęściej kupowane razem:
Język Cg. Programowanie grafiki w czasie rzeczywistym plus Getting Things Programmed. Droga do efektywności plus Język Go. Poznaj i programuj
Cena zestawu: 155,46 zł 182,90 zł
Oszczędzasz: 27,44 zł (15%)
Dodaj do koszyka
zestaw0 Język Cg. Programowanie grafiki w czasie rzeczywistym
Osoby, które kupowały książkę, często kupowały też:
6
(3)
5
(2)
4
(0)
3
(0)
2
(0)
1
(0)

Liczba ocen: 5

Średnia ocena
czytelników

  


okladka
  Ocena : 6 

Bardzo fachowa, problemy omawiane szczegółowo, proste i czytelne przykłady.
  Ocena : 6 

Powiem po prostu tyle, ta ksiązka nauczy programowania ultra realistycznej grafiki. Jest w niej wszystko wyjaśnione, naprawde można się z niej nauczyć.
  Ocena : 6 

Jedna z najlepszych książek z wydawnictwa Helion, sama książka trafia w samo sedno, wszystko opisane tak jak należy, przejrzyście i czytelnie! Gorąco polecam!
  Ocena : 5 

  Ocena : 5 

Krótkie, proste i konkretne przykłady z dokładnym opisem - czyli dokładnie tak jak powinno być. Jedyne czego w niej mi brakuje to szerszy opis funkcji samej biblioteki wykonawczej Cg i przykładowych kodów wykorzystania tejże biblioteki w faktycznych aplikacjach opengl i direct3d, krotko mówiąc: dodatek B jest za krotki :)