Wiesławie Sobiesiak,
Najwspanialszej Mamie na świecie!

– Karol Sobiesiak

Dziękuje Rodzicom za to, kim jestem,
Rodzinie za nieocenione wsparcie,
Przyjaciołom za to, że są zawsze blisko.

– Piotr Sydow

Projekt okładki i stron tytułowych Grzegorz Laskowski

Ilustracja na okładce Ociacia/Shutterstock

Wydawca Łukasz Łopuszański

Redaktor prowadzący Irena Puchalska

Redaktor Urszula Pawłowska

Koordynator produkcji Anna Bączkowska

Przygotowanie publikacji elektronicznej Ewa Modlińska

Skład wersji elektronicznej na zlecenie Wydawnictwa Naukowego PWN Magdalena Wojtas / 88em.eu

Książka, którą nabyłeś, jest dziełem twórcy i wydawcy. Prosimy, abyś przestrzegał praw, jakie im przysługują. Jej zawartość możesz udostępnić nieodpłatnie osobom bliskim lub osobiście znanym. Ale nie publikuj jej w internecie. Jeśli cytujesz jej fragmenty, nie zmieniaj ich treści i koniecznie zaznacz, czyje to dzieło. A kopiując jej część, rób to jedynie na użytek osobisty.

Szanujmy cudzą własność i prawo

Więcej na www.legalnakultura.pl

Polska Izba Książki

Copyright © by Wydawnictwo Naukowe PWN SA

Warszawa 2015

eBook został przygotowany na podstawie wydania papierowego z 2015 r.

(wyd. I)

Warszawa 2015

ISBN 978-83-01-18397-4

Wydawnictwo Naukowe PWN SA

02-460 Warszawa, ul. Gottlieba Daimlera 2

tel. 22 69 54 321, faks 22 69 54 288

infolinia 801 33 33 88

e-mail: pwn@pwn.com.pl

www.pwn.pl

  Spis treści

Rozdział 1. Wstęp

1.1. Do kogo jest skierowana ta książka?

1.2. Przydatne narzędzia

Rozdział 2. Zrozumieć GPU

2.1. Co to jest Shader?

2.2. Architektura GPU

2.2.1. GPU versus CPU

2.2.2. Jednostki wykonawcze GPU

2.2.3. Przełączanie kontekstu i unikanie opóźnień

2.2.4. Przetwarzanie rozgałęzień

2.2.5. Model pamięci

Rozdział 3. Potok renderujący OpenGL

3.1. Najważniejsze etapy potoku graficznego

3.1.1. Przetwarzanie geometrii

3.1.2. Rasteryzacja

3.1.3. Przetwarzanie fragmentów

3.1.4. Postprocess fragmentów

3.2. Wprowadzenie do programowalnego potoku

3.2.1. Shader wierzchołków

3.2.2. Teselacja

3.2.3. Shader geometrii

3.2.4. Shader fragmentów

3.3. Kompilacja

3.3.1. Proces kompilacji, wiązania i linkowania

3.3.2. Wielokrotne wiązanie shaderów tego samego typu

3.3.3. Rozłączne programy

3.3.4. Status kompilacji

Rozdział 4. Podstawy programowania

4.1. Język programowania shaderów GLSL

4.2. Profile

4.3. Interpretacja schematów konstrukcji programistycznych

4.4. Nazwy identyfikatorów obiektów

4.5. Preprocesor

