bartosz bazyluk oświetleniebazyluk.net/dydaktyka/gry_2018/04_geometria.pdf · geometria shading...

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



Źródło obrazu:Panocapture.com, Automotive Pack



● 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.



● 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


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


Mapowanie środowiska

Źródło obrazu:Gran Turismo

Sony Computer Entertainment


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.


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/

http://animationdynamics.com/


Ambient Occlusion

Źródło obrazów:Andrew Kramer


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.

https://realtimeillumination.wordpress.com/


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.


Deferred Shading

Problem:

W jaki sposób efektywnie obliczyć dynamiczne oświetlenie

dla dużej liczby świateł i bardzo złożonej geometrii?


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


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


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)


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:


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.

http://gamedev.ru/


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


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


Deferred Lighting

Przykładowa pełnoekranowa mapa światła.

Źródło obrazu:Sony, Guerilla Games


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



Źródło obrazów:MrBluesummers

SSS ON

SSS OFF



Ź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.



Ź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


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.


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


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.




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



● Prymitywy obsługiwane przez OpenGL:

Źródło obrazu:http://www.opengl.org



● 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




● Użycie prymitywu punkty (ang. points)

v0

v1

v2

v3

v4

v5



● Użycie prymitywu linie (ang. lines)


v0

v1

v2

v3

v4

v5



● Użycie prymitywu łamana (ang. line strip)


v0

v1

v2

v3

v4

v5



● Użycie prymitywu łamana zamknięta (ang. line loop)


v0

v1

v2

v3

v4

v5



● Użycie prymitywu trójkąty (ang. triangles)


v0

v1 v

2

v3

v4

v5



● Użycie prymitywu wachlarz (ang. triangle fan)


v0

v1

v2

v3

v4

v5



● Użycie prymitywu pas trójkątów (ang. triangle strip)


v0

v1

v2

v3

v4

v5



● Użycie prymitywu czworokąty (ang. quads)


v0

v1

v2

v3

v4

v5

Dwa ostatnie wierzchołki nie są wykorzystane- aby powstał kolejny quad, potrzebne byłyby

dwa następne!



● Użycie prymitywu pas czworokątów (ang. quad strip)


v0

v1

v2

v3

v4

v5

Ten czworokąt jest niepoprawny („zdegenerowany”)– nie jest wypukły!



● Użycie prymitywu wielokąt (ang. polygon)


v0

v1

v2

v3

v4

v5

Ten wielokąt jest niepoprawny („zdegenerowany”)– nie jest wypukły!


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


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


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


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


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


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);


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


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();


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


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


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


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


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


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


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);







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?


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)


x

y

z

v0

v1

v2

v3

v4

v5 v

6

v7


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


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


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)


x

y

z

v0

v1

v2

v3

v4

v5 v

6

v7


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


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


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);


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


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


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


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)


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));


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


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


x

y

z

v0

v1

v2

v3

v4

v5 v

6

v7

Klient Serwer

VBO

id

(dane)


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


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


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


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


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);


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ść.



Chmura punktów

Każdy punkt pomiarowy zwizualizowany jako punkt.



Powierzchnia

Teren wyrenderowany jako powierzchnia złożona

z trójkątów. Kolor fragmentu odpowiada wysokości terenu w

danym miejscu.



Oświetlenie

Obliczone wektory normalne, zaimplementowany model

oświetlenia Phonga.



Teksturowanie

Proceduralny dobór tekstury na podstawie wysokości

oraz nachylenia terenu w danym fragmencie.



● 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!



1

Jeden render call

Używając prymitywu TRIANGLE_STRIP, mamy

możliwość prostego zawarcia całego terenu w jednym zbiorze

wierzchołków.



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



1

2

3

Jeden render call






1

2

3

4

Jeden render call






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?



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.



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.



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ę!



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.



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.



1

2

3

4

5

6 8

7

910 11

12

13

Jeden render call






1

2

3

4

5

6 8

7

910 11

12 14

13

Jeden render call






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.



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



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.




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.


v(i -1 , j )

n0=v(i−1, j−1)×v(i−1, j)

v(i -1 , j -1)



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”).


v(i -1 , j )

n1=v(i−1, j)×v(i−1, j+1)

v(i -1 , j+1)



Wektory normalne

Postępujemy tak samo dla wszystkich ośmiu trójkątów.


v( i , j+1)n2=v(i−1, j+1)×v(i , j+1)

v( i-1 , j+1)



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.


N=18∑i=0

8

ni

Bartosz Bazyluk

Definicja GeometriiSposoby definicji geometrii. Backface culling.Renderowanie mapy wysokości.



bartosz bazyluk oświetleniebazyluk.net/dydaktyka/gry_2018/04_geometria.pdf · geometria shading...

Documents