texture

texture argomenti trattati (cenni...) * texture * bump mapping * procedure OpenGL per le texture

texture un sistema per aumentare il realismo della scena e' nell'uso delle "tessiture" - immagini qualunque in una o due dimensioni che vengono "incollate" sulla superfice dell'oggetto che si vuole rappresentare; qui sopra la texture (ad es. in formato xxx.bmp), a destra l' immagine di due cubi ottenuta con proiezione, su cubi e' stata applicata questa texure

texture le "tessiture" sono immagini qualunque in due dimensioni - che vengono "incollate" sulla superfice dell'oggetto che si vuole rappresentare: procedimento diretto: data un'immagine (texture), per applicare una tessitura ad una primitiva (un triangolo) devo passare dalla texture [ data come una superfice (un'immagine) in coordinate (u,v) ] alla primitiva (faccia) dell'ogetto: i singoli punti della tessitura ("texel") sono riportati, mappati sulla primitiva nello spazio data in coordinate oggetto (colore dei singoli punti) e quindi trasformati (proiettati, normalizzati,..) in coordinate display;

texture il procedimento inverso e' piu' usato: data la texture come immagine dato l'oggetto 3D da rappresentare in 2D, per ogni pixel [xsch,ysch] dello schermo (su cui sono proiettati i punti dell'oggetto a cui voglio applicare la texture) ritorno alle coordinate [x,y,z] dell' oggetto, e quindi alle coordinate [xlato,ylato] di un lato dell' oggetto, e infine passo alle coordinate u,v del punto della tessitura corrispondente;

texture si osservi che l'applicazione della tessitura puo' essere fatta in semi-trasparenza, conservando un colore e un'ombreggiatura: in tal caso si usa anche per la tessitura il fattore Alfa ogni "texel" ha i componenti (R,G,B,A), e l'intensita' di luce ovvero il colore del pixel dell'oggetto e' dato da Ip = a*Itext + b*Ig

texture 1D Tessitura lineare 1D - specifico un array monodimensionale di colori (R,G,B,A) e lo associo ad una "scena" lineare (un segmento di retta, una curva generica) con il procedimento seguente: ColorTex [n] = {(r,g,b,a), (r,g,b,a), (r,g,b,a),...(r,g,b,a)} indici 0 1 2 n coordinate s0=0.0 s1 s2 sn=1.0 corrispondenza x0 =xmin x1 x2 xn =xmax la coordinata s nello spazio tessitura va da 0.0 a 1.0, se s=0.0 uso il colore tex[0], se s=1.0 uso colore tex[n-1] se vi sono pochi colori allora si associa un colore tex[i] a piu' pixel xi,xi+1,..xi+k oppure si usa un'interpolazione lineare tra i due texel piu'vicini.

texture 2D (1,1) La tessitura 2D e' data con un array a 3 indici, cioe' terne di valori (r,g,b) individuate da due indici (u,v) o (xtess,ytess); associo la posizione (0,0) agli indici (0,0) e la posizione (1,1) agli indici (nxt,nyt); (0,0) file MonaLisa.BMP 50x50 pixel, qui sopra ingrandita

texture 2D Tessitura 2D - la tessitura e' data con un array a 3 indici, cioe' terne di valori (r,g,b) individuate da due indici xt,yt o u,v; generalmente si associa la posizione (0,0) agli indici (0,0) e la posizione (1,1) agli indici (nxt,nyt); (1,1) con il procedimento diretto da texture->oggetto->display si presenta il problema che un quadratino della tessitura ( trasformato dalla pipeline grafica oggetto->display ) non si sovrappone ad un quadratino-pixel su schermo, ma ne viene a coprire una parte; (0,0)

texture 2D piu' usato il procedimento inverso, dove si esegue per ogni pixel dello schermo la trasformazione inversa, da pixel a oggetto a texel:

texture 2D piu' usato il procedimento inverso, dove si esegue per ogni pixel dello schermo la trasformazione inversa, da pixel a oggetto a texel: in genere viene presa un' area piu' ampia di un pixel - si estende il pixel di mezzo pixel ad ogni lato - e si ritorna alla texture, dove i punti della texture corrispon-denti alle 9 regioni del pixel "grande" sono pesati con una funzione /\

Una tessitura si puo' applicare all'oggetto tessiture + colori Una tessitura si puo' applicare all'oggetto come un foglio elastico non trasparente che ricopre l'oggetto completamente, oppure come foglio semitrasparente, in modo che i colori della tessitura si mescolano con i colori dell'oggetto (e con le ombre dell'oggetto) (esempio da fare...) vedremo i parametri nelle procedure dell'OpenGL

in una sequenza di immagini un oggetto puo' cambiare dimensione apparente sullo schermo; in tal caso cambia la corrispondenza tra texture e i pixel, si deve applicare la tessitura originale ad una superficie diversa (piu' piccola o piu' grande) si ricorre a texture precalcolate di dimensioni diverse texture : MIP maps

MIP dal termine "multum-in-parvo" (dove texture 2D e mip-maps un oggetto cambia dimensione in esecuzione - in tal caso si deve applicare la tessitura originale ad una superficie di pixel diversa (piu' piccola/ piu' grande); per evitare distorsioni si possono predisporre piu' tessiture "pre-ridotte" e/o pre-aumentate; di solito a multipli di due, ovvero 1/2, 1/4, 1/8, ecc della dimensione originale; ad es. se la tessitura originale era 256x256, allora le tessiture ridotte saranno 128x128, 64x64, 32x32 ecc; queste repliche ridotte (e aumentate) della tessitura sono spesso dette mip-maps, MIP dal termine "multum-in-parvo" (dove multum sta per le repliche della tessitura, e parvo sta per l'oggetto...)

L' openGL ha procedure apposite per il calcolo delle mip-maps ... vedremo tra breve

tessiture, mip-maps e OpenGL segue ora una breve presentazione delle procedure di base per l'uso delle texture disponibili nella libreria OpenGL

libreria OpenGL per le tessiture procedure OpenGL per le tessiture, caso piu' semplice: glTexImage1D ( GL_TEXTURE_1D, 0, GL_RGBA, width, 0, dataFormat, dataType, lineTexArray ); glEnable( GL_TEXTURE_1D); parametri della glTexImage1D : 1) GL_TEXTURE_1D specifica texture monodimensionale 2) zero se non sono previste text-maps multiple (mipmaps) 3) GL_RGBA =4 specifica quali componenti sono usati per il blending, qui 4 valori per colore, RGBA (altri: tre valori=GL_RGB, un solo valore=intensita', ecc.) 4) width = dimensione della texture array = nTexColors = numero colori nel texture pattern, e' una potenza di due=2^n; nota che la dimensione dell'array e' 4*nTexColors;

libreria OpenGL per le tessiture procedure OpenGL per le tessiture: glTexImage1D( GL_TEXTURE_1D, 0, GL_RGBA, width, 0 /*5bordo*/, dataFormat, dataType, lineTexArray ); continua parametri: 5) bordo zero indica niente bordo attorno la tessitura (uno per avere un bordo di un pixel, per fusione con la prossima texture, in tale caso il 4.o param. deve essere 2+2^n 6) dataFormat specifica come sono memorizzati i colori (valori possibili: GL_RGBA, GL_BGRA, GL_RGB, GL_BGR, GL_BLUE, ecc ) 7) dataType tipo colore(GL_INT, GL_UNSIGNED_BYTE, GL_FLOAT,...) 8) lineTexArray --------------------------------------------------------- (*) pag seg

NOTA: in glTexImage1D( GL_TEXTURE_1D, 0, GL_RGBA, width, 0/*5bordo*/, dataFormat, dataType, lineTexArray ); i due parametri della procedura glTexImage1D: dataFormat, e dataType, sono gli stessi usati nella procedura prevista dall' OpenGL per disegnare un blocco di colori direttamente nel frame - buffer, la: glDrawPixels(width, height, dataFormat, dataType, pixMap); con dataFormat = formato colori(GL_RGBA, GL_BGR, GL_BLUE, dataType tipo valore di un colore (GL_INT, GL_FLOAT,...) es: glDrawPixels(128,128, GL_RGB, GL_UNSIGNED_BYTE, colorShape), disegna un pixmap raster direttamente copiando dall'array colorShape nel frame buffer, l'elemento di posizione in basso a sinistra e' copiato nella posizione specificata prima con la funzione glRasterPosXX (dove XX e' ad es. 2i ...)

libreria OpenGL per le tessiture per semplificare il calcolo della mappatura della tessitura nel caso (frequente) di mappatura da rettangolo texture a rettangolo lato di oggetto 3D, si usano le procedure mip-maps: se devo ingrandire la tessitura per coprire un'area grande: glTexParameteri( GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); oppure se devo ridurre l'area della tessitura per mapparla su un'area piu' piccola: GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); per avere il colore dato dall'interpolazione dei pixel piu'vicini invece di GL_NEAREST useremo GL_LINEAR .

libreria OpenGL per le tessiture per il caso 2D useremo glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGBA, texWidth, texHeight, 0, dataFormat, dataType, surfTexArray ); glEnable( GL_TEXTURE_2D); parametri: 1) GL_TEXTURE_2Dspecifica texture BIdimensionale 2) zero == un solo livello, non usati mipmaps 3) GL_RGBA (=4) tipo colore, (GL_RGB, GL_RED,GLBGR,..) 4) texWidth, texHeight della texture pattern, sempre potenza di due=2^n; dimensione del texture array e' 4 * texWidth * texHeight; 5) zero == niente bordo attorno la tessitura 6) dataFormat (GL_RGBA, GL_BGRA, GL_RGB, GL_BGR, GL_BLUE, 7) dataType tipo colore(GL_INT, GL_UNSIGNED_BYTE, GL_FLOAT,...) 8) surfTexArray dove e' memorizzata la texture, prima riga=posizione in basso, ...

libreria OpenGL per le tessiture ... esempio da Hearn & Baker : GLubyte texArray[32][32] [4]; // la tessitura, da specificare ... glTexParameteri( // nota [4] per RGBA, 4 si allinea bene.. GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 32,32, 0, GL_RGBA, GL_UNSIGNED_BYTE, texArray); glEnable( GL_TEXTURE_2D ); // assign full range of texture colors to a quadrilateral: glBegin( GL_QUADS ); glTexCoord2f( 0.0, 0.0 ); glVertex3fv( vertex1 ); // vertici: glTexCoord2f( 1.0, 0.0 ); glVertex3fv( vertex2 ); // 4 3 glTexCoord2f( 1.0, 1.0 ); glVertex3fv( vertex3 ); // 1 2 glTexCoord2f( 0.0, 1.0 ); glVertex3fv( vertex4 ); // glEnd(); glDisable( GL_TEXTURE_2D );

