Corso di Realtà Virtualepercro.sssup.it/marcello/didattica/AA2013/8_LightingShading.pdfEsatto (non real-time) Campionamento dei colori risultanti Un metodo ibrido consiste nel campionare

Realtà Virtuale: il presente, il passato, il futuroLighting e Shading

Lighting


Illuminazione

Determinare le caratteristiche della luce

che arriva da un punto della scena

all’occhio di chi la osserva

Problema computazionalmente oneroso

Fenomeni fisici correlati:


Illuminazione globale e locale

Illuminazione globale

Illuminazione diretta e indiretta

Riflessione Multipla

Rifrazione

Ombre

Illuminazione locale

Solo illuminazione diretta

No Riflessione Multipla

No Rifrazione

Ombre possibili


Equazione di Rendering

Descrive il flusso dell’energia luminosa in una scena. Basata sulla conservazione dell’energia.

La luce uscente da un punto x nella direzione ωo

è pari alla somma della luce emessa in quella direzione e della luce riflessa, nella stessa direzione1:

La luce emessa è zero, se il punto non è una sorgente di luce.

La “radianza” dà un’idea della quantità di luce che viaggia in una certa direzione. Il rendering può essere visto come il calcolo delle radianze lungo i raggi diretti verso il punto di vista e passanti per i pixel.

o o o

1 per tacer della trasmessa



La radianza uscente da x in direzione ωo è dunque

esprimibile come somma della componente “emessa” e della

risultante di tutte le componenti

“riflesse” da ogni direzione

BRDFBi-directional Reflectance Distribution Function

Descrive le proprietà ottiche di un materiale:

misura la frazione di energia luminosa entrante

In x dalla direzione ωi e riflessa in direzione ωo

Ω(n)Semisfera di tutte le possibili ωi entranti in x, centrata attorno a n

Li

Radianza entrante nella direzione ωi

Ω(n)



Perché il coseno?

Attorno a x, il contributo all’energia luminosa proveniente dalle varie

direzioni non è uniforme...

Intuitivamente:

l’area dell’intersezione tra un raggio e la superficie è minima sulla direzione normale, dunque l’energia

per unità di superficie dipende dal coseno dell’angolo tra la direzione del raggio e la normale.

Se il raggio è “sghembo” l’energia si disperde, se è “dritto” si concentra maggiormente su X.

n

i

θ

A

