Texture mapping

Agli albori della computer grafica, i piccoli dettagli dei modelli - che fossero geometrici o riconducibili al colore - erano rappresentati sul modello dell'oggetto "dipingendoli" sul modello stesso, come in una pittura trompe-l'œil.^[2] Era possibile dipingere una piccola macchia chiara sul modello in modo sembrasse un punto luce, a prescindere dall'illuminazione nella scena. Questi dettagli erano chiamati texture, ed erano memorizzati in un array immagine. Il modellista della scena doveva anche associare ogni vertice del modello alla posizione nell'array immagine, perciò "mappare" il modello all'immagine (sebbene l'obiettivo generale fosse proprio l'opposto - questa mappatura era usata per "applicare" l'immagine sul modello, come un adesivo).

Presto divenne chiaro che piuttosto che mappare l'albedo (ovvero la frazione dell'energia riflessa), era possibile mappare altri parametri del modello di illuminazione, come il vettore normale.^[2] Il variare del vettore normale rendeva il modello come increspato o accidentato (senza modificare la geometria del modello^[3]); in altre parole, l'aspetto di una trama. Ma il termine "texture" era già utilizzato per dare il significato a qualcosa di diverso, così questo fu chiamato bump mapping (Blinn, 1978). In seguito divenne chiaro che si potevano anche memorizzare in una mappa piccole variazioni nella posizione della superficie, e mentre questo sarebbe stato chiamato bump mapping - dato che effettivamente aggiungeva irregolarità a una superficie - quell'espressione era comunque in uso, così venne chiamato displacement mapping (Cook, 1984).^[2]

Infine, quando divennero comuni le GPU programmabili, la loro texture memory era l'unica struttura dati disponibile indirizzabile casualmente al programmatore, ed era spesso usata per memorizzare array n-dimensionali, puntatori, e altre cose (ovvero, essa era trattata come una memoria ordinaria). Perciò, il particolare significato di "texture" è piuttosto dipendente dal tempo; quando si legge un documento sulla materia, c'è bisogno di sapere quando è stato scritto per sapere cosa il termine sta a indicare.

Le texture sono immagini utilizzate per aggiungere dettagli ulteriori all'ombreggiatura di superfici che apparirebbero altrimenti troppo omogenee e artificiali. L'idea è semplice: ogni volta che lo shading viene calcolato, vengono letti i valori utilizzati dalla computazione - il colore diffuso, per esempio - da una texture, invece che usare i valori di attributo che sono connessi alla geometria renderizzata. Questa operazione è conosciuta come texture lookup^[4]: il codice dello shading specifica una texture coordinate, un punto nel dominio della texture, e il sistema di texture mapping trova il valore in quel punto nella texture immagine e lo restituisce. Il valore della texture è dopo usato nella computazione dello shading.

Si consideri una scena con un pavimento ligneo, e si determini che il colore diffuso del pavimento sia controllato da un'immagine che mostra assi del pavimento con una grana lignea. A prescindere che si stia utilizzando il ray tracing o la rasterizzazione, il codice dello shading che calcola il colore per un punto di intersezione raggio-superficie o per un frammento generato dal rasterizer, necessita di sapere il colore della texture nello shading point, in modo da usarlo come colore diffuso nel modello di shading lambertiano.

Per ottenere questo colore, lo shader esegue un texture lookup:^[4] comprende la posizione, nel sistema di coordinate della texture immagine, che corrisponde allo shading point, e legge il colore in quel punto nell'immagine, che ci risulta nel texture sample^[4]. Quel colore è dopo usato nello shading e, dato che il texture lookup avviene in differenti posizioni nella texture per ogni pixel che vede il pavimento, diviene visibile un pattern di colori differenti nell'immagine. Il codice potrebbe apparire in questo modo:

Color texture_lookup(Texture t, float u, float v) {
    int i = round(u * t.width() - 0.5)
    int j = round(v * t.height() - 0.5)
    return t.get_pixel(i,j)
}
Color shade_surface_point(Surface s, Point p, Texture t) {
    Vector normal = s.get_normal(p)
    (u,v) = s.get_texcoord(p)
    Color diffuse_color = texture_lookup(u,v)
    // compute shading using diffuse_color and normal
    // return shading result
}

In questo codice, lo shader chiede alla superficie dove guardare nella texture, e in qualche modo ogni superficie che si desideri ombreggiare usando una texture necessita di essere in grado di rispondere a questa richiesta. Questo porta al primo ingrediente chiave del texture mapping: abbiamo bisogno di una funzione che esegua una mappatura dalla superficie alla texture, che possiamo calcolare facilmente per ogni pixel. Questa è la texture coordinate function, e diremo che essa assegna delle texture coordinates per ogni punto sulla superficie. Matematicamente essa è una mappatura dalla superficie ${\displaystyle S}$  al dominio della texture, ${\displaystyle T}$ :^[4]

$${\displaystyle {\begin{aligned}\phi &:S\rightarrow T\\&:(x,y,z)\mapsto (u,v)\\\end{aligned}}}$$ 

 

L'insieme ${\displaystyle T}$ , spesso chiamato "texture space", è di solito solo un rettangolo che contiene l'immagine; è comune l'utilizzo del quadrato unitario ${\displaystyle (u,v)\in [0,1]^{2}}$  (useremo le lettere ${\displaystyle u}$  e ${\displaystyle v}$  per le due texture coordinates). La funzione ${\displaystyle \phi }$  è una mappatura dalla superficie alla texture, quando il nostro obiettivo è inserire la texture sulla superficie, questa tuttavia è la funzione di cui abbiamo bisogno.

Per il caso del pavimento di legno, se il pavimento si trova a essere a una costante ${\displaystyle z}$  e allineato agli assi ${\displaystyle x}$  e ${\displaystyle y}$ , possiamo semplicemente usare la mappatura^[4]

$${\displaystyle u=ax;\quad v=by}$$ 

per alcuni fattori di scala appropriatamente scelti ${\displaystyle a}$  e ${\displaystyle b}$ , per assegnare le texture coordinates ${\displaystyle (s,t)}$  al punto ${\displaystyle (x,y,z)_{\text{floor}}}$ , e in seguito utilizzare il valore di un texture pixel, o texel^[4], il più vicino a ${\displaystyle (u,v)}$ , come valore della texture in ${\displaystyle (x,y)}$ .

I pixel da visualizzare sullo schermo, calcolati a partire dai texel, verranno in seguito governati dal filtro della texture. Il metodo più veloce è quello di usare l'interpolazione lineare (filtro lineare), ma l'interpolazione bilineare (filtro bilineare) o l'interpolazione trilineare (filtro trilineare) tra MIP map sono quelle più comunemente utilizzate per ridurre l'aliasing, e quindi per aumentare la qualità complessiva dell'immagine. L'applicazione della texture sul modello tridimensionale è compito della scheda video.

• John F. Hughes, Andries Van Dam, Morgan Mcguire, David F. Sklar, James D. Foley, Steven K. Feiner, Kurt Akeley, Computer Graphics: Principles and Practise
• Steve Marschner, Peter Shirley, Fundamentals of Computer Graphics, 4ed.
• David S. Ebert, F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, Steven Worley, Texturing and Modeling - A Procedural Approach, 3ed.
• Huamin Wang, Texture Mapping Archiviato l'11 luglio 2019 in Internet Archive.
• Heckbert Paul, Fundamentals of Texture Mapping and Image Warping, 1989

• Computer grafica 3D
• Ombreggiatura
• Mappatura UV
• Shader
• Texture (grafica)

•   Wikimedia Commons contiene immagini o altri file sul texture mapping

• Chapter 2: Texture Mapping da happy-werner.hol.es
• ^{[collegamento interrotto]} usando XNA/DirectX, da www.riemers.net

  Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica