Grafica Real-Time, Hardware Grafico e Linguaggi di Shading. Alessandro Martinelli

Transcript

1 Grafica Real-Time, Hardware Grafico e Linguaggi di Shading Alessandro Martinelli

2 Grafica Real Time Il concetto di 'Real Time' in ambito grafico ha una valenza molto particolare: Fino agli anni '80, solo un grafica semplificata con prestazioni in tempo reale Successivamente: un nuovo ambito applicativo con principi, strumenti, e tecnologie distinte dagli altri ambiti della grafica tridimensionale. Si distingue per lo sviluppo della tecnologia delle schede grafiche

3 Mesh Indicizzate continua... Tre elenchi*,** v : vertice vn: vettore 'Normale' Associata al Vertice f: faccia, una lista di indici v/vn che identificano un poligono irregolare nello spazio v : 0.00,0.00,0.00 v : 1.00,0.00,0.00 v : 1.00,1.00,0.00 v : 0.00,1.00,0.00 [ ] vn : 0.00,0.00,-1.00 vn : 0.00,-1.00,0.00 vn : -1.00,0.00,0.00 [ ] f : 1/1,2/1,3/1,4/1 f : 1/2,2/2,5/2,6/2 [ ] (*specifiche formato.obj) Insieme di Poligoni irregolari nello spazio che rappresentano la superficie di un oggetto. ** Quattro, se si tiene conto delle coordinate textures

4 Mesh Indicizzate: visualizzazione Processo di visualizzazione: (1) Trasformazioni di coordinate: coordinate 3D coordinate schermo (2) Modelli di illuminazione semplici (i.e. Luci Puntiformi, assenza di ombre, la normale vn identifica il piano tangente alla superficie in v) 1 colore per ogni vertice Facce con più di 3 vertici tassellate in triangoli (3) Per ogni triangolo : digitalizzazione (Scan-Line) con interpolazione lineare dei colori ai vertici (Gouraud Shading) e determinazione delle relazioni di profondità (Z-buffering) (2) (3) (1) (2) (3) (1)

5 Scan-Line (1/2) Principale algoritmo di Digitalizzazione, cioè di produzione dell'elenco di pixel in cui è presente la proiezione di una certa geometria Determino il minimo e il massimo valore y della geometria Con passo '1 pixel' semplifico il problema ad un problema monodimensionale

6 Scan-Line (2/2) Durante il processo di Digitalizzazione troverò probabilmente dei triangoli sovrapposti. Come devo gestirli?

7 Algoritmo del Pittore Disegno gli oggetti in ordine (come un pittore: dallo sfondo al primo piano). Gli oggetti si sovrappongono.

8 Algoritmo dello Z-Buffer (1/4) Usa una matrice di profondità Z-buffer (o Depth-Buffer) delle stesse dimensioni dell immagine da elaborare. Ogni pixel nello Z-buffer contiene il valore z dell ultimo pixel disegnato in quella posizione. Per disegnare ancora in quella posizione devo superare un test sul valore di z: se il nuovo valore di z è più basso il frammento di superficie sta di fronte e sovrascrive i dati precedenti. Il risultato consente di evidenziare le intersezioni fra oggetti.

9 Algoritmo dello Z-Buffer (2/4)

10 Algoritmo dello Z-Buffer (3/4) a) Situazione iniziale dell immagine e dello z-buffer b) Arriva un nuovo frammento in (x,y); il valore di z già presente nello z-buffer è inferiore al nuovo valore proposto. Quindi il nuovo frammento sta dietro a quello precedentemente inserito (di cui ignoro l'origine) e viene scartato. c) Il nuovo frammento in (x,y+1) passa il test dello z-buffer ( la sua z è inferiore a quella già presente nel depth-buffer) e sovrascrive sia l immagine che lo z-buffer ( il nuovo frammento sostituisce completamente quello vecchio ) d) Analogo al caso (c)

11 Algoritmo dello Z-Buffer (4/4)

12 GPU: Graphics Processing Unit (1/2) All'interno di una tipica applicazione grafica in tempo reale, il processo di visualizzazione è relegato ai moduli di rendering della scheda grafica. L'applicativo grafico si occupa per lo più dell'organizzazione e trasferimento dei dati.

13 GPU: Graphics Processing Unit (2/2) Una GPU è una unità elettronica che implementa, tramite una struttura a pipeline, il processo di visualizzazione già presentato: Pipeline dei Vertici: trasformazioni di coordinate, colore ai vertici Ricostruttore delle geometrie: determinazione dei triangoli Modulo di Scan-Line: Digitalizzazione Scan-Line e Gouraud Shading Pipeline dei Frammenti: operazioni prebuffer Manager Buffer Manager: Z Buffering et. al. NOTA Frammento: struttura dati contenente informazioni relative ad un pixel, ma ancora da elaborare

14 GPU: parallelismo Il motivo per cui una scheda grafica giunge ad un elevato livello di prestazioni è legato al Parallelismo: Il parallelismo è insito nella struttura a Pipeline Il parallelismo è possibile perché la maggior parte delle operazioni della GPU possono essere eseguite in parallelo su set di dati differenti. Ad esempio: Elaborare i dati di vertici diversi in parallelo Elaborare i dati di frammenti diversi in parallelo Digitalizzare triangoli diversi in parallelo

15 GPU: performance ed utilizzo Il processore controlla la Scheda Grafica I dati vengono forniti alla GPU dal processore che controlla il processo grafico (attraverso API di programmazione Grafica) Il canale di comunicazione è tipicamente un BUS Il sistema Processore>Bus>GPU può essere considerato come un sistema di moduli in serie: E' possibile identificare un collo di bottiglia, che il più delle volte è rappresentato dalla CPU o dal BUS di comunicazione La GPU è tipicamente il modulo ad utilizzo inferiore.

16 GPU: strutture di memoria Una GPU offre una memoria interna che può essere sfruttata per allocare informazioni: Display List Buffer Objects Textures Image-Buffers Esistono molti modi di accedere/caricare queste risorse Image-Buffers/Textures Streaming Process ecc.

17 GPU Programmabili Le unità programmabili consentono la riprogrammazione di alcuni comportamenti della pipeline standard Restano invariati i moduli di ScanLine ed il Buffer Manager, mentre i moduli restanti sono di fatto completamente personalizzabili.

18 GPU Programmabili: Nuove Unità L unità di Vertex Shader sostituisce le funzionalità fisse relative alla elaborazione delle informazioni su base vertice: trasformazioni, illuminazione, gestione delle coordinate texture L unità di Fragment/Pixel Shader sostituisce le funzionalità fisse sull elaborazione dei frammenti Il Geometry Shader aggiunge un grado di flessibilità rispetto alla pipeline standard perchè consente la manipolazione di nuove geometrie Queste unità sono programmabili dall utente : è dunque possibile descrivere COME i vertici, i frammenti e le geometrie devono essere elaborati durante il rendering I linguaggi che consente di programmare queste funzionalità si chiamano linguaggi di shading.

19 Vertex Shader (1/2) Sostituisce completamente queste fasi della pipeline di Rendering: Trasformazioni di coordinate Illuminazione L'input del Vertex Shader è l'insieme di informazioni che caratterizzano un singolo vertice in ingresso alla pipeline L'output del Vertex Shader è l'insieme di informazioni orientate al vertice e pronte per essere spedite alla fase di rasterizzazione

20 Vertex Shader (2/2) Il Vertex Shader può Cambiare la posizione dei punti (Trasformarli anche secondo metodi diversi dalle classiche trasformazioni di coordinate) Colorare/Illuminare con formule speciali i punti ( applicare modelli di illuminazione più complessi ) Ecc. Il Vertex Shader non può Creare o Eliminare vertici ( cioè non consente la generazione di geometrie non-previste )

21 Fragment Shader (1/2) Sostituisce completamente queste fasi della pipeline di Rendering: Lettura delle texture Miscelazione dei colori Nebbia ecc. L'input del Fragment Shader è il frammento, che viene generato dal rasterizzatore tramite l'algoritmo di scan-line L'output del Fragment Shader sono il colore, la profondità e la posizione sull'immagine di un pixel

22 Fragment Shader (2/2) Il fragment Shader può: Leggere anche più textures con formule scelte a piacere Calcolare Texture procedurali Elaborare il valore di una texture letto Spostare pixel Eliminare Frammenti Il fragment Shader non può: Generare nuovi texel

23 Geometry Shader Introdotto recentemente (2006) Si affianca alla fase di ricostruzione delle geometrie. L'input del Geometry Shader è la primitiva geometrica (es. triangolo), che viene ricomposta dal modulo di ricostruzione delle geometrie. L'output del Geometry Shader sono ulteriori geometrie; l'output non può superare in quantitativo prefissato di informazione (in byte)dipendente dall'architettura.

24 Linguaggi di Shading I linguaggi di shading disponibili sono: HLSL ( High Level Shading Language ): linguaggio di shading di riferimento per le API DirectX GLSL ( Graphics Library Shading Language): linguaggio di shading di riferimento per OpenGL Esistono anche versioni di questi linguaggi 'a basso livello' con una programmazione simile ad un assembler vettoriale I linguaggi di shading sono vettoriali: Definiscono operazioni tra vettori di 1,2 3 o 4 elementi Somme, prodotti e sottrazioni sono sempre operazioni componente per componente su vettori della stessa lunghezza ( quindi è molto importante rispettare il comportamento delle lunghezze) Sono disponibili condizionali e cicli, ma i cicli devono ciclare un numero determinato di volte perchè il codice in fase di compilazione viene completamente srotolato (come se i cicli non ci fossero)

25 Tipologie di Variabili Le variabili possono essere Registri di Linguaggio non modificabili Registri temporanei Variabili Uniformi Variabili 'Varying'

26 Registri I registri non modificabili sono variabili predefinite dal linguaggio di shading che contengono informazioni in input o variabili di stato della pipeline di rendering. Ad esempio: gl_vertex è il vertici in ingresso al vertex shader. gl_position è l'output del Vertex Shader gl_color è il colore in input al fragment shader I Registri temporanei sono variabili che l'utente può dichiarare ed utilizzare liberamente all'interno del programma di shading

27 Variabili Uniformi Le variabili uniformi sono come i registri non modificabili, ma possono essere definiti dal programmatore. Le variabili uniformi consentono di definire delle variabili di stato personalizzate da passare ai linguaggi di shading Le variabili uniformi sono: Visibili sia dal Vertex che dal Fragment Shader Identificate attraverso il loro nome Solamente leggibili

28 Variabili Varying Le Varying rappresentano variabili generiche che devono essere interpolate all'interno del rasterizzatore. Per questo le variabili varying: Sono visibili in tutti gli shader Non possono essere lette ma solo scritte nel Vertex Shader che le produce: sono in effetti variabili di output del Vertex Shader Una volta prodotte dal Vertex Shader, il rasterizzatore le digitalizzerà per interpolazione come gli altri valori standard ( coordinate texture, colori, profondità z ecc. ) Il fragment shader può solamente leggerle: sono in effetti variabili di input del Fragment Shader

29 Esempio 1 ####V e rte x S h a de r vo id m a in (vo id){ g l_p o s it io n = g l_mo de lv ie w P ro je c tio n Ma trix * g l_v e rte x ; g l_f ro n t C o lo r = g l_c o lo r; g l_t e x C o o rd[0 ]=g l_mu ltite x C o o rd0 ; } ####F ra g m e n t S h a de r vo id m a in (vo id){ g l_f ra g C o lo r = g l_c o lo r * ve c 4 (1,0.5,0.5,1 ); }

30 Esempio 2 : Phong Shading Alternativo al Gouraud Shading: anziché calcolare il colore di illuminazione ai vertici, si interpolano le normali e si calcola il valore di illuminazione pixel per pixel lungo la superficie. Usa variabili varying per descrivere il vettore normale

31 Esempio 2 : Phong Shading ####V e rte x S h a de r u n ifo rm ve c 3 lig h tp o s 0 ; v a ry in g ve c 3 N,L ; vo id m a in (vo id ) { g l_p o s itio n = g l_mo de lv ie w P ro je c tio n Ma trix * g l_v e rte x ; N = n o rm a lize (g l_n o rm a lma trix * g l_n o rm a l); ve c 4 V = g l_mo d e lv ie w Ma trix * g l_v e rte x ; L = n o rm a lize (lig h tp o s 0 - V.x y z); g l_f ro n tc o lo r = g l_c o lo r; } ####F ra g m e n t S h a de r v a ry in g ve c 3 N,L ; vo id m a in (vo id ){ flo a t N d o tl = do t(n, L ); g l_f ra g C o lo r = g l_c o lo r * ve c 4 (m a x (0.0, N do tl )); }

32 Esempio 3 : Filtri Immagine

33 Esempio 3 : Filtri Immagine u n ifo rm s a m p le r2 D s a m ple r0 ; void main(void) { vec4 steps=vec4( , ,1,1); vec3 A = vec3(-2,-2,-2);vec3 B = vec3(0.333,0.333,0.333);vec3 C = vec3(-2,-2,-2); vec3 D = vec3(-2,-2,-2);vec3 E = vec3(0.333,0.333,0.333);vec3 F = vec3(2,2,2); vec3 G = vec3(2,2,2);vec3 H = vec3(0.333,0.333,0.333);vec3 I = vec3(2,2,2); vec3 weight=vec3(1,1,1); vec2 coord=gl_texcoord[0].xy; A=(texture2D(sampler0,coord+vec2(-steps.x,-steps.y)).xyz * A); B=(texture2D(sampler0,coord+vec2(0,-steps.y)).xyz * B); C=(texture2D(sampler0,coord+vec2(steps.x,-steps.y)).xyz * C); D=(texture2D(sampler0,coord+vec2(-steps.x,0)).xyz * D); E=(texture2D(sampler0,coord+vec2(0,0)).xyz * E); F=(texture2D(sampler0,coord+vec2(steps.x,0)).xyz * F); G=(texture2D(sampler0,coord+vec2(-steps.x,steps.y)).xyz * G); H=(texture2D(sampler0,coord+vec2(0,steps.y)).xyz * H); I=(texture2D(sampler0,coord+vec2(steps.x,steps.y)).xyz * I); weight=weight*(a+b+c+d+e+f+g+h+i); gl_fragcolor = vec4(weight,1); }

34 Esempio 4 : Geometrie Procedurali

35 Esempio 4 : Geometrie Procedurali ### V e rte x S h a de r v a ry in g ve c 3 v a lu e ; vo id m a in (vo id ) { ve c 3 po s itio n =ve c 3 (0.5 *c o s (g l_v e rte x.x ),0.5 *s in (g l_v e rte x.x ),0 ); g l_p o s itio n = g l_mo de lv ie w P ro je c tio n Ma trix * ve c 4 (po s itio n,1 ); g l_f ro n tc o lo r = g l_c o lo r; v a lu e =(p o s itio n +ve c 3 (1,1,1 ))*ve c 3 (0.5,0.5,0.5 ); } ###F ra g m e n t S h a d e r v a ry in g ve c 3 v a lu e ; vo id m a in (vo id ) { g l_f ra g C o lo r = g l_c o lo r * ve c 4 (v a lu e,1 ); }

36 General Purpose GPU Programming La nascita dei linguaggi di shading introduce un nuovo punto di vista: L'architettura della GPU presenta moduli riprogrammabili funzionanti in parallelo. I linguaggi di shading si evolvono per assomigliare sempre di più a comuni e completi linguaggi di programmazione. Le strutture di Memoria possono essere utilizzate per fornire dati alle procedure Esistono metodo per il recupero in CPU delle informazioni elaborate dalla scheda grafica Tutto questo suggerisce di utilizzare la GPU come generico strumento per la programmazione parallela.

37 General Purpose GPU Programming Applicazioni: Calcoli matriciali con matrici molto grandi Filtri immagine Metodi Montecarlo In generale: Algoritmi che operano molti task con poche operazioni in parallelo Utilizzo tipico (ma non unico): Tracciare un grande rettangolo a 'tutta immagine' ed eseguire l'elaborazione nel fragment shader

38 Un caso: GeForce moduli scalari sincronizzati per operare come uno qualsiasi dei moduli riprogrammabili Supporto di molti linguaggi di shading: GLSL HLSL Nvidia CG Supporto di funzionalità aggiuntive per il controllo del flusso dei dati della pipeline Programmazione CUDA per la programmazione generica