Differences
This shows you the differences between two versions of the page.
|
pgapi:laboratoare:02 [2024/10/08 11:58] florica.moldoveanu [Suprafețe de rotație] |
pgapi:laboratoare:02 [2025/09/29 18:23] (current) andrei.lambru |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== Laboratorul 02 ====== | + | ===== Laboratorul 02 ===== |
| - | ===== Suprafețe generate ===== | + | ===== Deferred Rendering ===== |
| - | În multe cazuri, putem cunoaște propietățile unei suprafețe fără a-i cunoaște geometria explicită. Putem genera această suprafață folosind o geometrie generatoare și un proces de generare. În acest laborator, vom explora câteva din metodele de generare existente. | + | ==== Introducere ==== |
| - | Orice suprafață generată are: | + | Pentru a desena obiecte iluminate 3D metoda studiată până acum este prin aplicarea directă a calculelor de iluminare (iluminare în vertex sau fragment shader) pentru a determina culorile pixelilor suprafețelor desenate. Această tehnică se numește forward rendering. |
| - | * Un generator, adică o geometrie explicit definită pe baza căreia are loc procesul de generare | + | |
| - | * Un algoritm de generare. Acesta poate fi bazat pe rotație, translație sau pe orice fel de curbă definită prin puncte de control (ex: Bezier, Hermite, etc) | + | |
| - | Procesul de generare decurge astfel: întâi se desenează geometria generator, pe baza căreia va fi construită suprafața generată. După aceasta, se desenează un număr de instanțe ale geometriei generator, fiecare transformată de funcția de generare într-un mod progresiv. Rezultatul final este obținut prin combinarea topologică a acestor instanțe. | + | Tehnica forward rendering nu se scalează bine când sunt multe surse de lumină deoarece se realizează calculele de iluminare și pentru pixelii unor suprafețe care sunt pe urmă obturați de pixelii altor suprafețe care sunt mai apropiați de observator. |
| - | ===== Diferite tipuri de instanțiere ===== | + | Pentru multe surse de lumină este avantajos să realizăm calculele de iluminare doar pentru pixelii care râmăn afișați în final pe ecran. |
| - | Instanțierea reprezintă un mecanism prin care se amplifică numărul de primitive trimise la banda grafică. Această amplificare este fie explicită (programată de utilizator în shader), fie implicită (generată prin comenzi OpenGL). | + | Deferred Rendering este o tehnică avansată, extensibilă si versatilă de sinteză în timp real de imagini ale obiectelor dintr-o scenă 3D. Cu un nume sugestiv, 'intârziat' sau 'amânat', tehnica se bazează pe desenarea de informație a geometriei din fiecare pixel(poziție in spațiul lume, vectorul normal în spațiul lume, constanta difuză, constanta speculară, strălucirea etc.) în texturi separate într-un prim pas, amânând procesul de iluminare pentru un pas urmator. Astfel când începe procesul de iluminare se vor folosi informațiile pixelilor celor mai apropiați de observator. |
| - | Pentru a instanția implict geometrie, există comanda: | + | ==== Forward Rendering ==== |
| + | In forward rendering culoarea finală a unui pixel se obține prin contribuția fiecărui fragment afișat in acel pixel, iar pentru culoarea fragmentelor se evaluează contribuția de la fiecare lumină din scenă. Din cauza aceasta, sunt evaluate fragmente ce vor fi acoperite ulterior sau se calculează contribuția neglijabilă a unei lumini îndepărtate. | ||
| - | <code cpp> | + | ==== Deferred Rendering ==== |
| - | glDrawElementsInstanced(topologie, nr_indecsi, tip_data, offset, instante). | + | In deferred rendering, ecuația de iluminare nu se mai execută pentru fiecare combinație posibilă (obiect, lumina), ci doar pentru luminile ce garantat au o contribuție ne-neglijabila. |
| - | </code> | + | |
| - | De exemplu, dacă aș dori să desenez de 1540 de ori (instanțe) un obiect cu 99 de indecși, format din triunghiuri din buffer-ul de indecși, legat curent la banda grafică, atunci comanda ar fi: | + | Acest lucru se face in 3 etape: |
| + | - GEOMETRY PASS: evaluarea informațiilor geometrice si texturale per pixel | ||
| + | - LIGHT ACCUMULATION PASS: folosind functia de blend (GL_ONE, GL_ONE), se acumulează într-o textură rezultatul calculului de iluminare pentru fiecare lumină, utilizând informațiile geometrice randate în G-buffer la pasul 1. | ||
| + | - FINAL(COMPOSITION) PASS: se evaluează culoarea finală a pixelului ca funcție de iluminarea acumulată la pasul anterior și de informațiile texturale(și poate și geometrice, e.g. rim light etc.) | ||
| - | <code cpp> | + | === Geometry Buffer === |
| - | glDrawElementsInstanced(GL_TRIANGLES, 99, GL_UNSIGNED_INT, 0, 1540); | + | |
| - | </code> | + | |
| - | Instanțierea explicită se face în shader, generând geometrie nouă prin comenzi glsl, în acest caz prin comenzi de geometry shader: | + | Pentru a implementa deferred rendering, vom folosi un frame buffer mare, denumit Geometry Buffer, sau G-Buffer. Acesta are atașate mai multe render textures utilizând GL_COLOR_ATTACHMENT_i. |
| - | <code cpp> | + | {{:pgapi:laboratoare:g-buffer.png?500|}} |
| - | gl_Position = P*V*M*vec4(p1, 1); EmitVertex(); | + | |
| - | gl_Position = P*V*M*vec4(p2, 1); EmitVertex(); | + | |
| - | gl_Position = P*V*M*vec4(p3, 1); EmitVertex(); | + | |
| - | EndPrimitive(); | + | |
| - | </code> | + | |
| - | Instanțirea oferă posibilitatea ușoară de a crește rapid numărul de obiecte din scenă, dacă obiectele sunt identice. Ex: copaci, tile-uri de teren, unități într-un rts, etc. | + | |
| - | Pentru a lucra cu suprafețe de translație, rotație și/sau interpolare, vom folosi instanțiere. Totuși, chiar dacă avem N instanțe de geometrie generator, nu avem topologia necesară pentru a lega instanțele, deoarece generatorul este o curbă (topologie 2D), iar suprafața generată necesită topologie 3D. | + | === Geometry Pass === |
| + | In această etapă sunt completate urmatoarele render targets din G-buffer: | ||
| + | * adâncime(se face automat) | ||
| + | * poziție | ||
| + | * normală | ||
| + | * culoare | ||
| - | {{ :pgapi:laboratoare:poza_suprafete.png?nolink |}} | + | === Light Accumulation Pass === |
| + | In această etapă sunt completate intrările din G-buffer pentru acumularea de lumină. | ||
| - | Din figură se observă clar cum avem mai multe tipuri de obiecte: | + | Pentru a calcula intersecția intre obiecte și lumini vom folosi obiecte geometrice aferente luminilor: sfera cu rază egala cu distanța maximă de influență pentru lumina omnidirectională, con cu sferă în baza pentru spot light(nu e implementat in laborator). |
| - | - Obiectul generator (prima linie neagră din stânga) | + | |
| - | - Obiectul nou generat (2 instanțe ale generatorului și topologie de legatură între linii) | + | |
| - | - Suprafața finală generată | + | |
| - | Dacă nu am fi folosit acest proces, atunci prin instanțiere am fi obținut liniile instanțiate, dar nu și topologia de legatură între linii, adică exact ca în următoarea imagine: | + | Pentru fiecare fragment de obiect ce reprezintă o lumină se încarcă poziția si normala din G-buffer și se evaluează ecuația de iluminare. Rezultatul este acumulat in bufferul de acumulare din G-buffer. |
| - | {{ :pgapi:laboratoare:poza_curbe.png?nolink |}} | + | === Final Pass === |
| - | ===== Suprafețe de translație ===== | + | In aceasta etapă se calculează rezultatul final per pixel. Culoarea nu se scrie in G-buffer, ci direct in framebuffer-ul default (cel al ferestrei grafice) sau în altul pregatit pentru postprocesare. Se combină culoarea pixelului cu iluminarea calculată și cu lumina ambientală. |
| - | O suprafață de translație este o suprafață generată prin instanțierea unui obiect generator. Fiecare instanță a generatorului suferă o transformare de translație. O suprafață de translație poate fi definită prin instanțierea unui generator cu fiecare instanță translatată progresiv dupa o funcție. | + | {{:pgapi:laboratoare:deferred.png?735|}} |
| - | Un exemplu de suprafață translatată este: | ||
| - | {{ :pgapi:laboratoare:suprafata_translatie.png?nolink |}} | + | ==== Avantaje ==== |
| + | - Desenarea informațiilor geometrice este eficientă deoarece nu se fac calcule de iluminare. Astfel se determină rapid pixelii cei mai apropiați de observator. | ||
| + | - Pentru sursele de lumină de intensitate mică se vor realiza calculele de iluminare într-o zonă restrânsă pe ecran. Astfel se evită calcularea contribuției fiecărei surse de lumină pentru fiecare pixel de pe ecran. | ||
| + | - Extensibilitatea, facilitează compoziția cu diverse etape de postprocesare ale informațiilor vizuale(de exemplu detecția contururilor folosind textura de normale și/sau textura de adâncime; efecte de bloom sau strălucire etc.) | ||
| + | - Nu mai este necesară scrierea de fragment shadere care să primească ca variabile de tip uniform o listă cu sursele de lumină. În pasul de iluminare pentru fiecare sursă de lumină se folosește un shader care tratează doar acea sursă de lumină. | ||
| + | - Având N obiecte și L surse de lumină complexitatea tehnicii deferred este O(N + L), în timp ce complexitatea forward rendering este O(N * L). De ce? Se separă buclele iterative peste mulțimea de lumini si mulțimea de obiecte din scenă: | ||
| - | ===== Suprafețe de rotație ===== | + | Forward: |
| + | for (obiect in obiecte): | ||
| + | for (lumina in lumini): | ||
| + | calculeaza_iluminarea(lumina, obiect) | ||
| - | O suprafață de rotație este o suprafață generată prin instanțierea unui obiect generator. Fiecare instanță a generatorului suferă o transformare de rotație. Aceasta poate fi definită prin instanțierea unui generator cu fiecare instanță rotită progresiv dupa o funcție. | + | Deferred: |
| + | for (obiect in obiecte): | ||
| + | deseneaza(obiect, Gbuffer) | ||
| + | for (lumina in lumini): | ||
| + | deseneaza(lumina) | ||
| - | {{ :pgapi:laboratoare:suprafata_rotatie.png?nolink |}} | + | ==== Dezavantaje ==== |
| + | |||
| + | - Complexitatea algoritmului poate fi dezavantajoasă dacă sunt puține surse de lumină în scenă | ||
| + | - Nu se pot folosi metode de netezire a muchiilor folosind accelerație hardware ([[https://www.khronos.org/opengl/wiki/Multisampling#Multisampling| multisampling]]). În schimb se pot folosi soluții de sinteză avansată de anti-aliasing, precum SSAA, MSAA, FXAA(foarte rapid), TAA, etc. | ||
| + | - Pentru fiecare informație a suprafeței necesară calculelor de iluminare este necesară adăugarea acestora în G-Buffer pentru fiecare pixel pe ecran. Astfel, se încarcă memoria procesorului grafic. | ||
| + | - Din cauză că deferred rendering se bazează pe faptul că un singur obiect va fi vizibil per pixel, algoritmul funcționează cât timp obiectele din scenă sunt opace. Obiectele transparente trebuie desenate în alt mod. | ||
| - | <del><del>===== Curbe și suprafețe de formă liberă ===== | + | ==== Cerințe laborator ==== |
| - | + | ||
| - | Curbele și suprafețele de formă liberă sunt generate plecând de la niște puncte de control și generând alte puncte pe baza acestor puncte de control, care apoi sunt legate prin topologie pentru a crea suprafața. Există mai multe tipuri de curbe de control: Hermite, Bezier, etc. Dacă folosim câte o curbă de control pentru fiecare dimensiune, obținem metode de generare de suprafețe (petice), de volume sau de forme multidimensionale. În acest laborator vom lucra cu o curba de control Bezier, dar vom descrie pe scurt și un petic Bezier. | + | |
| - | + | ||
| - | <del>Formal, o curbă Bezier este construită pe baza a N puncte, numite puncte de control. Ecuația unui punct generat, pe baza acestor puncte de control, este:</del> | + | |
| - | + | ||
| - | {{ :pgapi:laboratoare:formula bezier 1.png?nolink |}} | + | |
| - | + | ||
| - | Unde B(t) este noul punct generat, iar t reprezint distanța parametrică între primul punct de control și ultimul punct de control. | + | |
| - | + | ||
| - | În cazul comun, în care N = 4, ecuația devine: | + | |
| - | + | ||
| - | {{ :pgapi:laboratoare:formula bezier 2.png?nolink |}} | + | |
| - | + | ||
| - | O reprezentare vizuală a procesului de generare de puncte pe baza punctelor de control: | + | |
| - | + | ||
| - | {{ :pgapi:laboratoare:bezier.png?nolink |}} | + | |
| - | + | ||
| - | unde punctele albe sunt punctele de control, iar punctele roșii sunt cele generate. | + | |
| - | + | ||
| - | <del>Procesul poate fi extins cu ușurință la 2 dimensiuni prin utilizarea unei petic Bezier. În cazul particular, dar comun al unui petic cu 16 puncte (4x4), acesta poate arăta astfel: | + | |
| - | + | ||
| - | {{ :pgapi:laboratoare:bezier_suprafata.png?nolink |}} | + | |
| - | + | ||
| - | <hidden> | + | |
| - | ===Ce inseamnă, de fapt, din punct de vedere geometric, o curbă Bezier? === | + | |
| - | În imaginea alaturată putem observa cum toate segementele P0P1, P1P2, P2P3, A1A2, A2A3 si B1B2 sunt taiate la un t% predefinit. Acesta este t-ul din ecuatia de interpolare liniara. Astfel A1 este interpolarea liniara intre P0 si P1, A2 intre P1 si P2, B1 intre A2 si A1, samd. Punctul final C este rezultatul acestui sir de interpolari. Daca as avea N segmente de control, procesul de determinare al punctului de pe curba ar include N-1 + N-2 + N-3 + …. +2+ 1 interpolari. Acelasi proces este aplicabil pentru toate familiile de curbe, singurele diferente fiind ca nu se mai interpoleaza doar dupa pozitie, adica operatia de interpolare este mai complicata (include tangente, directii, unghiuri, etc). | + | |
| - | + | ||
| - | {{ :pgapi:laboratoare:capture.png?nolink&800 |}} | + | |
| - | + | ||
| - | ? | + | |
| - | {{ :pgapi:laboratoare:bezier_explicatii.png?nolink |}} | + | |
| - | </hidden> | + | |
| - | + | ||
| - | </del><del>Strike-through Text</del></del></del> | + | |
| - | ===== Cerințe laborator ==== | + | |
| - | + | ||
| - | <note tip> | + | |
| - | Prin utilizarea tastelor **1**, **2**, **3** și **4**, împreună cu combinația acestora cu tastele **SHIFT** și **CTRL**, puteți controla poziția celor 4 puncte de control ale curbei Bézier. | + | |
| - | </note> | + | |
| - | + | ||
| - | <note important> | + | |
| - | * În laborator, geometria suport pentru curbă este deja definită. Există două tipuri de instanțieri: | + | |
| - | * Instanțierea implicită, facută cu comanda glDrawElementsInstanced, care este deja implementată și care generează geometria suport de N ori | + | |
| - | * Instanțierea explicită, care va fi implementată în geometry shader. | + | |
| - | * //Geometria suport trimisă către shader este o linie, ce leagă primul și ultimul punct de control.// Punctele de control sunt accesabile în geometry shader sub numele ''control_p1'', ''control_p2'', ''control_p3'', ''control_p4''. | + | |
| - | </note> | + | |
| - Descărcați [[https://github.com/UPB-Graphics/gfx-framework|framework-ul de laborator]] | - Descărcați [[https://github.com/UPB-Graphics/gfx-framework|framework-ul de laborator]] | ||
| - | - Trimiteți către shader numărul de puncte generate pe o curbă bezier (''no_of_generated_points'') și controlați de la tastatură atât acest număr (''no_of_generated_points''), cât și numărul de instanțe (''no_of_instances''). | + | - Completați în metoda ''Init'', atribuirea pentru fiecare din cele 40 de surse de lumină din scenă a unei poziții, a unei raze și a unei culori alese aleatoriu. |
| - | - Modificați fișierul ''GeometryShader.glsl'' pentru a desena o curbă Bézier pe baza a 4 puncte de control. | + | - Pentru fiecare sursă de lumină, desenați o sferă la poziția ei, cu o rază egală cu dublul razei de influență a acesteia. Setați variabilele ''light_position'', ''light_color'' și ''light_radius'', de tipul uniform, cu informațiile sursei de lumină. |
| - | * Desenați o bandă de linii, pe baza tipului de geometrie de ieșire ''line_strip'', prin emiterea mai multor vârfuri ale căror poziții se obțin prin eșantionarea curbei Bézier. | + | - În fișierul ''LightPass.FS.glsl'' eșantionați texturile din G-buffer și folosiți metoda PhongLight pentru a calcula influența sursei de lumină ce va fi acumulată. |
| - | * Permiteți modificarea de la tastatură a numărului de vârfuri ce descriu banda de linii. Acest număr trebuie să poată fi scăzut și crescut. | + | - Completați în fișierul ''Composition.FS.glsl'', calculul de compoziție între culoarea obiectelor și influența luminilor asupra obiectelor. |
| - | * După acest pas, rezultatul pe care ar trebui să îl obțineti este următorul: \\ {{ :ppbg:laboratoare:bezier-animation.gif?600 |}} | + | - Realizați o animație de orbitare a surselor de lumină. Orbita pentru fiecare sursă de lumină este în jurul centrului scenei față de axa Oy. |
| - | - Modificați fisierul ''GeometryShader.glsl'' pentru a desena o suprafață de translație, pe baza curbei Bézier obținute anterior. | + | |
| - | * Desenați o bandă de triunghiuri, pe baza tipului de geometrie de ieșire ''triangle_strip'', prin emiterea mai multor vârfuri ale caror poziții se obțin prin eșantionarea a două curbe Bézier, alăturate. | + | |
| - | * Utilizați atributul de intrare ''instance'' pentru a translata banda desenata pe baza numarului de ordine al instanței desenate. | + | |
| - | * Permiteți modificarea de la tastatură a numărului de benzi desenate. Acest număr trebuie să poată fi scăzut și crescut. | + | |
| - | * După acest pas, rezultatul pe care ar trebui să îl obțineti este următorul: \\ {{ :ppbg:laboratoare:translation-surface-animation.gif?600 |}} | + | |
| - | - Modificați fișierul ''GeometryShader.glsl'' pentru a desena o suprafață de rotație, pe baza curbei Bézier obținute anterior. | + | |
| - | * Desenați o bandă de triunghiuri, pe baza tipului de geometrie de ieșire ''triangle_strip'', prin emiterea mai multor vârfuri ale căror poziții se obțin prin eșantionarea a două curbe Bézier, alăturate. | + | |
| - | * Utilizați atributul de intrare ''instance'' pentru a roti banda desenată pe baza numărului de ordine al instanței desenate. | + | |
| - | * Permiteți modificarea de la tastatură a numărului de benzi desenate. Acest număr trebuie să poată fi scăzut și crescut. | + | |
| - | * Permiteți modificarea de la tastatură a tipului de suprafață ce se desenează: suprafață de translație și de rotație. | + | |
| - | * După acest pas, rezultatul pe care ar trebui să îl obțineti este următorul: \\ {{ :ppbg:laboratoare:rotation-surface-animation.gif?600 |}} | + | |
| - | + | ||
| - | <hidden> | + | |
| - | * Geometria suport trimisă către shader este o linie, ce leagă primul și ultimul punct de control. Punctele de control sunt accesabile în geometry shader sub numele control_p1, control_p2, control_p3, control_p4. | + | |
| - | - Trimiteți către shader numărul de puncte generate pe o curbă bezier (no_of_generated_points) și controlați de la tastatură atât acest număr (no_of_generated_points), cât și numărul de instanțe (no_of_instances). | + | |
| - | - Geometria suport va fi în primul rând folosită pentru a genera o curbă de tip Bezier. Pentru acest lucru se vor genera de mână în geometry shader mai multe puncte (no_of_generated_points) pentru care se va evalua curba Bezier. | + | |
| - | - Se vor genera instanțe deplasate ale curbei bezier folosind translații sau rotații | + | |
| - | - Pentru două curbe adiacente, se vor genera triunghiuri, ce vor lega geometria generată a instanței curente de geometria generată a instanței următoare, generată prin translație sau rotație (practic se vor lega cate 2 triunghiuri pentru fiecare 2 puncte corespondente de pe 2 curbe - vedeți figura de mai jos). Astfel, plecând de la curbe Bezier, se va crea o suprafață. Modificați output-ul GeometryShader-ului astfel încât să trimita mai departe triangle_strip pentru a procesa corect triunghiurile. | + | |
| - | + | ||
| - | {{ :pgapi:laboratoare:triunghiuri_curbe.png |}} | + | |
| - | </hidden> | + | |