A

)ωncos(

AdS

i

dSn

dS

x


BRDF... belle ma pesanti! Vogliamo dei modelli di illuminazione più semplici,

veloci da calcolare, che diano risultati visivi soddisfacenti

Vettori in gioco:

Metodo di Phong (usato dalla pipeline statica di OpenGL)

Illuminazione locale: Phong

(da Wikipedia)

LUCIN SPCODIFOAMBOeReO LLLvLvLvLvL

_ ___ )()(x,)(x,)(x,)(x,

http://it.wikipedia.org/wiki/Immagine:Phong_components_version_4.png


Phong: Componente ambiente

Illuminazione locale: NO illuminazione indiretta

Nella realtà c’è una gran quantità di luce indiretta

Se una superficie non “vede” alcuna luce, sarà

renderizzata come nera

Teniamo conto della quantità

di luce “globalmente presente”

nell’ambiente, che arriva ad

un oggetto da tutte le direzioni,

con una costante: La (è una

radianza).

ka: costante che dipende dall’oggetto

aaAMBR LkvL )(x,_

LUCIN SPCRDIFRAMBReReO LLLvLvLvLvL

_ ___ )()(x,)(x,)(x,)(x,


Molti materiali appaiono ugualmente illuminati da qualsiasi direzione li si

guardi

Questo vuol dire che la luce è riflessa uniformemente in tutte le direzioni

Questo tipo di riflessione è nota come lambertiana

In questo caso per ogni ωi (e in particolare per ωi = l) la BRDF è costante,

e dunque abbiamo:

per un contributo finale (vedi eq. di rendering)

quantificabile in:

Phong: Componente diffusa


_ ___ )()(x,)(x,)(x,)(x,

),cos(),(_ lnLKvL ddDIFR

x


Componente speculare - Phong

Materiali con comportamento speculare

Da considerazioni empiriche, Phong ha proposto di utilizzare come

componente speculare:

dove rL è il raggio speculare a l rispetto a n


_ ___ )()(x,)(x,)(x,)(x,

sn

LSSSPCR vrLKvL ),cos(),(_

x

lnnlrL

)(2 Lr

n


Componente speculare - Phong

Il risultato è plausibile

nS: shininess


Modello di lighting di Phong

Riassumendo e compattando:

Ka, Kd, Ks, ns: caratteristiche dei materiali

La, Ld, Ls: caratteristiche della sorgente

luminosa

Solitamente sono espressi come terne RGB,

ad eccezione della shininess (scalare)

LUCIN

n

LssddaaRsrvLKlnLKLKL

_)()(


Illuminazione globale: Ray Tracing

E’ uno dei più famosi metodi di illuminazione globale

Per ogni pixel si traccia un raggio congiungente il pixel e il viewpoint

Ogni raggio è prolungato in tutto il view volume e se ne testa l’intersezione con gli oggetti in esso contenuti: se ve ne sono multiple, si sceglie quella con l’oggetto più vicino

Raggi primari: partono dal viewpoint

Raggi secondari: partono dalle intersezioni tra raggi primari e oggetti

Perché riflessi (materiale riflettente)

Perchè trasmessi-rifratti (materiale trasparenti)

Perché proiettano ombra

Il Ray-Tracing permette dunque di modellare riflessioni, trasparenze e ombre portate (shadow casting)

Performance scarse, esistonoimplementazioni real-time (es.Recente NVIDIA Optix su GPU)

Viewplane

Viewpoint


Illuminazione globale: Photon Mapping

Algoritmo in due passi per risolvere l’equazione di rendering

Si simula l’emissione di N fotoni da parte delle sorgenti di luce verso gli oggetti della scena. All’intersezione con una superficie, il punto di intersezione e la direzione sono memorizzate in una mappa (photon map)

Dopo la collisione, con probabilità dipendente dal tipo del materiale il fotone viene riflesso, assorbito o rifratto/trasmesso. Se riflesso(o rifratto) la nuova direzione viene stabilita tramite la BRDF, altrimenti il fotone “muore”.

Nel secondo passo (di rendering) si usa la photon map per un calcolo approssimato delle radianze di ogni pixel secondo questo schema: illuminazione diretta, speculare, caustica, indiretta “soft” (esistono varianti per il calcolo di ognuna di queste)

Trade-off su N per fotorealismo/velocità

Esistono implementazioni real-time che fanno uso della GPU

No fotoni Photon map 1000 fotoni 6000 fotoni


Illuminazione globale: real-time

Le tecniche di illuminazione globale sono solitamente molto

onerose e richiedono alti tempi di rendering (fino ad oggi…)

Se le condizioni di illuminazione sono statiche è però possibile

conservare le informazioni sull’illuminazione, ricavate da

rendering anche complessi, e riutilizzarle in futuro.

Senza scendere troppo nei dettagli, ci sono due possibilità:

Memorizzare le info sull’illuminazione come per-vertex-color, su

mesh più complesse di quelle di partenza (tipico delle soluzioni

radiosity)

Memorizzarle su texture che vengono poi combinate con le altre

texture originariamente presenti nel modello (lightmaps)

Svantaggi:

Le riflessioni speculari non possono essere simulate direttamente


Radiosity


Lightmaps


Illuminazione globale: Image Based Lighting

I metodi finora visti:

Calcolo dell’energia luminosa (radianza):

Approssimato

Esatto (non real-time)

Campionamento dei colori risultanti

Un metodo ibrido consiste nel campionare NON i colori, ma le informazioni

sulla radianza da un ambiente vero e memorizzarle in apposite mappe

(radiance map) che vengono poi usate in tempo reale. Tali mappe possono

essere acquisite a diversi livelli di esposizione in modo da coprire il

massimo range possibile della dinamica (High Dynamic Range maps).

Immagine normale:

Bassa dinamica

(rapporto fra la zona

più scura e quella più

chiara)

Immagine HDR:

Alta dinamica


Illuminazione globale: HDR

Per acquisire le mappe HDR si può usare un light probe che

rifletta l’ambiente circostante.

Le mappe possono essere poi mappate su un oggetto fittizio

(IBL environment, es. una sfera o un cubo) che circonda il

VE. L’HW grafico può fare in modo di renderizzare gli

oggetti come se riflettessero effettivamente la luce

ambientale.


Shading


Shading - Normali

Dalla mesh al colore di ogni pixel dell’oggetto sullo schermo.

Ci servono le normali:Normale ad una faccia

Ma sappiamo che spesso la mesh è solo un’approsimazione quindi…..


Shading - Normali

In questo caso possiamo usare le “vere” normali, per vertice

Di solito associate ai vertici e passate alla scheda grafica insieme ad essi

Calcolabili come media delle normali alle facce adiacenti ad un vertice

Per oggetti poligonali, è necessario “sdoppiare” i vertici e passare due diverse normali


Shading - Interpolazione

Date le normali ai vertici, come

colorare l’interno del poligono ?

Flat shading

Gouraud interpolation

Phong interpolation


Shading - Flat

Considera il colore costante sul poligono

Usa la normale alla faccia

Equivalente al campionamento di un solo

punto


Shading - Gouraud

Calcola il colore in ogni vertice

Interpola linearmente i colori


Di default Open GL:1) Prende in input vari attributi per-