un es. OpenGL per uso tessiture inizializzo una (o piu') tessiture, es. nella init(); chiamo LoadTexture, che fornira' il "nome" (numero) della textr: GLuint tess1 = LoadTexture( ...da file...), dove nella GLuint LoadTexture{ .. GLuint txtr; ... glGenTextures( 1, &txtr); // chiedi a OpenGL un num glBindTexture( GL_TEXTURE_2D, txtr); // poi genera(calcola) oppure leggi da file la tessitura // in una zona di memoria (con l'immagine bitmap), // *data e infine costruisce la texture txtr // qui gluBuild2DMipmaps al posto di glTexImage2D gluBuild2DMipmaps(GL_TEXTURE_2D,3, width,height, GL_RGB, GL_UNSIGNED_BYTE, data ); free( data ); return txtr; } // LoadTexture (vedi piu'dettagli tra 3 slide)

un es. OpenGL per uso tessiture poi, uso tessitura: .. drawFace(tess1,..);..dove: void drawFace( int mytexture, float siz ){ glEnable( GL_TEXTURE_2D ); glBindTexture( GL_TEXTURE_2D, mytexture ); glBegin(GL_QUADS); ... glEnd(); glDisable (GL_TEXTURE_2D); }

mappatura da area tessitura a area oggetto void draw2(int mytxtr, float siz){ float sx=1.0; glEnable( GL_TEXTURE_2D ); glBindTexture( GL_TEXTURE_2D, mytxtr ); /*per ogni lato fisso corrisp.lato-tessitura*/ glBegin(GL_QUADS); glTexCoord2f( 0.0, 0.0);/*tessit.basso sin */ glVertex3f( -siz, -siz, siz); /*basso sin */ glTexCoord2f( sx, 0.0);/*tessit.basso des */ glVertex3f( siz, -siz, siz); /*basso dest*/ glTexCoord2f( sx, sx); /* tessit.alto dest*/ glVertex3f( siz, siz, siz); /*alto dest*/ glTexCoord2f( 0.0, sx); /*tessit.alto sin*/ glVertex3f( -siz, siz, siz); /*alto sin*/ glEnd(); // da'la corrispondenza tra area tess. glDisable (GL_TEXTURE_2D); // e un'area oggetto }

GLuint LoadTexture( char * filename, int wrap ) { GLuint txtr; int width=256, height=256; char * data; data = ReadBMP( width, height, filename ); glGenTextures( 1, & txtr); // nota & stile C (param in uscita) glBindTexture( GL_TXTR_2D, txtr); /* segue specifica di come si aggiunge la txtr a superf.precedente */ glTexEnvf(GL_TXTR_ENV, GL_TXTR_ENV_MODE, GL_MODULATE ); /* GL_MODULATE oppure GL_DECAL, 2 slide dopo */ /* segue come si rimpiccolisce/ingrandisce la txtr (MIPMAP !): */ glTexParameterf( GL_TXTR_2D, GL_TXTR_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST ); glTexParameterf(GL_TXTR_2D, GL_TXTR_MAG_FILTER, GL_LINEAR ); /* now, if wrap - the txtr wraps over at the edges (repeat!), if not wrap - the txtr ends at the edges (clamp) */ glTexParameterf( GL_TXTR_2D, GL_TXTR_WRAP_S, wrap ? GL_REPEAT : GL_CLAMP );

GLuint LoadTexture( char * filename, int wrap ) { continua la GLuint LoadTexture( char * filename, int wrap ) { GLuint txtr; int width=256, height=256; char * data; data = ReadBMP( width, height, filename ); glGenTextures( 1, &txtr); glBindTexture( GL_TXTR_2D, txtr); ... /*now build texture MIP maps, 3 levels, copy image data*/ gluBuild2DMipmaps( GL_TXTR_2D, 3, width, height, GL_RGB, GL_UNSIGNED_BYTE, data ); // questo genera 3 livelli di riduzione della tessitura // fornita con il puntatore data, associati a txtr... // nota: gluBuild2DMipmaps e' al posto di glTexImage2D // ora la txtr e' fatta, posso eliminare il buffer "data" : free( data ); return txtr; // questo e' il risultato: il numero della txtr } /* fine della procedura LoadTexture */

un es. OpenGL per uso tessiture continua la LoadTexture, vediamo meglio il glTexEnv : GLuint LoadTexture{ GLuint txtr; int width=256, height=256; char * data; data = ReadBMP( width, height, filename ); glGenTextures( 1, & txtr); // nota & stile C (param in uscita) glBindTexture( GL_TXTR_2D, txtr); glTexEnv ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); /* come si combina tessitura con l'ambiente: GL_MODULATE per il prodotto dei due colori, GL_REPLACE se tessitura copre l'oggetto; GL_DECAL combina colore dell'oggetto(trasparente) con tessitura(sfondo); GL_BLEND se uso blend devo specificare un colore bC per il blending, con un altra call: glTexEnv3f( GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR, bC ) ...

altre proc per tessiture l'OpenGL prevede altre procedure per la creazione e gestione delle tessiture, ad es: glTexParameter*( texSpace, texWrapCoord, GL_REPEAT); dove texSpace e' ad es. GL_TEXTURE_2D, e dove texWrapCoord e' GL_TEXTURE_WRAP_S, oppure GL_TEXTURE_WRAP_T (indicazione di come si ripete la tessitura se si hanno coordinate tessitura maggiori di 1) invece di GL_REPEAT posso avere GL_CLAMP, che indica che coordinate s,t della tessitura maggiori di 1 sono troncate. ecc: vedere manuale ... e gli esempi

vedere il primo esempio di uso delle texture EGD3D_21_TXTR in questo esem. e' riportata anche la procedura di lettura di file immagini (nel formato piu' semplice, il bit-map, "bmp", dove c'e' una parte iniziale con informazioni sul formato del file; (non riportato il formato "raw", con solo pixel grafici, niente informazione, tutto a formato fisso) letto un file, con l'uso di char * ReadBMP ( int & width, int & height, char * filename ); proc. della "BITMAP_AU.h", il resto e' come detto prima...

tessiture su oggetti "complicati" una tessitura si puo' applicare su superfici complesse, sia regolari (sfera,cilindro ecc) sia irregolari (teiera, una faccia - date con una superficie fatte di triangoli) di seguito quattro esempi, tre con foto (corso EGD07) applicate a superfici + o - regolari,

tessitura su cilindro e su cono, es. dal programma di Tamiazzo (giu (Dotta e Hmeljak)

tessitura applicata a teiera, programma di Tamiazzo giugno 2007 (Mauri)

l' immagine seguente e' ottenuta applicando una texture (foto di una faccia) ad un' immagine costruita con triangoli nello spazio, che definiscono una "faccia" (la faccia e' da rete)

"Oscar" immagini da tesi di laurea triennale di Righetti su riconoscimento del parlato di una persona in real time, 9 apr. 2008, corso ing.inf. teledidattico, relatore prof.Mumolo

tessiture seguono quattro slide con esempi di immagini prodotte dai programmi: EGD3D_21_TXTR.cpp EGD3D_22_TXTR_CUBO.cpp EGD3D_24_ANICUBO.cpp EGD3D_25texgen1D.c

tessiture es da programma EGD3D_21_TXTR.cpp, tessitura (quadrata) su un triangolo (nello spazio)

tessiture esempio da programma EGD3D_22_TXTR_CUBO, stessa tessitura di prima applicata alle facce di un cubo

tessiture da programma EGD3D_24_ANICUBO, tre cubi con tre tessiture diverse

tessiture programma EGD3D_25texgen1D.c (dal manuale, tessitura calcolata)

due immagini con texture applicata a un oggetto sfera, con costruzione esplicita (vedi slide seguente) nel testo seguente sono stati ommesse alcune istruzioni, come: glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glColor4f(1,1,1,1);

void drawSphere(int txtr, int nMaj, int nMin, float radius) { double majorStep= M_PI / nMaj, minorStep= 2*M_PI / nMin; glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, txtr); for (int i = 0; i < nMaj; ++i) { double a,b,r0,r1; GLfloat z0,z1; a = i * majorStep; b = a + majorStep; r0 = radius * sin(a); z0 = radius * cos(a); z1 = radius * cos(b); r1 = radius * sin(b); glBegin(GL_TRIANGLE_STRIP); for (int j = 0; j <= nMin; ++j) { GLfloat x,y; double c = j * minorStep; x = cos(c); y = sin(c); glNormal3f( (x*r0)/radius, (y*r0)/radius, z0/radius); glTexCoord2f( j/(GLfloat) nMin, i/(GLfloat)nMaj); glVertex3f( x * r0, y * r0, z0); glNormal3f( (x*r1)/radius, (y*r1)/radius, z1/radius); glTexCoord2f( j/(GLfloat)nMin, (i+1)/(GLfloat)nMaj); glVertex3f( x * r1, y * r1, z1); } /* for j */ glEnd(); /* triangle strip */ } /* for i */ glDisable (GL_TEXTURE_2D); glDisable(GL_CULL_FACE); } /* drawSphere */

a sinistra "schiera oggetti Mona Lisa" - nota tessitura sui tetraedri, che si ricompone sulla schiera dei tetraedri piu' vicini all'osservatore; a destra (teiere) e' stato aggiunto il blending (alfa=0.5) di seguito parte del testo di disegno schiera oggetti

void displaySolid(){ glPushMatrix(); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_2D); glBindTexture( GL_TEXTURE_2D, texture1 ); glutSolidTetrahedron(); // o altro glutSolid... glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable (GL_TEXTURE_2D); glPopMatrix(); } // displaySolid

seguono delle presentazioni di tecniche di uso di texture per ottenere effetti di realismo piu' spinti: environmental mapping bump mapping parallax mapping ...

le slide seguenti sono dal materiale preparato dagli studenti Tamiazzo (07), Tubini (06) e Signoretti (07) per il seminario finale del corso

Environment Mapping Tamiazzo Claudio EGD07

Environment Mapping - Cos’è Tecnica utilizzata in grafica digitale allo scopo di realizzare oggetti riflettenti senza ricorrere agli onerosi calcoli computazionali del RayTracing: la scena riflessa non e' calcolata (ray tracing) ma e' precalcolata (predisposta, spesso come immagine fotografica) e poi incollata sull'ogetto come fosse un adesivo ! seguono due slide con alcune immagini

Come Funziona L’environment mapping permette di realizzare superfici apparentemente riflettenti utilizzando delle textures rappresentanti l’ambiente da riflettere La riflessione dipende/e'data da una environment map nella quale è proiettata l’immagine da riflettere In base al punto di vista, si effettuano i calcoli per determinare l’immagine riflessa, e poi questa viene usata come txtr

Tecniche più Diffuse Standard Environment Mapping, o più comunemente detta Spherical Environment Mapping. Cube Environment Mapping

Spherical Environment Mapping Sviluppata da Blinn e Newell Si basa sull’utilizzo come environment map di una sfera “texturizzata” Spesso la texture di partenza consiste in un’immagine ottenuta con una macchina fotografica con lenti a grandangolo

Effetto ottenuto con l' E.M. sferico Foto ottenuta con lente “fisheye”

Spherical Environment Mapping Questa tecnica porta con se' delle grosse limitazioni legate al punto di vista dell’utente nella scena 3D Una volta che il punto di vista cambia, cambia l'immagine riflessa e sarebbe necessario disporre di una texture diversa per ogni angolazione

Fronte Retro Riflessione corretta Riflessione incoerente

Cube Environment Mapping Tecnica che utilizza il cube mapping per ottenere oggetti riflettenti Una cube map consiste in 6 textures quadrate che vanno a formare una environment map cubica ( predisposto in OpenGL)

Esempio: environment map di un paesaggio da riflettere ottenibile con sei foto fatte in sei direzioni diverse

Cube Environment Mapping Per realizzare una superficie riflettente si calcola il raggio dal punto di vista all’oggetto ed, in base alla normale, il raggio riflesso che va a intercettare un punto su una delle sei facce del cubo. Il colore intercettato sulla texture sarà il colore da riportare sull’oggetto nel punto di riflessione

Cube Mapping In OpenGL Creazione Cube Map (predisposto in OGL) per ognuna delle sei facce (+X,-X,+Y,-Y,+Z,-Z) : glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, imageSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, image1); glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, imageSize, 0,GL_RGBA, GL_UNSIGNED_BYTE, image2); . . . . . devo avere sei immagini texture per le sei direzioni

Cube Mapping In OpenGL Settaggio wrapping e filtering glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_REPEAT); si ricorda che (S,T,R,Q) sono le coordinate (x,y,z,w) della texture

Cube Mapping In OpenGL Generazione delle coordinate (S,T,R) della cube map texture glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP); glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);

GL_REFLECTION_MAP vs GL_NORMAL_MAP Immagini realizzate con programma cubemap.c da http://developer.nvidia.com/

Cube Mapping In OpenGL Abilitazione texturing glEnable(GL_TEXTURE_CUBE_MAP_EXT); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_GEN_R); (S,T,R) coordinate della (cube map) texture