4.5.1. Kontrola wersji shadera (#version)

4.5.2. Definiowanie symboli oraz makrodefinicji (#define, #undef)

4.5.3. Kontrola warunkowej kompilacji (#if, #ifdef, #ifndef, #elif, #else, #endif)

4.5.4. Wspomaganie warunkowej kompilacji (#error)

4.5.5. Wspomaganie diagnostyki kodu źródłowego (#line)

4.5.6. Sterowanie działaniem kompilatora (#pragma)

4.5.7. Zarządzanie zestawem rozszerzeń języka GLSL (#extension)

4.6. Typy danych

4.6.1. Bazowe typy numeryczne – skalary

4.6.2. Pochodne typy numeryczne – wektory

4.6.3. Pochodne typy numeryczne – macierze

4.6.4. Typy uchwytów

4.6.5. Typ subroutine

4.6.6. Struktury

4.6.7. Tablice

4.7. Zmienne

4.7.1. Zmienne wewnętrzne

4.7.2. Zmienne interfejsu

4.7.3. Blok interfejsu

4.7.4. Deklaracja obiektów użytkownika w modułach shadera

4.8. Zakres zmiennych

4.9. Operatory

4.10. Instrukcje kontroli przepływu

4.11. Funkcje

4.11.1. Deklaracja funkcji

4.11.2. Definicja funkcji

4.11.3. Przeładowywanie funkcji

4.11.4. Parametry funkcji i wartości zwracane

Rozdział 5. Dane

5.1. Generyczny magazyn danych (obiekt bufora)

5.1.1. Tworzenie buforów

5.1.2. Wiązanie buforów

5.1.3. Zarządzanie stanem obiektów buforowych

5.1.4. Swobodny dostęp do danych bufora

5.1.5. Kopiowanie buforów

5.1.6. Odczytywanie zawartości buforów

5.1.7. Usuwanie buforów

5.2. Zmienne oraz bloki <em>uniform</em>

5.2.1. Domyślny blok <em>uniform</em>

5.2.2. Nazwany blok <em>uniform</em>

5.3. Zmienne oraz bloki <em>buffer</em>

5.3.1. Blok buforowy

5.3.2. Kontrola dostępu do pamięci

5.3.3. Operacje atomowe na zmiennych buforowych

5.3.4. Organizacja danych w bloku

5.3.5. Własności stanu zmiennych oraz bloków buforowych

5.3.6. Pozyskiwanie lokacji zmiennych buforowych oraz aktualizacja danych

5.3.7. Wiązanie bloku buforowego

5.4. Sformatowany magazyn danych (obiekt tekstury)

5.4.1. Reprezentacja tekstur w OpenGL

5.4.2. Struktura magazynu danych

5.4.3. Tworzenie oraz usuwanie tekstur

5.4.4. Wiązanie tekstur

5.4.5. Alokacja oraz aktualizacja magazynu danych dla tekstur

5.4.6. Tekstura buforowa

5.5. Tekstury w shaderach

5.5.1. Mechanizm teksturowania

5.5.2. Zmienne <em>sampler</em>

5.5.3. Podstawowa metoda dostępu do złożonych typów tekstur

5.5.4. Funkcje wbudowane odpytywania tekstur

5.5.5. Zaawansowane funkcje wbudowane dostępu do danych tekstury

5.6. Obrazy w shaderach

5.6.1. Zmienne <em>image</em>

5.6.2. Podstawowe operacje na obrazie

5.6.3. Operacje atomowe na obrazie

5.7. Liczniki atomowe

5.7.1. Tworzenie liczników

5.7.2. Własności stanu liczników atomowych

5.7.3. Wiązanie buforów z licznikami

5.7.4. Operacje atomowe

5.8. Dodatkowe metody synchronizacji w dostępie do danych

5.8.1. Synchronizacja dostępu w shaderach

5.8.2. Synchronizacja dostępu w API

Rozdział 6. Programowanie potoku renderującego

6.1. Przykładowy program zawierający wszystkie podstawowe shadery

6.2. Ogólny obraz komunikacji międzyetapowej

6.3. Przekazywanie danych w potoku

6.3.1. Atrybuty shadera wierzchołków

6.3.2. Interfejsy in/out między etapami

6.3.3. Lokacje przy przekazywaniu danych między shaderami

6.3.4. Pełne a częściowe dopasowanie

6.3.5. Komponenty w lokacjach

6.3.6. Sposoby interpolacji przy przekazywaniu danych do shadera fragmentów

6.3.7. Wbudowany blok gl_PerVertex

6.4. Przebieg i własności teselacji

6.4.1. Deklaracja płatu i jego przekształcenie na właściwy prymityw poddawany teselacji

6.4.2. Stopnie teselacji

6.4.3. Opcje rozstawu

6.4.4. Teselacja trójkąta

6.4.5. Teselacja czworokąta

6.4.6. Teselacja izolinii

6.5. Programowanie shadera wierzchołków

6.5.1. Optymalizacja liczby wywołań

6.5.2. Zmienne wbudowane

6.6. Programowanie shadera kontroli teselacji

6.6.1. Przepływ danych i deklaracja liczby wywołań

6.6.2. Współbieżny dostęp do danych wyjściowych

6.6.3. Zmienne wbudowane

6.7. Programowanie shadera ewaluacji teselacji

6.7.1. Przepływ danych

6.7.2. Konfiguracja prymitywów za pomocą wejściowego kwalifikatora layout

6.7.3. Zmienne wbudowane

6.8. Programowanie shadera geometrii

6.8.1. Interfejs wejścia i deklaracja liczby wywołań shadera

6.8.2. Interfejs wyjścia – deklaracja prymitywu i emisja wierzchołków

6.8.3. Dedykowane prymitywy przylegające

6.8.4. Zmienne wbudowane

6.9. Programowanie shadera fragmentów

6.9.1. Renderowanie do bufora ramki

6.9.2. Odrzucanie fragmentów

6.9.3. Modyfikacja współrzędnych fragmentów

6.9.4. Wczesny test fragmentów i modyfikacja buforu głębokości

6.9.5. Funkcje wbudowane i wywołania wspomagające

6.9.6. Zmienne wbudowane

Rozdział 7. Mechanizmy uzupełniające

7.1. Renderowanie do tekstur

7.1.1. Przygotowanie aplikacji

7.1.2. Renderowanie do wielu tekstur jako osobnych załączników koloru

7.1.3. Renderowanie do tekstur złożonych z wykorzystaniem shadera geometrii

7.2. Mechanizm Shader Subroutine

7.2.1. Funkcje wywoływane statycznie i dynamicznie

7.2.2. Elementy składniowe mechanizmu

7.2.3. Przykładowa implementacja

7.2.4. Konfigurowanie powiązań zmiennych z funkcjami<em> subroutine</em>

Rozdział 8. Shader obliczeniowy

8.1. Wprowadzenie

8.1.1. Kompilacja i użycie shadera obliczeniowego

8.2. Wywołania shadera obliczeniowego i grupy wykonawcze

8.2.1. Identyfikacja wywołania

8.2.2. Ograniczenia liczby wywołań

8.3. Charakterystyka przetwarzania

8.3.1. Przetwarzanie lokalnych grup roboczych

8.3.2. Pamięć współdzielona – kwalifikator shared

8.3.3. Synchronizacja

Przypisy

Dodatki

Dodatek A

Dodatek B

Dodatek C

Dodatek D

Dodatek E

Dodatek F

Słownik pojęć

Bibliografia

Okładka

Strona tytułowa

Dedykacja

Strona redakcyjna

Spis treści

Rozdział 1. Wstęp

1.1. Do kogo jest skierowana ta książka?

1.2. Przydatne narzędzia

1 Wstęp

Czasy, w których programy były pisane najczęściej pod kątem wykorzystania zasobów obliczeniowych centralnego procesora CPU (ang. central processing unit), właśnie się skończyły. Dzisiaj nie tylko komputery osobiste klasy PC lub Mac, lecz także tablety i smartfony oprócz układu CPU mają potężną jednostkę obliczeniową GPU (ang. graphics processing unit). Coraz powszechniejsza staje się wiedza o tym, jak wykorzystać moc drzemiącą w tych układach, tym bardziej, że żyjemy w świecie, w którym jest ważna nie tylko sama informacja i jej przetwarzanie, lecz także jej wizualizacja. A w tej dziedzinie akurat GPU sprawdza się nad wyraz dobrze, zwłaszcza gdy problem dotyczy wizualizacji 3D.

Jeszcze na początku XXI wieku układy te były stosunkowo wolne i ograniczone programistycznie. Renderowanie fotorealistycznych scen w czasie rzeczywistym znajdowało się jedynie w sferze głębokich marzeń programistów oraz artystów tworzących wizualizacje. W grach komputerowych, produkowanych w tamtym okresie rozwoju technologii 3D, trudno było uzyskać bardziej zaawansowane efekty wizualne, nawet oświetlenie i cienie były najczęściej statyczne, realizowane przy użyciu informacji wypalanych bezpośrednio na teksturach. Możliwości udostępniane przez API bibliotek graficznych i architekturę układów GPU z tamtego okresu były mocno ograniczone i dało się to odczuć szczególnie w branży tworzenia gier wideo. Na szczęście postęp technologiczny rozwiązał z czasem kwestię wydajności, a programistom dał większą swobodę działania. Zaczęły pojawiać się shadery, dzięki którym programiści mogli przejść z mocno ograniczonego konfigurowania pracy GPU za pośrednictwem API na bardziej bezpośredni kontakt z układem, programując cały dostępny potok renderujący według uznania. Liczba dostępnych shaderów stopniowo rosła. Doczekaliśmy się też rewolucji, jaką było zastosowanie układu graficznego do GPGPU (ang. General purpose computing on GPU), które zostało udostępnione w postaci CUDA przez firmę Nvidia czy OpenCL przez firmę Apple (dzisiaj opiekę nad rozwojem OpenCL, podobnie jak OpenGL, sprawuje grupa Khronos). Na taką otwartość programistyczną akceleratorów graficznych, zbliżoną do CPU, czekało wiele osób. W końcu zawitała ona również do OpenGL pod postacią shadera obliczeniowego (ang. compute shader). Nie dostarcza on może takich możliwości, jakie mają CUDA czy OpenCL, jednak pozwala na prostą integrację dodatkowych możliwości obliczeniowych z istniejącymi już aplikacjami wykorzystującymi API OpenGL. Shadery są dzisiaj potężnym narzędziem dla kreatywnych programistów, potrafiących za pomocą odpowiednich technik tworzyć podstawy do wspaniałych, często już nawet fotorealistycznych wizualizacji.

Postęp związany z rozwojem procesorów graficznych następuje nie tylko na polu komputerów osobistych. Jak już wspomnieliśmy na początku, również tablety i smartfony mają procesory, które mogą renderować zaawansowane graficznie sceny. Podstawową różnicą między tymi urządzeniami a komputerami osobistymi jest architektura GPU i API, które jest do tej architektury dostosowane. W domowych komputerach PC korzysta się z pełnej wersji OpenGL, natomiast urządzenia mobilne mają uszczuploną jego wersję o nazwie OpenGL ES. Shadery niestety są również przez to ograniczone (w książce opisujemy desktopową wersję GLSL). Powoli pojawiają się jednak zmiany, które mają na celu ujednolicenie obu platform. Nvidia w 2014 roku wypuściła na rynek mobilny układ GPU o nazwie Tegra K1 do zastosowań w tabletach, o takich samych możliwościach, jak te spotykane w domowych komputerach, włączając w to pełną wersję OpenGL wraz ze wszystkimi shaderami. Jest zatem tylko kwestią czasu, gdy również smartfony znajdą się w tym samym gronie.

Cieszymy się, że sięgnąłeś po tę książkę drogi czytelniku i mamy nadzieję, że będziemy w stanie zaspokoić twoją chęć poznania współczesnych technik korzystania z możliwości procesorów graficznych i samego języka GLSL.

1.1. Do kogo jest skierowana ta książka?

Książkę tę pisaliśmy z myślą o osobach zainteresowanych współczesnym podejściem do programowania GPU z zastosowaniem shaderów. Kluczowe jest tu słowo „współczesnym”, ze względu na zastosowanie najnowszej wersji języka dostępnej w czasie pisania tej książki, a mianowicie GLSL 4.50. Zależało nam na przedstawieniu aktualnych możliwości i trendów w programowaniu procesora graficznego. Nie jest to jednak lektura, która opisuje działanie samej biblioteki OpenGL. Zapoznanie się chociażby z podstawowymi zagadnieniami związanymi z programowaniem za pomocą tego API jest niezbędne, aby móc posłużyć się treścią zawartą w książce. OpenGL jest jednak niezbędny dla GLSL, dlatego w wielu przypadkach podczas opisu pewnych funkcjonalności i tam, gdzie było to konieczne, staraliśmy się nakierować czytelnika na to, w jaki sposób przygotować aplikację i jakie funkcje OpenGL należy zastosować. Większy nacisk położyliśmy jednak na programowanie samych shaderów.

Treść zawarta w książce jest dedykowana osobom z dobrze ugruntowaną wiedzą programistyczną oraz mających choćby podstawową wiedzę z zakresu grafiki trójwymiarowej i algebry liniowej. W kwestii programistycznej występują znaczne różnice między programami pisanymi pod CPU, a tymi pisanymi pod GPU. Dlatego na początku książki staramy się wprowadzić czytelnika w być może nowe dla niego środowisko, opisując pokrótce architektoniczne różnice obu platform, które są istotne z punktu widzenia programisty. Samo programowanie shaderów zostało opisane od podstaw, z tłumaczeniem całej składni języka. Z tego względu książkę tę możemy polecić wszystkim osobom chcącym rozpocząć swoją przygodę z językiem GLSL.

1.2. Przydatne narzędzia

Istnieje wiele narzędzi ułatwiających pracę programistom grafiki 3D, czy bardziej dogłębnie GPU. W tym podrozdziale wymieniamy część z nich, te, które mogą się przydać podczas pracy nad własną aplikacją, testowaniem czy też mogą po prostu posłużyć do zapoznania się ze współcześnie stosowanymi rozwiązaniami w tego typu aplikacjach.

QuickShader (Windows) – Aplikacja ta pozwala na szybkie pisanie i testowanie shaderów w środowisku OpenGL/GLSL 4. Udostępnia możliwość programowania pięciu podstawowych shaderów potoku (z wyłączeniem shadera obliczeniowego). Aplikacja zawiera już na wstępie kilka ciekawych efektów, na których można się opierać, pisząc własne shadery.

ShaderToy (strona internetowa) – Bardzo popularna platforma do testowania efektów, zbudowana na podstawie WebGL. Umożliwia programowanie jedynie shadera fragmentów, jednak baza efektów, jaką zbudowano przez lata, jest imponująca. Adres strony internetowej to www.shadertoy.com.

GPU PerfStudio (Windows, Linux) – Narzędzie firmy AMD do profilowania i debugowania aplikacji napisanych z wykorzystaniem API OpenGL lub DirectX. Ma wiele możliwości, takich jak: analiza shaderów, wyrenderowanych klatek, czasu renderowania i wiele innych. Jest to zaawansowane narzędzie służące do kompleksowej analizy aplikacji.

Nvidia Nsight (Windows, Linux, Mac OS) – Narzędzie firmy Nvidia do profilowania i debugowania aplikacji graficznych, które integruje się z IDE programistycznym, jakim może być Visual Studio lub Eclypse. Jest to zaawansowane narzędzie, które ma szerokie możliwości analizowania działania aplikacji graficznych, takie jak: analiza shaderów, przebiegu renderowania klatek, czasu renderowania i wiele innych.