vertice (posizione, colore, light source, texture coordinates, etc.)

2) Calcola un colore finale per ogni vertice utilizzando un certo modello di illuminazione (OpenGL usa Phong)

3) Per ogni pixel, interpola linearmente i valori associati ai tre vertici per ottenere il colore del pixel (ad esempio Gouraud shading)

4) Scrive il colore del pixel nel frame buffer

Shading – Gouraud (esempio)


Shading - Gouraud

Problema:

Interpola linearmente i colori ma il

modello di illuminazione non è lineare


Shading - Phong

Interpola le normali, poi calcola il

colore

OK, ma quante normali ?


Shading - Riepilogo

FLAT : cf = f (Nf)

GOURAUD: cvi = f (Nvi)

cv1 cv2 cv3 vengono interpolati trilinearmente sul

triangolo

PHONG: cp = f (Np)

Np è il risultato dell’interpolazione delle Nvi .

L’equazione di illuminazione viene valutata

per ogni pixel (per-pixel-lighting).


Spazi e Trasformazioni

•Ognuno di questi spazi ha delle proprietà utili per certe operazioni

•Gli attributi dei vertici sono specificati in object space

•Il lighting dei vertici avviene tipicamente in eye space

•Il clipping avviene in clip space

•La rasterizzazione avviene in window space

MODELVIEW matrix

object space

eye space

PROJECTION matrix

clip space

Perspective Divide

normalized device coordinates

viewport/depthrange scale & bias

window space


Trasformazione delle normali

Le traslazioni non modificano le normali

x-x

-z

z

x-x

-z

z



In OpenGL (fixed pipeline) il lighting viene

eseguito tipicamente in eye space

Per valutare l’equazione di illuminazione in

eye space, TUTTE le normali devono essere

trasformate da object space in eye space

Le normali però non sono trasformate

utilizzando la matrice di modelview come le

posizioni…



Le rotazioni si applicano alle normali

come ai vertici

x-x

-z

z

x-x

-z

z



Le scalature uniformi sui vertici non

modificano la direzione delle normali:

x-x

-z

z

x-x

-z

z



Le scalature non uniformi modificano la direzione delle normali In modo opposto a come sono modificati i vertici,

ovvero va applicata la matrice inversa di quella applicata ai vertici (Mv)

x-x

-z

z

x-x

-z

z

x-x

-z

z

No!

Ok!

Mv

M-1v



traslazione

posizione normale

T I

rotazione R R

scaling S S-1

Lavoriamo con coordinate omogenee e matrici 4x4



Ricordando che: S-1 = (S-1)T = S-T (matrice diagonale)R = (R-1)T = R-T (matrice ortonormale )

Se la matrice che trasforma un vertice da object ad eye space è (non consideriamo le traslazioni):

Mv = RS

allora (vedi tabella precedente) la matrice che trasforma una normale da object ad eye space è:

Mn = RS-1 = R-TS-T = (RS)-T = Mv-T

ovvero la matrice inversa-trasposta della matrice di modelview


Normali in OpenGL

In OpenGL (e nei tool opengl-based) la corretta

matrice di trasformazione delle normali viene

impostata AUTOMATICAMENTE:

glBegin(GL_QUADS);

glNormal(0.181636,-0.25,0.951057);

glVertex(0.549,-0.756,0.261);

glNormal(0.095492,-0.29389,0.95106);

glVertex(0.288,-0.889,0.261);

glNormal(0.18164,-0.55902,0.80902);

glVertex(0.312,-0.962,0.222);

glNormal(0.34549,-0.47553,0.80902);

glVertex(0.594,-0.818,0.222);

glEnd();

Trasformati con MV

(matrice di ModelView)

Trasformati con MV-T


Attenti alle scalature!

OpenGL dà per scontato che le normali siano unitarie!

Se si effettua una scalatura dei vertici, ciò non accade

più (l’inversa trasposta “scala” le componenti):

SOLUZIONE:

Usare GL_NORMALIZE o GL_RESCALE_NORMALS:

glScale(3.0,3.0,3.0);

glBegin(GL_QUADS);

glNormal3f(0.181636,-0.25,0.951057);

glVertex3f(0.549,-0.756,0.261);

…

glEnd();

Di fatto sono scalate di 1/3 !!!

glEnable(GL_NORMALIZE)

Documents

Corso di Realtà Virtualepercro.sssup.it/marcello/didattica/AA2013/8_LightingShading.pdfEsatto (non real-time) Campionamento dei colori risultanti Un metodo ibrido consiste nel campionare