Applicazioni Cinematografiche Flight of the navigator, 1986: Superficie della navicella realizzata Con l’uso dell’ environment mapping Terminator 2: Judgement Day-1991 Il cyborg T1000 nelle sue metamorfosi è una delle più celebri applicazioni dell’environment mapping

Bibliografia Libri - il manuale “OpenGl Programming Guide” di Shreiner, Woo, Neider, Davis (red-book) Rete: http://www.debevec.org/ReflectionMapping/ http://www.developer.com http://en.wikipedia.org/wiki/Reflection_mapping http://developer.nvidia.com

BUMP MAPPING seminario Tubini maggio 2006

invece che come colori di pixel BUMP-maps invece che come colori di pixel (talvolta in mescolanza come il blending dei colori) una tessitura si puo' applicare all' oggetto come funzione che cambia la direzione della normale N alla superficie, (ricordiamo che N e' alla base del calcolo della luce riflessa / diffusa) creando effetti di ombre e di rugosita' questa tecnica si dice bump-mapping il materiale seguente e' del seminario di Stefano Tubini, corso EGD maggio 2006

ricordiamo la formula di Gouraud per l'intensita' di luce in un punto: per una sorgente di luce, N = normale alla superfice: I = Iambiente + I Diffusa + I Speculare = Ka * Ia + I Incidente Kd * cos(a) + W(a) * I Incidente * Ks* cosn(x) = Ka * Ia + I Incidente Kd * N . L + W(a) * I Incidente * Ks* (N.H)n in generale, con ns sorgenti di luce, avremo la luce in un punto P della superficie di un oggetto data da: I = Iambiente + somma k ( I Diffusa k (N) + I Speculare k (N) ) per tutte le luci k da 1 a ns;

Il bump mapping è un metodo per simulare superfici scabrose, con rilievi, con textures bidimensionali. Per esempio: se realizziamo un oggetto che rappresenta un tronco di legno, le fenditure della corteccia, grazie al bump mapping, possono apparire tridimensionali anche se non sono realizzate realmente con poligoni. In questo modo, eventuali cambi di illuminazione possono far apparire tali solchi profondi anche se sono assolutamente piatti; con il bump mapping si possono utilizzare molti meno poligoni per disegnare un oggetto 3D, come mostrato dalla immagine seguente: l' immagine originale (non mostrata nella slide) viene semplificata in un' immagine con superfici a triangoli "grandi", poi questa viene resa con il bump-mapping che alla fine da' quasi la stessa qualita' con 10 volte meno triangoli!

Dot3 Bump Mapping : Questo metodo di bump mapping è anche detto Dot Product Perturbed Bump Mapping o Per-pixel lighting. L'algoritmo alla base del Dot3 mapping è relativamente semplice e si basa sulla creazione di una normal map, vale a dire una mappa dove i valori di ogni singolo pixel non rappresentano un colore come nelle texture convenzionali (secondo il classico schema RGB [red-green-blue]) ma vettori 3D, o normali (rette perpendicolari). A questo punto si esegue un prodotto (da cui "dot product") tra queste normali ed il vettore della luce: il risultato indica l'intensità di riflessione della luce per ogni pixel trattato. Modulando questo valore con il pixel della texture di base si ottiene la texture finale che sarà applicata all'oggetto.

Dot3 Bump Mapping Texture Normal Map Final Image

texture 2D e bump-maps quindi si usa il bump-mapping per una buona resa di superfici rugose: si alterano le normali alla superfice in funzione dei valori di una tessitura "bump-texture" = un' immagine monocromatica che fornisce la "rugosita' " come ombre locali, e quindi il calcolo dell'intensita' di luce locale varia da punto a punto, in quanto varia la direzione della normale nel punto in funzione della bump-map; due esempi di texture + bump-map son riportati qui a fianco (manca la combinazione delle due tessiture, sorry) e nella pagina seguente

texture 2D e bump-maps per superfici rugose si usa la tecnica detta bump-mapping; qui un secondo esempio di texture + bump-map; ricordiamo che l'intensita' di luce locale I e' funzione di N, normale alla superficie; il bump mapping altera questa N, da cui segue un alterazione dell' intensita' della luce locale (diffusa e riflessa)

texture 2D e bump-maps il bump-mapping: ricordiamo che l'intensita' di luce locale I e' funzione di N, normale alla superficie; nel bump-mapping si usa una normale N' = N + Nb , con N normale alla superficie e Nb funzione di (u,v), coordinate del punto nella superficie, appunto la bump-map data con un' immagine (come negli esempi visti) oppure - caso delle tessiture procedurali - la Nb puo' esser data con una funzione o procedura cioe' calcolata invece che data da un'immagine (effetti di particolari rugosita' date con sinusoidi "irregolari") nota: la parte ARB che appare nei nomi e' per le estensioni gia' approvate dal comitato OGL Architecture Review Board, ma non ancora messe in una delle librerie gl, glu, glut ...

Dot3 Mapping (Codice) Associo la normal map alla texture unit 0 : glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D, oggetto3D->normalMap); glEnable(GL_TEXTURE_2D); // Associo normalisation cube map alla texture unit 1. Dove la normalisation // cube map: penso come 6 textr 2D posizionate in modo da formare un cubo. glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap); glEnable(GL_TEXTURE_CUBE_MAP_ARB); … Dot 3 Bump Mapping … glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB); … Texture Rendering

tessiture procedurali per motivi di spazio (una procedura occupa meno spazio di un'immagine) o per motivi di effetti speciali (non ottenibili da un'immagine fissa) si usano tessiture costruite al momento con apposite procedure sul bump-mapping esistono molte varianti, con uso di piu' "mappe" o immagini - tessiture da combinare per ottenere effetti realistici di seguito due cenni

Environment map bump mapping : è uno tra i metodi più nuovi apparsi nel campo della grafica 3D. L'environment map bump mapping utilizza 3 texture diverse: la texture di base, una bump map ed una environment map. La bump map contiene i valori di altezza dei particolari della texture di base. Tra i primi ad aver utilizzato questo metodo è il G400, un chip Matrox che per prima ne ha diffuso in modo significativo l'utilizzo. Per capire meglio riprendiamo l'esempio della texture della corteccia: avremo i solchi più profondi che rappresenteranno il livello di base, avremo i rilievi più alti che potranno sporgere di 10 unità, quelli intermedi di 5 unità, ecc... Tutti questi valori sono raccolti nella height map sotto forma di una matrice di valori. L'environment map è la matrice che contiene le informazioni su cosa deve essere fatto: in genere, l'environment map può essere una semplice mappa di illuminazione, ma può contenere anche altri effetti da applicare. Alla fine, quando le 3 texture sono combinate insieme, si ottiene quella finale che sarà applicata sul poligono. segue esempio

Environment map bump mapping

Parallax Mapping Parallax Mapping è un miglioramento della tecnica del bump mapping applicata alle textures nelle applicazione di 3D rendering come i video games. Le textures, con l’utilizzo di questa tecnica avranno una maggiore profondità e realismo senza aumentare la loro complessità poligonale. Il Parallax mapping agisce su di una texture modificando le coordinate di ogni punto che la compone di un valore uguale a quello riportato nella normal map associata.

Parallax Mapping Senza Parallax Mapping Con Parallax Mapping

Image Based Realtime Rendering seminario di A. Signoretti L.S. Ingegneria Informatica Corso di Elementi di Grafica Digitale Anno Accademico 2006 - 2007 rivedere !!

Obiettivo Sviluppare applicazioni di Grafica Digitale, con Real-Time Rendering, sempre più realistiche e dettagliate Possibile aumentando a dismisura il numero di poligoni delle “Mesh” degli oggetti… …ma l’Hardware attuale non è in grado di gestirne così tanti in Real-Time

Tecniche per simulare scabrosità Utilizzo di tecniche basate su: Modelli locali di illuminazione (Shading models) Texture Mapping Implementate negli attuali linguaggi (OpenGL, Direct3D e loro estensioni) e supportate dai moderni hardware grafici Buone prestazioni nelle elaborazioni Real-Time, ma danno una resa della scena peggiore rispetto alle tecniche off-line (Ray-tracing, Radiosity,…)

Modelli di Illuminazione Determinano il colore e l’intensità luminosa di una superficie, rendendo realistica la scena e dando agli oggetti bidimensionale un aspetto 3D Dipende dalla superficie: (a) Lucida o Speculare (specchio) (b) Opaca o Diffusiva (gesso, carta) (c) Traslucente o Traslucida Trasparente (vetro)

Modello di Phong (1975) L’intensità di illuminazione di un punto dipende da: Distanza e angolazione della sorgente luminosa rispetto al punto (attenuazione) Tipologie di riflessione della specifica superficie Attenuazione Distanza: l’intensità luminosa si attenua col quadrato della distanza. Aumenta l’effetto di profondità. Punto di vista all’infinito ⇒ No attenuazione Angolo: posizione della sorgente luminosa rispetto al punto

Modello di Phong [2] Tipologie di riflessione (componenti): Luce Ambientale: approssima il fenomeno della inter-riflessione diffusa tra oggetti della scena, uniforme in ogni punto Luce Riflessa Diffusa: riflessa da una superficie perfettamente diffusiva ugualmente verso qualsiasi direzione Luce Riflessa Speculare: la luce riflessa (versore r) esce dalla superficie come cono di luce, con intensità funzione dell'angolo Φ (tra v, osservatore, e r, simmetrico rispetto la normale del versore L, luce incidente) Valido per k sorgenti luminose. Il calcolo va effettuato per ognuno dei canali RGB.

Metodi di Illuminazione Flat Shading: si calcola Phong su un punto per ogni poligono e si assegna il valore risultante a tutti i punti del poligono Metodo di Gouraud Si definisce il vettore n in ciascun vertice di un poligono come media pesata delle normali dei poligoni attorno al vertice stesso e si applica Phong su ciascuno dei vertici Trovo la I per ogni punto interpolando linearmente le I dei vertici Metodo di Phong: simile a Gouraud, ma vengono interpolate le normali dei vertici per trovare la normale di ogni punto con cui si ricalcola Phong. Richiede un numero maggiore di calcoli ma dà risultati migliori.

Texture Mapping (Catmull ’74) Tecnica che consiste nell’applicare un’immagine bi-dimensionale su un oggetto 3D composto da uno o più poligoni

Texture Map Funzione che associa un textel (punto della texture) ad ogni punto della superficie di un oggetto geometrico e poi proietta questi punti sullo schermo In pratica è una matrice bi-dimensionale contenente dati indirizzati dalle coordinate s e t Vi sono tipicamente due strategie per poter mappare una texture su una superficie: Mappatura diretta: dato un textel (s, t) nella texture si trova il punto (x, y, z) dell’oggetto su cui tale pixel viene mappato e, con una funzione di proiezione, si trova il suo corrispondente (xs, ys). Mappatura indiretta: Per ogni pixel (xs, ys) si trova nella texture la corrispondente coordinata (s, t). Non è detto che numero e coordinate dei textel corrispondano a quelle dei pixel e viceversa: si usano tecniche di aliasing (Magnification e Minification - MIPMAPping)

Rendering L’ultima fase della pipeline di rendering assegna una gradazione di colore ad ogni fragment tramite il modello di shading Invece di incrementare la complessità della Mesh, si aggiungono particolari alla scena come parte del processo di Rendering Gli algoritmi di mapping modificano i risultati dello shading sulla base di un vettore bidimensionale (map) che contiene, in ogni elemento, diversi tipi di dati La map viene applicata dopo il calcolo dell’illuminazione per modificare: colore, luminosità, trasparenza… (scalari -> texture mapping) Parametri utilizzati nel modello di Phong (normali -> bump mapping)

Bump Mapping (Blinn ’78) Tecnica che perturba la normale in un punto tramite il valore corrispondente nella Bump Map (texture) Altera lo shading della superficie senza modificarne la geometria (il modello locale di illuminazione usa la normale per calcolare l’intensità di colore), simulando un effetto di profondità Non proietta alcuna ombra, non copre altri oggetti

Bump Mapping (Blinn ’78)

Bump Mapping [2] Sia P(u,v) un generico punto della superficie (parametrizzata) da perturbare Sia data la mappa B(u,v) che specifica la perturbazione (virtuale) da applicare alla superficie, spostando il punto P(u,v) lungo la sua normale della quantità B(u,v) La normale in P è dunque (normalizzata) dove Pu e Pv sono le derivate parziali rispetto ai due parametri

Bump Mapping [3] Se spostassimo P lungo n di un valore B(u,v) si otterrebbe: Per calcolare la nuova normale n’ derivo P’(u,v) rispetto a u e v: Supponendo che B(u,v) sia sufficientemente piccola e la superficie sufficientemente regolare da poter trascurare l’ultimo termine: Se applicando il modello di illuminazione a P si usa n’ al posto di n si ottiene l’impressione che il punto sia stato perturbato.

Bump Map Le Bump Map sono immagini in scala di grigio (usano un solo canale per i dati di perturbazione) Le aree più chiare (bianco) sono renderizzate come aree che “escono dalla superficie” mentre le aree più scure (nero) sono renderizzate come depressioni Texture Map Bump Map

Difetti del Bump Mapping Se il punto di vista è troppo vicino o quasi parallelo rispetto alla superficie si nota chiaramente che essa è piatta Necessario utilizzare due textures (texture map classica + height map), ricalcolare le normali su tutti i punti e riapplicare l’algoritmo di shading Utilizzabile solamente per simulare limitate scabrosità, rugosità

Normal Mapping (Peercy ’97) Miglioramento del Bump Mapping: più preciso in quanto usa delle Normal Map “colorate” con 3 canali più rapido in quanto la Normal Map contiene già le normali perturbate (non sono necessari ulteriori calcoli)

Normal Map Texture che codifica le coordinate delle normali alla superficie già perturbate, nei 3 canali RGB (al posto di valori di colore) Red: coordinate x, destra-sinistra Green: coordinate y, giù-su Blue: coordinate z, solo positive, fuoriesce I valori dei 3 canali, che sono riferiti allo Spazio Texture, devono essere trasformati in coordinate nello Spazio Tangente: Spazio Texture: range di valori [0-255] Spazio Tangente: range di valori [-1,1]

Creare una Normal Map Detail Preservation Da una High map: non si migliora il dettaglio, ma velocizza i calcoli Si usano generalmente dei tool forniti dai programmi di grafica

Displacement Mapping (Cook ’84) Tecnica di Rendering Geometry-Based, modifica la geometria di una superfice in base ad una immagine presente su di una texture Durante il rendering, le displacement map modificano la geometria, producendo effetti di qualità più elevata, al prezzo di un maggior numero di triangoli Non utilizzabile nelle applicazioni Real Time

Parallax Mapping (Kaneko ’01) Parallasse: fenomeno per cui un oggetto sembra spostarsi rispetto allo sfondo se si cambia il punto di osservazione Tecnica che approssima la parallasse su una superficie come se fosse scabrosa, in modo da aumentarne il dettaglio Non simula Occlusions o Self Shadowing Quando si osserva una superficie su cui è stato applicato il Parallax Mapping da un certo angolo, i punti più alti oscureranno i punti più bassi dietro di loro

Parallax Mapping (Idea) Se guardassimo la superficie piatta, dalla direzione dell’osservatore, vedremmo il punto A Se, osservando nella stessa direzione il poligono, fossero presenti anche le scabrosità che vorremmo ottenere, non vedremmo più il punto A bensì il B Potremmo “spostare” di un certo offset la coordinata texture (applicata alla superficie) corrispondente al punto A L’offset di ogni textel viene calcolato in funzione dell’Height Map associata

Height Map Mappa di elevazione: Rappresenta la variazione di altezza della superficie Correlata con la texture map Contiene un valore di altezza per ogni textel [0.0 - 1.0]

Calcolo dell’offset Dati: V = vettore Osservatore normalizzato Hsb = altezza scalata del punto T0 dalla height map Si traccia un vettore parallelo (offset) al poligono dal punto A al vettore Osservatore

Per-Pixel Texture Coordinate Addressing Bisogna indirizzare le coordinate della texture per ogni pixel u e v sono le coordinate texture sorgente e u’ e v’ sono quelle risultanti M è una matrice 2x2, definita dall’utente, per scalare e ruotare le coordinate texture (in base a particolarità della superficie da rappresentare) Δu e Δv sono dei valori di variazione delle coordinate texture (trovate con il calcolo dell’offset) I risultato è inserito in una distortion map

Parallax VS Bump

Pro e Contro del Parallax Vantaggi: Costo elaborativo molto basso: vengono solamente modificate delle coordinate texture producendo una texture distorta Può essere usata con tutti i tipi di mapping Possibile aumentare la complessità della geometria Svantaggi: Le modifiche alla texture non sono perfette E’ errata l’assunzione che l’altezza del punto, dopo aver distorto la texture, rimanga la stessa (può andare bene per punti molto vicini) Funziona male con height maps che variano continuamente il valore di altezza

Offset-limited Parallax Mapping Attenua ma non elimina il problema dell’altezza Vettore offset non deve mai essere maggiore di hsb Se T0 e Tn sono vicini, è più probabile che la loro altezza sia simile L’equazione da usare è la seguente:

Conclusioni Negli ultimi anni (dal 2001 in poi) si sono sviluppate molte tecniche basate su Bump e Parallax Mapping Queste tecniche hanno tipicamente l’obiettivo di migliorare il rendering o di aggiungere algoritmi per calcoli più precisi su diverse componenti della superficie, senza arrivare a calcoli troppo onerosi Alcune di esse: Relief Texture Mapping Iterative Parallax Mapping Interval Mapping Steep Parallax Mapping

fine parte cenni di tessiture