bartosz bazyluk oświetleniebazyluk.net/dydaktyka/gry_2018/04_geometria.pdf · geometria shading...
TRANSCRIPT
Bartosz Bazyluk
OświetlenieZaawansowane techniki oświetlenia, c.d.
Gry komputerowe, Informatyka S1, II Rok
http://bazyluk.net/dydaktyka
20 kwietnia 2018 r. Bartosz Bazyluk 2
Image Based Lighting (IBL)
Źródło obrazu:Panocapture.com, Automotive Pack
20 kwietnia 2018 r. Bartosz Bazyluk 3
Image Based Lighting (IBL)
Źródło obrazu:Panocapture.com, Automotive Pack
20 kwietnia 2018 r. Bartosz Bazyluk 4
Image Based Lighting (IBL)
● Technika oświetlenia wykorzystująca mapę środowiska rzutowaną na powierzchnię oświetlanego obiektu
● Najczęściej jest to omnikierunkowe zdjęcie, zwykle HDR
Źródła obrazów:Panocapture.com, Automotive Pack
Springer, Davide Scaramuzza.
Pozyskanie mapy środowiska wymaga ultraszerokokątnego
obiektywu lub specjalnego rodzaju kamery.
20 kwietnia 2018 r. Bartosz Bazyluk 5
Image Based Lighting (IBL)
● Technika oświetlenia wykorzystująca mapę środowiska rzutowaną na powierzchnię oświetlanego obiektu
● Najczęściej jest to omnikierunkowe zdjęcie, zwykle HDR
Źródło obrazów:http://www.hdrlabs.com/sibl
20 kwietnia 2018 r. Bartosz Bazyluk 6
Mapowanie środowiska
● Technika IBL wywodzi się z mapowania środowiska, które jest techniką rzutowania otoczenia obiektu pod postacią tekstury na jego powierzchnię
● Mapowanie sferyczne (ang. sphere mapping)
● Mapowanie sześcienne (ang. cube mapping)
Źródło obrazów:Wikipedia
http://escience.anu.edu.au/lecture/cg
20 kwietnia 2018 r. Bartosz Bazyluk 7
Mapowanie środowiska
Źródło obrazu:Gran Turismo
Sony Computer Entertainment
20 kwietnia 2018 r. Bartosz Bazyluk 8
Ambient Occlusion ● Kolejna, tym razem dokładniejsza niż phongowski komponent ambient, aproksymacja oświetlenia niebezpośredniego
● Estymacja tego, jak bardzo dane miejsce narażone jest na działanie oświetlenia pochodzącego ze środowiska (ang. ambient light)
● Rezultat może np. wpłynąć na wartość komponentu ambient w modelu Phonga
Źródło obrazu:http://ucbugg.github.io/learn.ucbugg
Dla każdego punktu obierana jest półsfera. W jej obrębie
wysyłane są promienie.
To, ile z nich i w jakiej odległości trafi w inne obiekty, sugeruje ile
światła ze środowiska może dotrzeć do tego punktu.
20 kwietnia 2018 r. Bartosz Bazyluk 9
Ambient Occlusion ● Technika ta nie bierze pod uwagę źródeł światła!● Uwzględnia jedynie geometrię obiektów sceny
i ich względne położenie oraz odległości● Jest to technika nastawiona na rednerowanie offline
● Bazuje na koncepcji próbkowania / śledzenia promieni, jest więc bardzo kosztowna
● Im mniej próbek, tym większe zaszumienie
Źródło obrazów:Nikki Ferchland, http://animationdynamics.com/
https://realtimeillumination.wordpress.com/
20 kwietnia 2018 r. Bartosz Bazyluk 10
Ambient Occlusion
Źródło obrazów:Andrew Kramer
20 kwietnia 2018 r. Bartosz Bazyluk 11
Ambient Occlusion ● Screen Space Ambient Occlusion (SSAO)● Operuje nie na geometrii, ale na zawartości bufora klatki
– dużo szybsze!
● Porównuje względne odległości blisko oddalonych od siebie pikseli – korzysta z bufora Z
● Powoduje artefakty polegające na zmiennym oświetleniu obiektów zależnie od miejsca i kierunku,z którego je oglądamy
Źródła obrazów:https://realtimeillumination.wordpress.com/
http://media.moddb.com/
Metody monte carlo pozwalają przyspieszyć działanie
algorytmu.
20 kwietnia 2018 r. Bartosz Bazyluk 12
Screen-Space Ambient Occlusion
(SSAO)
Źródła obrazu:Tatarchuk ‘08
Blizzard Entertainment
Komponent Ambient w grze Starcraft II. Widoczne
użycie SSAO.
Zaszumienie obrazu wynika z zastosowanego rozkładu
próbek. Rezultat jest później rozmywany z uwzględnieniem
nieciągłości głębi.
20 kwietnia 2018 r. Bartosz Bazyluk 13
Deferred Shading
Problem:
W jaki sposób efektywnie obliczyć dynamiczne oświetlenie
dla dużej liczby świateł i bardzo złożonej geometrii?
20 kwietnia 2018 r. Bartosz Bazyluk 14
Forward Shading
W klasycznym podejściu (ang. forward shading) oświetlenie
jest obliczane dla każdego fragmentu powstałego przy
renderowaniu kolejnych elementów sceny.
W ten sposób dla każdego piksela bufora klatki wielokrotnie
wykonuje się czasochłonne obliczenia zupełnie na darmo.
Oczywiście stosowane są różne optymalizacje zmniejszające ten
problem, jednak nie można go całkowicie wyeliminować.
Wydajność potoku jest więc ściśle zależna od złożoności geometrii, a także od liczby źródeł światła.
Geometria Shading
Framebuffer
Geometria Shading
Geometria Shading
Geometria Shading
Geometria Shading
20 kwietnia 2018 r. Bartosz Bazyluk 15
Deferred Shading
Podejściez odroczonym cieniowaniem
(ang. deferred shading) polega na przebudowie potoku tak, by właściwe cieniowanie
odbywało się dopiero po wyrenderowaniu geometrii.
Na pierwszym etapie obliczane są tylko podstawowe wartości, które
posłużą później do właściwego obliczenia oświetlenia.
Najbardziej kosztowne operacje związane z oświetleniem są zatem
zawsze wykonywane tyle razy, ile mamy pikseli w buforze klatki
(w uproszczeniu), a więc niezależnie od faktycznej
złożoności geometrii.
Geometria
G-Buffer
Geometria
Geometria
Geometria
Geometria
Shading Framebuffer
20 kwietnia 2018 r. Bartosz Bazyluk 16
Deferred Shading ● Metoda odraczająca obliczenie oświetlenia do momentu, gdy będzie gotowa zawartość bufora klatki
● Dzieli proces renderowania klatki na dwa etapy:● Obliczenie na podstawie geometrii sceny wartości,
które będą niezbędne dla obliczenia oświetlenia
● Obliczenie właściwego oświetlenia z pomienięciem geometrii, już w przestrzeni ekranu
Źródła obrazów:Anton LindeströmEpic Games, UDK
Screen z UE3, prezentuje technikę Deferred Shading
ze 123 dynamicznymi światłami (rok 2011)
20 kwietnia 2018 r. Bartosz Bazyluk 17
Deferred Shading
Źródła obrazów:http://www.learnopengl.com
Wynik obliczeń z pierwszego etapu przechowywany jest
w tzw. G-Buffer.
Dopiero na podstawie jego zawartości obliczane jest
faktyczne oświetlenie.
Zaw
arto
ść G
-Buf
fer:
20 kwietnia 2018 r. Bartosz Bazyluk 18
Deferred Shading ● Zalety Deferred Shading:● Złożoność obliczeń związanych z oświetleniem jest
w dużo mniejszym stopniu zależna od złożoności geometrii sceny
● Tym samym możliwość wprowadzenia znacznie większej liczby źródeł światła
● Wady Deferred Shading:● Problemy z technikami anti-aliasingu
– Właściwy kolor pikseli jest obliczany dopiero na samym końcu, w obrazie o docelowej rozdzielczości
● Większe zapotrzebowanie na pamięć
– Bufor klatki musi przechować wszystkie wartości wyliczone podczas pierwszego etapu – jako tzw. G-Buffer
Źródła obrazów:http://gamedev.ru
http://richdavison.co.uk/
Korzyści płynące z użycia podejścia deferred shading stają się znacznie większe,
gdy rozważy się użycie techniki light culling.
Light culling polega na renderowaniu wpływu
źródeł światła tylko dla ograniczonego zasięgu.
Np. renderując światło punktowe, przybliżamy jego
kształt geometrią sfery.
20 kwietnia 2018 r. Bartosz Bazyluk 19
Deferred Lighting ● Modyfikacją techniki Deferred Shading jest podejście nazywane Deferred Lighting
● Nazywane często Light pre-pass
– Odroczone renderowanie pełnoekranowej light mapy,która później jest używana do oświetlenia geometrii
● Trzy przebiegi● Geometry pass
– Wejście: Geometria
– Wyjście: G-Buffer
● Lighting pass
– Wejście: G-Buffer
– Wyjście: Full-screen light map
● Final pass
– Wejście: Geometria + Full-screen light map
– Wyjście: Gotowa klatka
Źródło obrazu:Azkanan, Leadwerks Software
20 kwietnia 2018 r. Bartosz Bazyluk 20
Deferred Lighting ● Modyfikacją techniki Deferred Shading jest podejście nazywane Deferred Lighting
● Redukcja ilości pamięci potrzebnej do przechowania wyjścia z pierwszego etapu
Źródło obrazu:Azkanan, Leadwerks Software
20 kwietnia 2018 r. Bartosz Bazyluk 21
Deferred Lighting
Przykładowa pełnoekranowa mapa światła.
Źródło obrazu:Sony, Guerilla Games
20 kwietnia 2018 r. Bartosz Bazyluk 22
Subsurface Scattering
● Technika subsurface scattering (SSS) polega na symulowaniu podpowierzchniowegorozpraszania światła
● Bierze pod uwagę światło, które przeszło (nie zostało odbite) przez częściowo przezroczystą powierzchnię
● Światło jest rozpraszane w głębi obiektu w wielu kierunkach
● Promienie światła wychodzą w innych miejscach powierzchni obiektu oraz pod innym kątem niż gdyby zostały odbite przez tę powierzchnię
● W rezultacie uwzględniona jest grubość przedmiotu, jak i zmiękczenie ostrych krawędzi cieni
● Materiały i obiekty takie jak: wosk, marmur, ludzka skóra, liście
Odbicie powierzchnioweRozproszenie
podpowierzchniowe
20 kwietnia 2018 r. Bartosz Bazyluk 23
Subsurface Scattering
Źródło obrazów:MrBluesummers
SSS ON
SSS OFF
20 kwietnia 2018 r. Bartosz Bazyluk 24
Subsurface Scattering
Źródło obrazu:MrBluesummers
W rzeczywistym świecie ludzka skóra odbija na powierzchni
jedynie 6% światła, pozostałe 94% pochodzi z rozproszenia
podpowierzchniowego![Krishnaswamy, Baronoski 2004]
Aby realistycznie renderować skórę, konieczne jest więc
uwzględnienie SSS.
20 kwietnia 2018 r. Bartosz Bazyluk 25
Subsurface Scattering
Źródło obrazów:Wikipedia
● Symulowanie SSS● Podstawowe równanie renderingu obejmuje jedynie
powierzchniowe odbicie światła opisane za pomocą BRDF
● Prosta metoda czasu rzeczywistego pozwalająca na przybliżenie wyglądu obiektu zbudowanego z np. wosku, polega na wyznaczeniu jego grubości w danym miejscu korzystając z bufora głębokości uzyskanego z punktu widzenia światła
Odpowiednikiem BRDF uwzględniającym pod-
powierzchniowe rozproszenie jest BSSRDF
20 kwietnia 2018 r. Bartosz Bazyluk 26
Materiały wielowarstwowe
Źródła obrazów:MrBluesummersD M Multimedia
● Szczególnym przypadkiem powiązanym z SSS jest renderowanie materiałów wielowarstwowych (ang. layered material)
● Przykładowe zastosowanie: wizualizacja metalicznego lakieru samochodowego
Przykład wyrenderowanego, kilkuwarstwowego materiału
imitującego lakier samochodowy.
20 kwietnia 2018 r. Bartosz Bazyluk 27
Kaustyki
Źródła obrazów:LuxRenderWikipedia
● Zjawisko polegające na trafianiu wielu odbitych lub załamanych fal światła w pobliżu jednego miejsca nazywamy kaustyką (ang. caustic)
● Najczęściej mamy do czynienia z takim zjawiskiem np. przy wklęsłych zwierciadłach i powierzchniach przepuszczających światło lub przy falujących powierzchniach płynów
Szklanka wody powoduje załamanie fal światła w taki
sposób, że powstają kaustyki
20 kwietnia 2018 r. Bartosz Bazyluk 28
Kaustyki
Źródło obrazów:FXGuide.com, Mike Seymour. The State of Rendering - Part 2.
● Realistyczne renderowanie polega na śledzeniu załamywanych lub odbijanych promieni światła
● Szczególnie dobrze widoczne przy technice mapowania fotonów (ang. photon mapping)
● Metody czasu rzeczywistego polegają m.in. na próbkowaniu powierzchni, operacjachper-fragment i nakładaniu tekstur imitujących obszary skupienia promieni
Bartosz Bazyluk
Definicja GeometriiSposoby definicji geometrii. Backface culling.Renderowanie mapy wysokości.
Gry komputerowe, Informatyka S1, II Rok
http://bazyluk.net/dydaktyka
20 kwietnia 2018 r. Bartosz Bazyluk 30
Renderowanie geometrii
● Geometria jest opisana przede wszystkim pozycjami wierzchołków
● Podczas procesu renderowania powierzchnie obiektów rysowane są za pomocą tzw. prymitywów
● Prymitywy to figury geometryczne odpowiadające za to, jak informacja o kolejnych pozycjach zostanie wykorzystana podczas rysowania
● Mogą to być np. punkty, linie, łamane, trójkąty, pasy trójkątów, czworokąty, wielokąty, itp.
Przetwarzanie wierzchołków
Łączenie w prymitywy
Rasteryzacja prymitywów
Operacje na fragmentach
Operacje na pikselach
Wierzchołki
Bufor klatki
Źródło obrazu:GPU Design
20 kwietnia 2018 r. Bartosz Bazyluk 31
Renderowanie geometrii
● Prymitywy obsługiwane przez OpenGL:
Źródło obrazu:http://www.opengl.org
20 kwietnia 2018 r. Bartosz Bazyluk 32
Renderowanie geometrii
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Myślimy o punktach w przestrzeni 3D, nie na płaszczyźnie
v0
v1
v2
v3
v4
v5
20 kwietnia 2018 r. Bartosz Bazyluk 33
Renderowanie geometrii
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu punkty (ang. points)
v0
v1
v2
v3
v4
v5
20 kwietnia 2018 r. Bartosz Bazyluk 34
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu linie (ang. lines)
Renderowanie geometrii
v0
v1
v2
v3
v4
v5
20 kwietnia 2018 r. Bartosz Bazyluk 35
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu łamana (ang. line strip)
Renderowanie geometrii
v0
v1
v2
v3
v4
v5
20 kwietnia 2018 r. Bartosz Bazyluk 36
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu łamana zamknięta (ang. line loop)
Renderowanie geometrii
v0
v1
v2
v3
v4
v5
20 kwietnia 2018 r. Bartosz Bazyluk 37
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu trójkąty (ang. triangles)
Renderowanie geometrii
v0
v1 v
2
v3
v4
v5
20 kwietnia 2018 r. Bartosz Bazyluk 38
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu wachlarz (ang. triangle fan)
Renderowanie geometrii
v0
v1
v2
v3
v4
v5
20 kwietnia 2018 r. Bartosz Bazyluk 39
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu pas trójkątów (ang. triangle strip)
Renderowanie geometrii
v0
v1
v2
v3
v4
v5
20 kwietnia 2018 r. Bartosz Bazyluk 40
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu czworokąty (ang. quads)
Renderowanie geometrii
v0
v1
v2
v3
v4
v5
Dwa ostatnie wierzchołki nie są wykorzystane- aby powstał kolejny quad, potrzebne byłyby
dwa następne!
20 kwietnia 2018 r. Bartosz Bazyluk 41
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu pas czworokątów (ang. quad strip)
Renderowanie geometrii
v0
v1
v2
v3
v4
v5
Ten czworokąt jest niepoprawny („zdegenerowany”)– nie jest wypukły!
20 kwietnia 2018 r. Bartosz Bazyluk 42
● Przykład:● Mamy dane 6 wierzchołków o następujących położeniach:
● Użycie prymitywu wielokąt (ang. polygon)
Renderowanie geometrii
v0
v1
v2
v3
v4
v5
Ten wielokąt jest niepoprawny („zdegenerowany”)– nie jest wypukły!
20 kwietnia 2018 r. Bartosz Bazyluk 43
Face culling ● Rozpatrzmy przypadek: scena zawiera sześcian
● Ile jego ścian jest widocznych na danej klatce animacji?
● Ile ścian jest renderowanych podczas rysowania klatki?
● W którym momencie potoku pomijane są tylne ściany?
Przetwarzanie wierzchołków
Łączenie w prymitywy
Rasteryzacja prymitywów
Operacje na fragmentach
Operacje na pikselach
Wierzchołki
Bufor klatki
20 kwietnia 2018 r. Bartosz Bazyluk 44
Face culling ● Technika face culling pozwala na pominięcie ścian widocznych z określonej strony jeszcze przed rozpoczęciem ich rasteryzacji
● O odrzuceniu decyduje kolejność wierzchołków po ich projekcji (ang. winding order)
● Zgodnie z ruchem wskazówek zegara (ang. clockwise)
● Przeciwnie do wskazówek zegara (ang. counter-clockwise)
Konieczne jest więc ustalenie w jakiej kolejności definiowane są
wierzchołki ścian gdy patrzymy na ich przednią stronę, a potem
konsekwentne trzymanie się ustalonej kolejności podczas
opisywania geometrii obiektów.
v0
v1
v3
v2
CCW
20 kwietnia 2018 r. Bartosz Bazyluk 45
Face culling ● Jeśli po przejściu do współrzędnych kamery kolejność wierzchołków zgadza się z tą uznaną za przednią, to znaczy że widzimy przednią stronę ściany i należy ją poddać rasteryzacji
● Jeśli kolejność jest odwrotna, to widzimy tylną stronę ściany i możemy ją pominąć (jeśli używamy techniki back face culling)
Źródło obrazu:http://www.learningopengl.com
20 kwietnia 2018 r. Bartosz Bazyluk 46
Face culling ● Jak karta graficzna porównuje kolejność wierzchołków?
● Czy kąt pomędzy wektorem normalnym ściany,a wektorem obserwacji jest mniejszy lub równy 90 stopni?
– Wektor normalny obliczamy za pomocą iloczynu wektorowego trzech kolejnych wierzchołków w kolejności ich zdefiniowania
– Równoważne pytanie: Czy iloczyn skalarny między tymi wektorami jest większy lub równy zero?
● Jeśli tak, to kolejność jest różna od początkowej – ścianę należy pominąć!
v0
v1
v2
N
v2-v0
v1-v0
V0
N=(v1−v0)×(v2−v0)V 0∘N⩾0
20 kwietnia 2018 r. Bartosz Bazyluk 47
Face culling ● Kiedy back face culling jest problematyczny?● Gdy na scenie są przezroczyste obiekty
– Wówczas pomijanie tylnych ścian może być widoczne
● Gdy występują obiekty o zerowej grubości, w których obie strony ścian są widoczne
● Do czego dodatkowo może służyć back face culling?● Usuwanie "niewidocznych" linii w renderowaniu wireframe,
pod warunkiem że geometria jest wypukła
● Do czego mógłby służyć front face culling?● Ukrywanie przednich ścian może być przydatne podczas
renderowania mapy cieni, by uniknąć efektu self-shadowing gdy sprawdzane jest przysłonięcie sceny z punktu widzenia źródła światła
20 kwietnia 2018 r. Bartosz Bazyluk 48
Face culling ● Jak korzystać z face cullingu w OpenGL?● Włączanie:
● Wybór kolejności definicji przednich ścian:
– dotyczy wierzchołków definiowanych po wywołaniu tej funkcji
● Wybór ścian, które mają być pomijane:
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW); // przeciwnie do ruchu wskazówek zegaraglFrontFace(GL_CW); // zgodnie z ruchem wskazówek zegara
glCullFace(GL_BACK);glCullFace(GL_FRONT);glCullFace(GL_FRONT_AND_BACK);
20 kwietnia 2018 r. Bartosz Bazyluk 49
Definicja geometrii w OpenGL
● Najprostszą metodą definicji i renderowania geometrii jest tzw. immediate mode
● Definicja własności wszystkich wierzchołków w każdej klatce
● Podejście którego współcześnie się już nie stosuje
– Jest nieefektywne● W każdej klatce duża ilość danych przekazywana do karty graficznej● Współcześnie używa się buforów w pamięci karty graficznej
– Jest najłatwiejsze w zrozumieniu
glBegin(GL_QUADS);
glVertex3f(-1.0f, -1.0f, 0.0f);
glVertex3f(1.0f, -1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glVertex3f(-1.0f, 1.0f, 0.0f);
glEnd();
Prymityw
20 kwietnia 2018 r. Bartosz Bazyluk 50
Kolor w OpenGL ● Atrybuty wierzchołków, np. ich kolor, określamy przed stworzeniem danego wierzchołka
glColor3f(1.0f, 0.0f, 0.0f);glBegin(GL_QUADS);
glVertex3f(-1.0f, -1.0f, 0.0f);glVertex3f(1.0f, -1.0f, 0.0f);glVertex3f(1.0f, 1.0f, 0.0f);glVertex3f(-1.0f, 1.0f, 0.0f);
glEnd();
glBegin(GL_QUADS);glColor3f(0.0f, 0.0f, 0.0f);glVertex3f(-1.0f, -1.0f, 0.0f);glColor3f(1.0f, 0.0f, 0.0f);glVertex3f(1.0f, -1.0f, 0.0f);glColor3f(0.0f, 1.0f, 0.0f);glVertex3f(1.0f, 1.0f, 0.0f);glColor3f(0.0f, 0.0f, 1.0f);glVertex3f(-1.0f, 1.0f, 0.0f);
glEnd();
20 kwietnia 2018 r. Bartosz Bazyluk 51
DEFINICJA GEOMETRII
x
y
z
v0
v1 v
2
v3
v4
v5
v6
v7
● Przykłady będą dotyczyły prostego sześcianu:
● Dla uproszczenia na razie pomijamy wszystko poza pozycjami wierzchołków
Przykładowe dane
20 kwietnia 2018 r. Bartosz Bazyluk 52
DEFINICJA GEOMETRII
x
y
z
v0 = (0,1,1)
v1 = (0,0,1)
v2 = (1,0,1)
v3 = (1,1,1)
v4 = (0,1,0)
v5 = (0,0,0) v
6 = (1,0,0)
v7 = (1,1,0)
● Pozycje wierzchołków:
Przykładowe dane
20 kwietnia 2018 r. Bartosz Bazyluk 53
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
DEFINICJA GEOMETRII
● Kolejność definicji ścian naszego sześcianu:
● Zakładamy użycie prymitywu GL_QUADS● Oczywiście możliwe będzie zyskanie na wydajności
np. używając GL_QUAD_STRIP, ale chcemy prosty przypadek
● GL_QUADS nie jest dostępny we współczesnych wersjach OpenGL, ale pozwala łatwiej zobrazować zagadnienie
Przykładowe dane
20 kwietnia 2018 r. Bartosz Bazyluk 54
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
DEFINICJA GEOMETRII
● Kolejność definicji wierzchołków: ● v0 -> v1 -> v2 -> v3
v3 -> v2 -> v6 -> v7v7 -> v6 -> v5 -> v4v4 -> v5 -> v1 -> v0v0 -> v3 -> v7 -> v4v1 -> v5 -> v6 -> v2
● Czyli: 24 zestawy po 3 współrzędne po 4 bajty
– 24 × 3 × 4 = 288 bajtów
● Pamiętamy o backface cullingu
– zakładamy że front-face'y definiowane są przeciwnie do ruchu wskazówek zegara (CCW)
Przykładowe dane
20 kwietnia 2018 r. Bartosz Bazyluk 55
IMMEDIATE MODE ● Najprostsze podejście polegające na bezpośredniej definicji geometrii
● Wartości (np. współrzędne wierzchołków) dla każdorazowego żądania renderowania, przekazywane są do serwera od nowa
● Oznacza to ogromną ilość danych przesyłaną co klatkę od klienta do serwera
● Oznacza to ogromną liczbę wywołań funkcji OpenGL
Ogólna charakterystyka
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 56
IMMEDIATE MODE ● Otwarcie bloku definicji geometrii● Wskazanie pożądanego prymitywu
● Definicja geometrii● Wierzchołki, wektory normalne, współrzędne tekstur...
● Zamknięcie bloku● Zlecenie renderowania, ewentualne buforowanie
● Przykład dla pierwszego quada:
glBegin(GL_QUADS);glVertex3f(0.0f, 1.0f, 1.0f);glVertex3f(0.0f, 0.0f, 1.0f);glVertex3f(1.0f, 0.0f, 1.0f);glVertex3f(1.0f, 1.0f, 1.0f);
glEnd();
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
Sposób użycia
20 kwietnia 2018 r. Bartosz Bazyluk 57
IMMEDIATE MODE ● Dla całego sześcianu:
Przykład użycia glBegin(GL_QUADS);
glVertex3f(0.0f, 1.0f, 1.0f);glVertex3f(0.0f, 0.0f, 1.0f);glVertex3f(1.0f, 0.0f, 1.0f);glVertex3f(1.0f, 1.0f, 1.0f);
glVertex3f(1.0f, 1.0f, 1.0f);glVertex3f(1.0f, 0.0f, 1.0f);glVertex3f(1.0f, 0.0f, 0.0f);glVertex3f(1.0f, 1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);glVertex3f(1.0f, 0.0f, 0.0f);glVertex3f(0.0f, 0.0f, 0.0f);glVertex3f(0.0f, 1.0f, 0.0f);
glVertex3f(0.0f, 1.0f, 0.0f);glVertex3f(0.0f, 0.0f, 0.0f);glVertex3f(0.0f, 0.0f, 1.0f);glVertex3f(0.0f, 1.0f, 1.0f);
glVertex3f(0.0f, 1.0f, 0.0f);glVertex3f(0.0f, 1.0f, 1.0f);glVertex3f(1.0f, 1.0f, 1.0f);glVertex3f(1.0f, 1.0f, 0.0f);
glVertex3f(0.0f, 1.0f, 1.0f);glVertex3f(1.0f, 1.0f, 1.0f);glVertex3f(1.0f, 1.0f, 0.0f);glVertex3f(0.0f, 1.0f, 0.0f);
glVertex3f(0.0f, 0.0f, 1.0f);glVertex3f(0.0f, 0.0f, 0.0f);glVertex3f(1.0f, 0.0f, 0.0f);glVertex3f(1.0f, 0.0f, 1.0f);
glEnd();
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
● W każdej klatce wysyłamy do serwera pozycje wszystkich wierzchołków
● Nie zmieniają się – po co?
● Powtarzające się wierzchołki wysyłane są kilkukrotnie
● Już zostały przesłane – po co?
20 kwietnia 2018 r. Bartosz Bazyluk 58
DISPLAY LIST ● Skompilowana sekwencja instrukcji zmieniających stan serwera
● Przechowywana w pamięci karty graficznej● Raz utworzona nie może być modyfikowana
● Nie nadaje się do animacji bryły
● Sterownik odpowiada za to, by lista została wykonana efektywnie
● Każda lista ma przypisany identyfikator, który służy jej późniejszemu wywołaniu (żądaniu renderowania)
Ogólna charakterystyka
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 59
DISPLAY LIST ● Utworzenie display listy● Żądanie identyfikatora
● Kompilacja display listy● Wierzchołki, wektory normalne, współrzędne tekstur...
● Można dołączyć inne zmiany stanu serwera
● Wywołanie display listy● Żądanie renderowania z użyciem identyfikatora
● Przykład dla pierwszego quada:
Sposób użycia
GLuint id = glGenLists(1);glNewList(id, GL_COMPILE);
glBegin(GL_QUADS);glVertex3f(0.0f, 1.0f, 1.0f);glVertex3f(0.0f, 0.0f, 1.0f);glVertex3f(1.0f, 0.0f, 1.0f);glVertex3f(1.0f, 1.0f, 1.0f);
glEnd();glEndList();// Renderowanie:glCallList(id);
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 60
DISPLAY LIST ● Dla całego sześcianu:
Przykład użycia GLuint id = glGenLists(1);glNewList(id, GL_COMPILE);
glBegin(GL_QUADS);glVertex3f(0.0f, 1.0f, 1.0f);glVertex3f(0.0f, 0.0f, 1.0f);glVertex3f(1.0f, 0.0f, 1.0f);glVertex3f(1.0f, 1.0f, 1.0f);glVertex3f(1.0f, 1.0f, 1.0f);glVertex3f(1.0f, 0.0f, 1.0f);glVertex3f(1.0f, 0.0f, 0.0f);glVertex3f(1.0f, 1.0f, 0.0f);glVertex3f(1.0f, 1.0f, 0.0f);glVertex3f(1.0f, 0.0f, 0.0f);glVertex3f(0.0f, 0.0f, 0.0f);glVertex3f(0.0f, 1.0f, 0.0f);glVertex3f(0.0f, 1.0f, 0.0f);glVertex3f(0.0f, 0.0f, 0.0f);glVertex3f(0.0f, 0.0f, 1.0f);glVertex3f(0.0f, 1.0f, 1.0f);glVertex3f(0.0f, 1.0f, 0.0f);glVertex3f(0.0f, 1.0f, 1.0f);glVertex3f(1.0f, 1.0f, 1.0f);glVertex3f(1.0f, 1.0f, 0.0f);glVertex3f(0.0f, 1.0f, 1.0f);glVertex3f(1.0f, 1.0f, 1.0f);glVertex3f(1.0f, 1.0f, 0.0f);glVertex3f(0.0f, 1.0f, 0.0f);glVertex3f(0.0f, 0.0f, 1.0f);glVertex3f(0.0f, 0.0f, 0.0f);glVertex3f(1.0f, 0.0f, 0.0f);glVertex3f(1.0f, 0.0f, 1.0f);
glEnd();glEndList();
//…
// Dla każdej klatki:
glCallList(id);
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
● Pozycje wszystkich wierzchołków wysyłamy tylko raz
● Podczas renderowania kolejnych klatek korzystamy z danych znajdujących się w pamięci graficznej
● Znacząco zyskuje na tym wydajność
● Możliwości list wykraczają poza zwykłą definicję geometrii
● Możliwość użycia innych instrukcji zmieniających stan
● Nie ma możliwości modyfikacji listy po jej skompilowaniu
20 kwietnia 2018 r. Bartosz Bazyluk 61
VERTEX ARRAY ● Ciągła tablica po stronie klienta (w pamięci głównej) zawierająca dane wierzchołków
● Możliwość dowolnej manipulacji zawartości● Możliwość wybiórczego renderowania
● Rozwiązuje problem redefinicji powtarzających się wierzchołków, co daje oszczędność pamięci
● Interleaved arrays, czyli łączone tablice dla różnych danych per-vertex
● Np. pozycja, wektor normalny, kolor, współrzędne tekstury...
● Wszystko w jednej tablicy (co ma i zalety, i wady)
Ogólna charakterystyka
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 62
VERTEX ARRAY ● Utworzenie tablicy z wartościami● Zwyczajna tablica po stronie klienta
● Wskazanie serwerowi miejsca w pamięci,gdzie znajdują się dane
● Przekazanie adresu tablicy
● Żądanie renderowania● Można określić, które z danych i w jakiej kolejności
nas interesują
Sposób użycia
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 63
VERTEX ARRAY ● Przykład dla pierwszego quada:
● Aby wskazać gdzie przechowywane są wartości innych atrybutów, można posłużyć się funkcjami:
● glNormalPointer(), glTexCoordPointer(), glVertexAttribPointer(), ...
Sposób użycia (c.d.)GLfloat buffer[] = {
0.0f, 1.0f, 0.0f,0.0f, 1.0f, 1.0f,0.0f, 0.0f, 1.0f,1.0f, 0.0f, 1.0f
};
// Renderowanie:glEnableClientState(GL_VERTEX_ARRAY);glVertexPointer(3, GL_FLOAT, 0, buffer);
glDrawArrays(GL_QUADS, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 64
VERTEX ARRAY ● Wybiórcze renderowanie można zrealizować na kilka różnych sposobów:
● Podzakres tablicy od-do:
– glDrawArrays(primitive, from, to)
● Wskazanie indeksów wierzchołków:
– glDrawElements(primitive, num_indices, index_type, indices)
– Dzięki temu nie musimy redefiniować wierzchołków!
– Przykład – cały sześcian:
Wybiórcze renderowanie
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
GLfloat buffer[] = {0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f,0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f
};GLubyte indices[] = {
0, 1, 2, 3, 3, 2, 6, 7, 7, 6, 5, 4,4, 5, 1, 0, 0, 3, 7, 4, 1, 5, 6, 2
};
// Renderowanie:glEnableClientState(GL_VERTEX_ARRAY);glVertexPointer(3, GL_FLOAT, 0, buffer);
glDrawElements(GL_QUADS, 24, GL_UNSIGNED_BYTE, indices);
glDisableClientState(GL_VERTEX_ARRAY);
20 kwietnia 2018 r. Bartosz Bazyluk 65
VERTEX ARRAY ● Wybiórcze renderowanie można zrealizować na kilka różnych sposobów (c.d.):
● Wskazanie indeksów wierzchołków oraz ich zakresu:
– glDrawRangeElements(primitive, start, end, num_indices, index_type, indices)
– start i end określają zakres wartości elementów z tablicy indeksów (nie zakres tablicy, który zostanie użyty!)
– Służy to do małej optymalizacji – OpenGL będzie wiedział, jakiego zakresu indeksów się spodziewać bez konieczności iterowania po tablicy indeksów. W ten sposób może lepiej zaplanować odczyt z VA.
● Co cechuje Vertex Arrays?● Możliwość dowolnej kontroli wartości w trakcie
renderowania
– Przydatne przy animacji bryły
● Konieczność przesłania tablicy do pamięci karty graficznej
● Dużo mniej odwołań do funkcji OpenGL
Wybiórcze renderowanie
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 66
WYBIÓRCZE RENDEROWANIE
● Inny przykład praktycznego wykorzystania selektywnego renderowania geometrii z użyciem indeksów wierzchołków:
● Level of detail (LOD) dla map wysokościPrzykład zastosowania
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
Źródło obrazu:http://windows-tech.info
20 kwietnia 2018 r. Bartosz Bazyluk 67
VERTEX ARRAY ● Przekazywanie wartości dodatkowych atrybutów wierzchołków
● Nie tylko pozycja (współrzędne) jest wartością per-vertex
– Wektory normalne, współrzędne tekstur, wektory styczne, kolor, stopień zniszczenia, wiek, stopień deformacji, zabrudzenie, następna pozycja, ...
– Możemy definiować własne atrybuty, które wykorzystamy w naszych shaderach
● Są dwa podejścia rozwiązania tej kwestii:
– Oddzielne tablice dla każdego z atrybutów
– Jedna tablica zawierająca przeplatające się wartości atrybutów(tzw. interleaved arrays)
Dodatkowe atrybuty
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 68
INTERLEAVED ARRAYS
● Interleaved arrays – przykład:
● Parametry każdego atrybutu:● offset – odległość w bajtach od początku wierzchołka
● stride – odległość w bajtach pomiędzy wierzchołkami
● Zakładając, że szerokość każdej wartości to 4B, mamy:
– offset(p) = 0, stride(p) = 32
– offset(n) = 12, stride(n) = 32
– offset(t) = 24, stride(t) = 32
Sposób działania
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
...
v0
v1
v2
Współrzędne pozycji (p)
Wektor normalny (n)
Współrzędne 2D tekstury (t)
20 kwietnia 2018 r. Bartosz Bazyluk 69
INTERLEAVED ARRAYS
● Reprezentacja interleaved array w pamięci głównej z punktu widzenia programu
● Wygodnym podejściem jest użycie struktur
● C++ gwarantuje, że struktura zajmuje ciągły obszar pamięci, a składowe mają zachowaną kolejność
● Zamiast arytmetyki wskaźników (mogącej doprowadzić do problemów), warto wykorzystać po prostu:
– &buffer[0].pos, &buffer[0].normal, &buffer[0].tex
Sposób użycia
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
typedef struct {GLfloat pos[3];GLfloat normal[3];GLfloat tex[2];
} SVertex;
SVertex buffer[];
glVertexPointer(3, GL_FLOAT, sizeof(SVertex), buffer);glNormalPointer(GL_FLOAT, sizeof(SVertex), buffer + 3 * sizeof(GLfloat));glTexCoordPointer(2, GL_FLOAT, sizeof(SVertex), buffer + 6 * sizeof(GLfloat));
20 kwietnia 2018 r. Bartosz Bazyluk 70
INTERLEAVED ARRAYS
● Interleaved arrays – dodatkowe informacje:● Jeśli np. planujemy często zmieniać pozycję wierzchołków,
pozostawiając pozostałe atrybuty bez zmian, warto użyć oddzielnych tablic
● Warto dążyć do tego, by stride był równy wielokrotności 32. Wiele kart graficznych potrafi wtedy lepiej organizować odczyt z pamięci
– Nawet kosztem zwiększonego zużycia pamięci,wprowadzając padding!
● Możemy określić stride jako 0, jeśli nasze dane są ciasno upakowane (żadnego paddingu) i tablice zawierają wartości tylko pojedynczych atrybutów
● Jeśli nasz układ danych jest standardowy, można użyć funkcji glInterleavedArrays() w celu wyboru tego układu(oszczędza liczbę wywołań funkcji OpenGL)
Dodatkowe informacje
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 71
VBO ● Vertex Buffer Object (VBO) – technika pozwalająca na łatwe manipulowanie zawartością pamięci karty graficznej
● Siostrzana technika do Frame Buffer Object (FBO) i Pixel Buffer Object (PBO)
● Pozwala zarezerwować, wypełnić, odczytać, modyfikować zawartość bufora
● Po stronie klienta przechowywany jest jedynie identyfikator bufora
Ogólna charakterystyka
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
Klient Serwer
VBO
id
(dane)
20 kwietnia 2018 r. Bartosz Bazyluk 72
VBO ● Wygenerowanie nowego bufora● Otrzymujemy id bufora
● Bindowanie bufora● Wybór bufora, który ma stać się aktywny
● Określenie rodzaju bufora (GL_ARRAY_BUFFER)
● Alokacja bufora● Przekazanie danych do pamięci karty graficznej
● Określenie charakteru danych: czy będą często modyfikowane, czy też nie...
– Wpływa na optymalny przydział pamięci
● Wskazanie miejsc w pamięci● Nie przekazujemy wskaźników (bo ich nie mamy), tylko
określamy liczbowo offset i stride dla VBO
● Żądanie renderowania● Można określić, które z danych i w jakiej kolejności
nas interesują
Sposób użycia
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 73
VBO ● Przykład dla pierwszego quada:
Przykład użyciaGLfloat buffer[] = {0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f};
GLuint vbo;glGenBuffers(1, &vbo);glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(buffer), buffer, GL_STATIC_DRAW);delete[] buffer; // Oczywiście jest to błędne użycie (alokacja podczas kompilacji)
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Renderowanie:glBindBuffer(GL_ARRAY_BUFFER, vbo);
glEnableClientState(GL_VERTEX_ARRAY);glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_QUADS, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);glBindBuffer(GL_ARRAY_BUFFER, 0);
// Sprzątanie:glDeleteBuffers(1, &vbo);
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 74
VBO ● Istnieje możliwość modyfikacji zawartości VBO:● Ponowna alokacja pamięci i wysłanie danych
– glBufferData(target, size, data, usage)
● Poprzez zastąpienie części danych
– glBufferSubData(target, offset, size, data)
– Pamięć nie jest realokowana!Warto użyć nawet, jeśli zamieniamy całą zawartość bufora.
● Poprzez mapowanie pamięci
– glMapBuffer(target, access)
– glUnmapBuffer(target)
– Otrzymujemy wskaźnik do pamięci, możemy dowolnie ją czytać i zmieniać
– Kosztowna synchronizacja z GPU
● Warto zastanowić się nad wydajnością i synchronizacją
– Wykorzystanie techniki podwójnego buforowania(dwa VBO, które zamieniamy miejscami – rysujemy z jednego, drugi uaktualniamy) może rozwiązać problem synchronizacji
Modyfikacja zawartości
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 75
IBO ● Wybiórcze renderowanie z VBO jest jeszcze lepsze● Mamy możliwość stworzenia bufora indeksów:
Index Buffer Object (IBO)
● IBO działa analogicznie do VBO:
– Musimy go stworzyć, wybrać, zaalokować, wypełnić, zwolnić
– GL_ELEMENT_ARRAY_BUFFER
● IBO jest przechowywany w pamięci karty graficznej– odczyt podczas renderowania nie wymaga przesyłania danych z pamięci głównej!
Indeksowanie VBO
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
20 kwietnia 2018 r. Bartosz Bazyluk 76
IBO ● Przykład – cały sześcian:
Przykład użycia
x
y
z
v0
v1
v2
v3
v4
v5 v
6
v7
GLfloat buffer[] = {0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f,0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f
};GLubyte indices[] = {
0, 1, 2, 3, 3, 2, 6, 7, 7, 6, 5, 4,4, 5, 1, 0, 0, 3, 7, 4, 1, 5, 6, 2
};
GLuint vbo, ibo;
glGenBuffers(1, &vbo);glBindBuffer(GL_ARRAY_BUFFER, vbo);glBufferData(GL_ARRAY_BUFFER, sizeof(buffer), buffer, GL_STATIC_DRAW);delete[] buffer;
glGenBuffers(1, &ibo);glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);delete[] indices;
// Renderowanie:glEnableClientState(GL_VERTEX_ARRAY);glVertexPointer(3, GL_FLOAT, 0, buffer);glDrawElements(GL_QUADS, 24, GL_UNSIGNED_BYTE, 0);glDisableClientState(GL_VERTEX_ARRAY);
// Sprzątanie:glBindBuffer(GL_ARRAY_BUFFER, 0);glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);glDeleteBuffers(1, &vbo);glDeleteBuffers(1, &ibo);
20 kwietnia 2018 r. Bartosz Bazyluk 77
Renderowanie mapy wysokości
● Zadanie: zwizualizować rzeźbę terenu daną mapą wysokości (heightmapą)
● Bitmapa, gdzie wartość każdego piksela jest zapisem wysokości terenu w danym miejscu
– Odcienie szarości
● Regularna siatka punktów pomiarowych
● Na jej podstawie należy zbudować zbiór wierzchołków, wyrenderować go i ocieniować dla uzyskania jak najlepszego efektu.
● Ilość wykorzystanej pamięci karty graficznej powinna być jak najmniejsza.
Mapa wysokości
Czyli dane wejściowe naszego programu.
Jaśniejszy kolor na mapie oznacza większą wysokość.
20 kwietnia 2018 r. Bartosz Bazyluk 78
Renderowanie mapy wysokości
Chmura punktów
Każdy punkt pomiarowy zwizualizowany jako punkt.
20 kwietnia 2018 r. Bartosz Bazyluk 79
Renderowanie mapy wysokości
Powierzchnia
Teren wyrenderowany jako powierzchnia złożona
z trójkątów. Kolor fragmentu odpowiada wysokości terenu w
danym miejscu.
20 kwietnia 2018 r. Bartosz Bazyluk 80
Renderowanie mapy wysokości
Oświetlenie
Obliczone wektory normalne, zaimplementowany model
oświetlenia Phonga.
20 kwietnia 2018 r. Bartosz Bazyluk 81
Renderowanie mapy wysokości
Teksturowanie
Proceduralny dobór tekstury na podstawie wysokości
oraz nachylenia terenu w danym fragmencie.
20 kwietnia 2018 r. Bartosz Bazyluk 82
Renderowanie mapy wysokości
● Wierzchołki: VBO● Zawiera informacje o wysokościach, odczytane z mapy
● Każdy wierzchołek występuje tylko raz
● Dodatkowo wektory normalne, współrzędne tekstury
● Indeksy: IBO● Za pomocą indeksów wierzchołków z VBO
tworzy siatkę która posłuży do wyrenderowania powierzchni
● Żądanie renderowania● glDrawElements()
● Prymityw GL_TRIANGLE_STRIP
● Najlepiej zawrzeć całą mapę w tylko jednym żądaniu!
20 kwietnia 2018 r. Bartosz Bazyluk 83
Renderowanie mapy wysokości
1
Jeden render call
Używając prymitywu TRIANGLE_STRIP, mamy
możliwość prostego zawarcia całego terenu w jednym zbiorze
wierzchołków.
20 kwietnia 2018 r. Bartosz Bazyluk 84
Renderowanie mapy wysokości
1
2
Jeden render call
W każdej iteracji po kolumnach mapy wysokości, w obrębie jednego wiersza, będziemy
dodawać do zbioru dwa wierzchołki:
- z obecnego wiersza- z kolejnego wiersza
20 kwietnia 2018 r. Bartosz Bazyluk 85
Renderowanie mapy wysokości
1
2
3
Jeden render call
W każdej iteracji po kolumnach mapy wysokości, w obrębie jednego wiersza, będziemy
dodawać do zbioru dwa wierzchołki:
- z obecnego wiersza- z kolejnego wiersza
20 kwietnia 2018 r. Bartosz Bazyluk 86
Renderowanie mapy wysokości
1
2
3
4
Jeden render call
W każdej iteracji po kolumnach mapy wysokości, w obrębie jednego wiersza, będziemy
dodawać do zbioru dwa wierzchołki:
- z obecnego wiersza- z kolejnego wiersza
20 kwietnia 2018 r. Bartosz Bazyluk 87
Renderowanie mapy wysokości
1
2
3
4
5
6 8
7
Jeden render call
Problem pojawia się gdy dotrzemy do końca wiersza.
Jak przejść do następnego wiersza nie przerywając
renderowania?
20 kwietnia 2018 r. Bartosz Bazyluk 88
Renderowanie mapy wysokości
1
2
3
4
5
6 8
7
9
Jeden render call
Jeśli zaczęlibyśmy od razu kolejny wiersz w taki sam
sposób jak poprzednio, otrzymalibyśmy niepożądany
trójkąt przecinający nasz misternie
przygotowywany teren.
20 kwietnia 2018 r. Bartosz Bazyluk 89
Renderowanie mapy wysokości
1
2
3
4
5
6 8
7
9
Jeden render call
Powszechnie wykorzystywanym sposobem jest użycie tzw.
zdegenerowanych trójkątów.
Dodajemy jeszcze jeden wierzchołek w tym samym
miejscu. Stosunkowo małym kosztem tworzymy w ten sposób
trójkąt, który podczas rasteryzacji nie wytworzy
żadnego fragmentu.
20 kwietnia 2018 r. Bartosz Bazyluk 90
Renderowanie mapy wysokości
1
2
3
4
5
6 8
7
910
Jeden render call
Przechodząc teraz do nowego wiersza, tworzymy jeszcze jeden
zdegenerowany trójkąt.
Uwaga: używając prymitywu LINE_STRIP, uzyskamy tutaj
dodatkową linię przechodzącą przez całą mapę!
20 kwietnia 2018 r. Bartosz Bazyluk 91
Renderowanie mapy wysokości
1
2
3
4
5
6 8
7
910 11
Jeden render call
Gdybyśmy od razu zaczęli kolejny wiersz, powstałby
zbędny trójkąt 9-10-11.
Dlatego potrzebujemy jeszcze jednego zdegenerowanego
trójkąta, by móc swobodnie iterować po kolejnym wierszu.
20 kwietnia 2018 r. Bartosz Bazyluk 92
Renderowanie mapy wysokości
1
2
3
4
5
6 8
7
910 11
12
Jeden render call
Teraz możemy już swobodnie zająć się kolejnym wierszem.
Całość można rozwiązać też na inne sposoby, np. odwracając
kolejność co drugiego wiersza.
20 kwietnia 2018 r. Bartosz Bazyluk 93
Renderowanie mapy wysokości
1
2
3
4
5
6 8
7
910 11
12
13
Jeden render call
Teraz możemy już swobodnie zająć się kolejnym wierszem.
Całość można rozwiązać też na inne sposoby, np. odwracając
kolejność co drugiego wiersza.
20 kwietnia 2018 r. Bartosz Bazyluk 94
Renderowanie mapy wysokości
1
2
3
4
5
6 8
7
910 11
12 14
13
Jeden render call
Teraz możemy już swobodnie zająć się kolejnym wierszem.
Całość można rozwiązać też na inne sposoby, np. odwracając
kolejność co drugiego wiersza.
20 kwietnia 2018 r. Bartosz Bazyluk 95
Renderowanie mapy wysokości
1
2
3
4
5
6 8
7
910 11
12 14 16 18
28262422
19
13 15 17
20 21 23 25 27
Jeden render call
Postępujemy w ten sposób do samego końca.
W ten sposób uzyskujemy całą powierzchnię mapy.
20 kwietnia 2018 r. Bartosz Bazyluk 96
Renderowanie mapy wysokości
Wektory normalne
Musimy dla każdego wierzchołka obliczyć współrzędne wektora
normalnego.
Pamiętajmy, że jeśli zależy nam na uzyskaniu gładkiej
powierzchni, wektory normalne powinny być identyczne
dla wierzchołków o tej samej pozycji.
Dlatego wektory normalne należy powiązać z punktami
węzłowymi mapy wysokości, analogicznie do wysokości terenu w danym miejscu.
Źródło obrazu:http://www.lighthouse3d.com
20 kwietnia 2018 r. Bartosz Bazyluk 97
Renderowanie mapy wysokości
Wektory normalne
Jednym ze sposobów jest uśrednienie wektorów
normalnych obliczonych dla wszystkich zbiegających się
w danym wierzchołku ścian.
To nie muszą być dokładnie te ściany, które faktycznie
renderujemy!
Warto uwzględnić wszystkie trójkąty wokoło rozpatrywanego
w danej chwili wierzchołka.
Źródło obrazu:http://www.lighthouse3d.com
20 kwietnia 2018 r. Bartosz Bazyluk 98
Renderowanie mapy wysokości
Wektory normalne
By obliczyć wektor normalny pojedynczego trójkąta, należy
wyliczyć iloczyn wektorowy wektorów zbudowanych
z jego boków.
Budując wektory, bierzemy pod uwagę wszystkie trzy
współrzędne wierzchołków trójkąta – wszak zależy nam
na uwzględnieniu nachylenia terenu w trzech wymiarach.
Źródło obrazu:http://www.lighthouse3d.com
v(i -1 , j )
n0=v(i−1, j−1)×v(i−1, j)
v(i -1 , j -1)
20 kwietnia 2018 r. Bartosz Bazyluk 99
Renderowanie mapy wysokości
Wektory normalne
Należy pamiętać o kolejności mnożonych wektorów, która
wpłynie na zwrot wyniku(„reguła śruby prawoskrętnej”,
„reguła prawej dłoni”).
Źródło obrazu:http://www.lighthouse3d.com
v(i -1 , j )
n1=v(i−1, j)×v(i−1, j+1)
v(i -1 , j+1)
20 kwietnia 2018 r. Bartosz Bazyluk 100
Renderowanie mapy wysokości
Wektory normalne
Postępujemy tak samo dla wszystkich ośmiu trójkątów.
Źródło obrazu:http://www.lighthouse3d.com
v( i , j+1)n2=v(i−1, j+1)×v(i , j+1)
v( i-1 , j+1)
20 kwietnia 2018 r. Bartosz Bazyluk 101
Renderowanie mapy wysokości
Wektory normalne
Na końcu sumujemywektory, które obliczyliśmy
dla pojedynczych trójkątów. Wynik dzielimy przez ich liczbę, aby nasz wektor normalny miał długość 1.
Potem przechodzimy do kolejnego wierzchołka i powtarzamy proces.
Zamiast trójkątów, można rozpatrywać czworokąty.
Wynikowe wektory normalne można poddać dodatkowo
rozmyciu z użyciem filtracji splotowej.
Źródło obrazu:http://www.lighthouse3d.com
N=18∑i=0
8
ni
Bartosz Bazyluk
Definicja GeometriiSposoby definicji geometrii. Backface culling.Renderowanie mapy wysokości.
Gry komputerowe, Informatyka S1, II Rok
http://bazyluk.net/dydaktyka