Lucrarea Nr 5 TEXTURAREA

Texturarea este o tehnica importanta de crestere a realismului scenelor virtuale, prin care se genereaza imagini ale obiectelor tridimensionale mult mai interesante si mai complexe. Prin texturare, se moduleaza culoarea suprafetelor obiectelor folosind o imagine repetitiva (textura), obtinndu-se un efect asemanator aceleia de aplicatie (lipire) a unui desen pe o suprafata. n decursul dezvoltarii tehnicilor de texturare, au fost propuse diferite modalitati de creare a impresiei de realism a suprafetelor, de exemplu prin perturbatia normalelor suprafetelor, sau prin variatii ale iluminarii mediului ambiant al obiectelor. n momentul actual, metoda cea mai larg raspndita, cu numeroase implementari hardware n sistemele grafice, este metoda de modulare a culorii suprafetelor obiectelor folosind imagini de texturi. Texturile se definesc ca imagini bidimensionale care se aplica suprafetelor obiectelor, sau ca un cmp tridimensional, si atunci culoarea obiectului se determina prin intersectia suprafetelor sale cu acest cmp tridimensional al texturii. n lucrarea de fata ne vom ocupa de texturi bidimensionale.

5.1

APLICATIA SI REDAREA TEXTURILOR

Textura bidimensionala este o imagine definita ntr-un spatiu bidimensional (numit spatiul texturii) T(s, t), n intervalul [0,1] pe ambele axe de coordonate s si t. Textura este alcatuita din elementele componente discrete care sunt dreptunghiuri (sau patrate) numite texeli . Fiecare imagine de textura este definita prin rezolutia ei, data ca numar de texeli pe cele doua coordonate. De exemplu, se folosesc imagini de textura de 256 256 texeli, 512 512, etc. Aplicatia texturii bidimensionale unui obiect consta din parametrizarea suprafetelor, urmata de transformarea obiectului n sistemul de referinta ecran 3D. Prin parametrizarea suprafetelor se asociaza fiecarui vrf al obiectului modelat (reprezentat n sistemul de referinta de modelare) un punct de coordonate (s, t) n spatiul texturii. Transformarea completa de aplicatie a texturii mai necesita, dupa parametrizarea suprafetelor, toate transformarile geometrice obisnuite, de la sistemul de referinta model (spatiul obiect) la sistemul de referinta ecran 3D. Daca se compun cele doua transformari (parametrizarea suprafetei si transformarea n spatiul ecran 3D) se obtine o transformare de aplicatie a texturii (texture mapping), care transforma puncte din spatiul texturii n spatiul ecran 3D. Transformarea de parametrizare amplaseaza imaginea texturii pe un obiect prin asocierea unui punct (s, t) n spatiul texturii (parametrul de texturare), fiecarui punct (xm, ym, zm) al obiectului. Modul cum poate fi colata o suprafata plana (textura) pe un obiect tridimensional nu are o solutie unica si nu poate fi realizat dect admitnd diferite tipuri de erori si distorsiuni. n implementarile practice au fost adoptate mai multe tehnici de aplicatie ale texturilor. De exemplu, se poate atribui cte o textura fiecarei fete plane a unui obiect, unui grup de fete ale obiectului, sau se poate proiecta aceeasi textura pe toate fetele obiectului. Aplicatia texturii pe o suprafata plana. n acest mod de aplicatie a texturii, se definesc coordonatele (s, t) n spatiul texturii pentru fiecare vrf al suprafetei. Aceste coordonate sunt calculate o singura data, la modelarea obiectului, si sunt memorate mpreuna cu coordonatele vrfului si cu normala n vrf. Daca 0 s, t 1, atunci imaginea texturii apare o singura data (n ntregime sau partial) pe suprafata texturata. Daca coordonatele vrfurilor suprafetei n spatiul texturii depasesc patratul cu latura egala cu 1 n care este definita imaginea de textura, atunci se poate ca textura sa se repete pe suprafata texturata. Coordonatele de texturare se obtin printr-o scalare (prin care coordonata cea mai mare a vrfurilor suprafetei este adusa la valoarea 0.5), urmata de transformarea vrfurilor suprafetei dintr-un sistem de referinta local (al suprafetei) n sistemul de referinta al texturii bidimensionale. Daca se

considera ca sistemul de referinta al texturii nu este rotit fata de sistemul de referinta local, atunci matricea de pozitionare a sistemului de referinta al texturii fata de sistemul de referinta local este T(-0.5, -0.5) (fig. 5.1). n acest caz, matricea de transformare care se aplica vrfurilor suprafetei este: M = T-1*S(1/(2*d), 1/(2*d)) = T(0.5, 0.5)* S(1/(2*d), 1/(2*d)), unde d este cea mai mare valoare a coordonatelor vrfurilor suprafetei. t
(-0.5,0.5) ( 0, 1)

y
(0.5,0.5) ( 1, 1)

x 0 s

( 0.5,-0.5) ( 1, 0) Fig. 5.1 . Calculul coordonatelor de texturare

O' (-0.5,-0.5) ( 0, 0)

Fie cazul cel mai simplu de aplicatie a unei texturi pe o suprafata plana, si anume un patrat cu latura de dimensiune 2. Textura este definita n planul (sO't) si n acest sistem de referinta coordonatele colturilor sunt (0,0), (1,0), (1,1), (0,1). Patratul este definit n planul xOy si are coordonatele vrfurilor (-1,-1), (1,-1), (1,1), (-1,1). Pentru ca textura s a se suprapuna peste ntreg patratul, o singura data, atunci se scaleaza patratul cu un factor de scara de 0.5 (care aduce dimensiunea laturii patratului la dimensiunea laturii texturii, adica 1), dupa care se executa o translatie cu vectorul de translatie (0.5, 0,5). Se obtin astfel coordonatele de texturare ale vrfurilor patratului colturilor (0,0), (1,0), (1,1), (0,1), ceea ce era usor de observat n mod direct. Redarea suprafetelor texturate. Adresa texelilor corespunzatori pixelilor unei primitive geometrice (obtinuti prin transformarea de rastru), se calculeaza printr-o transformare de texturare care este transformarea inversa transformarii de aplicatie a texturii, constnd din transformarea ecran 3Dmodel urmata de transformarea inversa transformarii de parametrizare. Un pixel, definit ca un patrat n spatiul ecran 3D, este transformat n spatiul obiect printr-o transformare inversa transformarii modelecran 3D, si apoi este transformat n spatiul texturii, printr-o transformare inversa transformarii de parametrizare. Deoarece transformarea inversa transformarii model-ecran 3D nu este liniara, unui pixel din imagine i corespunde o suprafata n spatiul texturii care, n general, este un patrulater. Culoarea texelului corespunzator acestui patrulater este atribuita pixelului. Se poate observa ca transformarea de texturare este deosebit de costisitoare (ca putere de calcul) si rezultate bune n redarea interactiva (sau n timp real) se pot obtine numai prin implementarea hardware a operatiilor de texturare. Determinarea texelilor (din spatiul texturii) corespunzatori pixelilor primitivelor geometrice este un proces de esantionare si este posibil sa apara un zgomot de spectru transpus (aliasiang), daca nu se efectueaza filtrarea texturilor. Acest aspect este prezentat n subcapitolul urmator.

5.2

FILTRAREA TEXTURILOR

Fenomenul de aliasing care apare n texturare are cauza n esantionarea imaginii de textura. Transformarea din spatiul ecran 3D n spatiul texturii bidimensionale genereaza o suprafata n forma de patrulater corespunzatoare fiecarui pixel, care este numita pre-imaginea pixelului. Pentru simplificare se presupune ca pre-imaginea pixelului este un patrat n spatiul texturii (fig. 5.2). Pentru determinarea culorii corespunzatoare unui pixel din imagine, imaginea texturii este esantionata cu o frecventa de esantionare data de inversul dimensiunii pre-imaginii pixelului n planul texturii.

56

Pre-imagine pixel

Pixel

Poligon Textura Fig. 5.2 Pre-imaginea unui pixel n spatiul texturii.

Daca nu se efectueaza filtrarea texturii, atunci se atribuie pixelului culoarea texelului cel mai apropiat de centrul pre-imaginii acestuia. Probelemele de aliasing care apar n aceasta situatie sunt foarte grave, mai ales pentru imaginile suprafetelor privite n perspectiva, n care variaza mult dimensiunea pre-imaginii pixelilor. Pentru filtrarea texturii, se foloseste un filtru trece-jos, aproximat cu fereastra Fourier pe o distanta inter-pre-imagine pixel, iar integrala de convolutie este o medie ponderata a tuturor texelilor acoperiti de pre-imaginea pixelului. n fig. 5.2, culoarea care se atribuie pixelului marcat se obtine prin medierea ponderata a intensitatii culorilor celor patru texeli acoperiti partial de pre-imaginea pixelului. Aria pre-imaginii unui pixel n planul texturii depinde de pozitia suprafetei fata de punctul si directia de observare. Daca suprafata se apropie de punctul de observare, atunci imaginea suprafetei pe ecran creste si este compusa dintr-un numar mai mare de pixeli care acopera acelasi numar de texeli, deci preimaginea unui pixel scade iar frecventa de esantionare a texturii creste. n aceasta situatie nu apare zgomot de aliasing, dar imaginea nu devine mai buna, deoarece se observa discontinuitatile de trecere de la un texel la altul. Aceasta situatie se datoreaza faptului ca textura nu este o imagine continua, ci este reprezentata prin elemente discrete (texelii) si, pentru a obtine imagini mai bune, ar trebui crescut numarul de texeli ai texturii (rezolutia texturii). Daca suprafata se departeaza de punctul de observare, atunci imaginea suprafatei pe ecran scade si este compusa dintr-un numar mai mic de pixeli care acopera acelasi numar de texeli, deci preimaginea unui pixel creste iar frecventa de esantionare a texturii scade. n aceasta situatie apare zgomot de aliasing, daca nu se efectueaza filtarea imaginii texturii. Filtrarea se executa ntr-o fereastra Fourier pe dimensiunea pre-imaginii unui pixel n planul texturii, si se efectueaza prin medierea ponderata a intensitatilor tuturor texelilor acoperiti de pre-imaginea pixelului. Efectul de aliasing al texturii este deosebit de suparator, mai ales pentru texturi repetitive aplicate suprafetelor privite n perspectiva. Zgomotul n spectrul de joasa frecventa prin care se manifesta suprapunerea n spectrul frecventelor spatiale nalte creeaza un aspect de moaraj al texturii nefiltrate. Filtre variabile n spatiu. Pentru suprafetele observate n perspectiva, dimensiunea preimaginii pixelilor variaza chiar n cuprinsul suprafetei, crescnd cu cresterea distantei de observare. Acest lucru nseamna ca filtrarea texturii trebuie sa fie realizata cu o fereastra de filtrare de dimensiune variabila. Implementarea filtrelor variabile n spatiu (space-variant filter) a fost abordata de mai multi cercetatori, folosindu-se aproximarea cu un patrulater sau cu o elipsa a ariei n spatiul texturii asupra careia opereaza filtrul. Implementarea filtrelor variabile n spatiu are un timp de executie ridicat si variabil n functie de aria pre-imaginii pixelilor. Folosind aceasta metoda, filtrarea texturilor de dimensiuni mari (cu numar mare de texeli) care se aplica unor suprafete reprezentare ntr-o zona mica pe ecran (numar mic de pixeli) este foarte costisitoare. Alte tehnici, cum este tehnica de prefiltrare a imaginii texturii, sunt mult mai eficiente si independente de aria suprafetelor texturare. Prefiltrarea texturilor. Procedeul de filtrare a texturii poate fi accelerat datorita faptului ca imaginea care se filtreaza (textura) este cunoscuta si se pot construi imagini prefiltrate ale acesteia. n loc sa se efectueze medierea pe suprafata mai multor texeli atunci cnd pre-imaginea pixelului acopera un numar mare de texeli, se poate folosi o imagine de textura prefiltrata, cu rezolutie mai scazuta, n care culoarea fiecarui nou texel reprezinta media culorilor texelilor din textura originala (fig. 5.3). Prin

57

prefiltrarea texturii se reduce frecventa spatiala maxima a texturii, n acelasi raport cu reducerea frecventei de esantionare, data de inversul dimensiunii pre-imaginii pixelilor.
Textura originala Textura prefiltrata

Pixel

Poligon Fig. 5.3 Prefiltrarea texturilor.

O tehnica eleganta de prefiltrare a texturilor, care are o mare popularitate si numeroase implementari hardware n acceleratoarele grafice, este tehnica numita mip-map, dezvoltata de Wiliams n 1983. n loc sa fie folosita o singura imagine de textura, n tehnica mip-map se foloseste o succesiune de imagini ale aceleiasi texturi, toate derivate din imaginea originala, prin medierea culorilor si reducerea rezolutiei. Fiecare imagine din succesiune are o rezolutie egala cu jumatatera rezolutiei imaginii precedente si fiecare texel este media a patru texeli din imaginea precedenta.. Termenul mip provine din expresia multum in parvo (multe lucruri ntr-un spatiu restrns). Parametrul L este parametrul de selectie a nivelului de filtrare a texturii. Nivelul L = 0 reprezinta imaginea originala a texturii (imaginea nefiltrata) cu rezolutia maxima. n general, n tehnica mip-map se folosesc rezolutii egale pe cele doua coordonate s si t, cu valoare o putere a lui 2, iar imaginile prefiltrate au rezolutii care scad prin njumatatire pna la valoarea 1 1. Prin selectia nivelului de filtrare a texturii (L), se alege imaginea cu rezolutia cea mai potrivita pentru dimensiunea pre-imaginii pixelului. Pentru evitarea discontinuitatilor ntre imagini la rezolutii diferite, se pot combina doua nivele de filtrare prin interpolare liniara. Selectia corecta a nivelului L este importanta. Daca L este prea mare, imaginea apare estompata; daca L este prea mic, atunci se observa zgomotul de aliasing. Nivelul L se alege astfel ca aria pre-imaginii pixelului sa fie ct mai apropiata de aria texelului. Detaliile de executie ale prefiltrarii folosind texturi mip-map depind de implementarea specifica, hardware sau software. n subcapitolul urmator sunt prezentate functiile bibliotecii OpenGL prin care se pot programa aplicatii grafice folosind texturarea suprafetelor.

5.3

FUNCTII OPENGL DE TEXTURARE

Biblioteca OpenGL permite texturarea obiectelor, oferind suport pentru un numar foarte mare de posibilitati de definire, aplicare si filtrare a texturilor. n lucrare vor fi prezentate numai o parte dintre aceste posibilitati, ca exemplificare a modului de implementare a texturarii si ca baza de pornire n crearea aplicatiilor grafice. Celelate aspecte, mai de detaliu, se pot urmari n manualul de referinta al bibliotecii, precum si n numeroasele exemple care sunt disponibile n OpenGL si GLUT. Se pot defini texturi unidimensionale sau bidimensionale, cu diferite rezolutii (numar de texeli) care se specifica la crearea imaginii texturii. Fiecare texel consta din una, doua, trei sau patru componente, reprezentnd valori de modulare sau cvadruple RGBA. Texturarea poate fi validata sau invalidata prin apelul functiei glEnable() respectiv glDisable(), cu argument una din constantele simbolice GL_TEXTURE_1D sau GL_TEXTURE_2D pentru texturi unidimensionale, respectiv bidimensionale.

5.3.1

DEFINIREA TEXTURILOR

n OpenGL se pot defini mai multe texturi (n general, la initializarea programului) si fiecare suprafata se textureaza folosind una dintre acestea. Fiecare textura (obiect textura - texture object) are un nume unic n program si este definita printr-un set de date care permit aplicarea acesteia

58

suprafetelor: adresa imaginii texturii, functia de texturare (modulare, nlocuire, combinare), si proprietatile texturii (filtrari, mod de repetare, etc). Posibilitatea de a manevra mai multe texturi n timpul executiei, fara sa fie necesar ncarcarea sau generarea imaginii texturii de fiecare data, mbunatateste performantele de texturare. n orice moment una din texturile definite este setata ca textura curenta, care se aplica tuturor suprafetelor redate, pna ce alta textura devine textura curenta. Numele texturilor. Numele texturilor sunt numere ntregi fara semn (de tipul GLuint) care sunt memorate ntr-un vector transmis ca argument functiei:
void glGenTextures(GLsizei n, GLuint *textureNames);

Aceasta functie creeaza un vector de nume de texturi, unice n program, pe care le memoreaza n vectorul textureNames. Numele create nu sunt neaparat numere succesive. Functia glGenTextures() creeaza numai numele texturilor si le marcheaza ca utilizate, dar obiectele textura se creeaza numai la conectarea (bind) acestora. Crearea texturilor. Functia glBindTexture() se foloseste att pentru crearea ct si pentru utilizarea unei texturi. Prototipul ei este:
void glBindTexture(GLenum target, GLuint texName);

Parametrul target poate avea ca valoare una din constantele simbolice GL_TEXTURE_1D sau GL_TEXTURE_2D pentru texturi unidimensionale, respectiv bidimensionale. Argumentul texName este numele unei texturi, generat de functia glGenTextures() si memorat n vectorul de nume ale texturilor. Atunci cnd este apelata prima oara pentru un nume de textura, functia glBindTexture() creeaza un nou obiect textura, cu toate datele referitoare la imaginea si proprietatile texturii implicite. Dupa apelul functiei glBindTexture(), textura cu numele dat ca argument devine textura curenta si toate operatiile ulterioare, att pentru definirea unor proprietati ale texturii, ct si pentru aplicatia texturii, folosesc textura curenta. Textura curenta se schimba prin apelul unei noi functii glBindTexture(). Crearea imaginii de textura . Imaginea texturii este un tablou unidimensional sau bidimensional de texeli, fiecare texel avnd una, doua, trei sau patru componente. Texturile unidimensionale au o utilizare restrnsa. Ele sunt folosite pentru texturarea n benzi, pentru care variatia culorii are o singura directie. n continuare se vor prezenta numai texturile bidimensionale, care sunt cel mai frecvent folosite. Imaginea texturii curente se poate crea prin apelul functiei glTexImage2D() (ai carei parametri sunt descrisi n documentatia MSDN) sau prin apelul functiei auxRGBImageLoad() care apartine unei biblioteci auxiliare din OpenGL, glaux.lib. Aceasta biblioteca este o versiune mai veche a sistemului de dezvoltare GLUT, dar, deoarece versiunea 3.6 a bibliotecii GLUT (n care au fost scrise programele), nu contine o functie de ncarcare a imaginilor de textura, s-a apelat functia din glaux.lib. Prin functii ale bibliotecii glaux.lib se pot ncarca imagini de textura n format RGB sau n format bitmap DIB (Device Independent Bitmap). Functii de texturare. Modul n care se calculeaza culoarea unui pixel (sau fragment de pixel) se stabileste prin apelul uneia din functiile glTexEnv#() :
void glTexEnvf(GLenum target,GLenum pname,GLfloat param); void glTexEnvi(GLenum target,GLenum pname,GLfloat param);

unde argumentele au urmatoarea semnificatie: target specifica mediul de aplicare a texturii; trebuie sa fie constanta simbolica GL_TEXTURE_ENV pname este numele simbolic al unui paramentru de mediu de texturare; trebuie sa aiba valoarea GL_TEXTURE_ENV_MODE param specifica functia de texturare printr-o constanta simbolica care poate lua una din valorile GL_MODULATE, GL_DECAL, sau GL_BLEND.

59

Functiile de texturare stabilesc modul de calcul al culorii rezultante a pixelilor pe baza culorii texelilor din imaginea de textura si a culorii pixelilor primitivei geometrice (care se obtin din culoarea curenta sau din calcule de umbrire). n modul GL_DECAL, culoarea finala atribuita unui pixel este culoarea texturii. n modul GL_MODULATE se foloseste culoarea texturii pentru modularea culorii pixelilor; acesta culoare poate fi culoarea calculata prin iluminare si umbrire sau culoarea curenta (daca nu s-a validat iluminarea). n modul GL_BLEND se combina culoarea texturii cu culoarea fragmentului. Aceasta modalitate generala de atribuire a culorii depinde si de formatul intern al texturii, care se stabileste la crearea imaginii de textura. Modul de repetare al texturii. Daca toate valorile coordonatelor de texturare ale vrfurilor primitivelor grafice n planul texturii sunt cuprinse n intervalul [0,1], atunci textura este aplicata o singura data pe suprafata respectiva. Daca aceste valori depasesc intervalul [0,1], atunci textura poate fi repetata pe suprafata sau limitata la intervalul [0,1]. Proprietatea unei texturi de a fi repetata sau limitata se stabileste prin apelul uneia din functiile:
void glTexParameterf(GLenum target, GLenum pname, GLfloat param); void glTexParameteri(GLenum target, GLenum pname, GLint param);

n aceste functii, parametrul target reprezinta tipul texturii si poate lua una din constantele simbolice GL_TEXTURE_1D sau GL_TEXTURE_2D. Parametrul pname specifica numele simbolic al unei proprietati a texturii. si poate lua una din constantele: GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAX_FILTER, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T. Primele doua valori se refera la optiunile de filtrare ale texturii si vor fi prezentate n paragraful urmator. Urmatoarele valori, seteaza proprietatea de repetare a texturii pentru coordonata s, respectiv t. n acest caz, parametrul param poate fi GL_REPEAT pentru repetarea texturii, sau GL_CLAMP pentru limitarea texturii la intervalul [0,1]. Filtrarea texturilor. Tipul de filtrare care se aplica unei texturi este definit prin valorile a doi parametri, GL_TEXTURE_MAG_FILTER si GL_TEXTURE_MIN_FILTER. setati prin apelul functiei glTexParameter#(). Filtrarea de marire (magnification, GL_TEXTURE_MAG_FILTER) se aplica atunci cnd dimensiunea pre-imaginii pixelului este egala sau mai mica dect dimensiunea texelului. Filtrarea de micsorare (minification, GL_TEXTURE_MIN_FILTER) se aplica atunci cnd dimensiunea pre-imaginii pixelului este mai mare dect dimensiunea texelului. Parametrul de filtrare GL_TEXTURE_MAG_FILTER poate lua numai una din valorile GL_NEAREST sau GL_LINEAR. Valoarea GL_NEAREST nseamna, de fapt, lipsa filtrarii: se selecteaza texelul cel mai apropiat de centrul pre-imaginii pixelului. Valoarea GL_LINEAR asigura filtrarea texturii prin calculul mediei ponderate a patru texeli cei mai apropiati de centrul pre-imaginii pixelului. Daca este implementata software, filtrarea texturii (GL_LINEAR) este executata mai lent dect esantionarea acesteia (GL_NEAREST). Filtrarea de micsorare este accelerata prin tehnica de prefiltrare a texturilor folosind imagini de texturi mip-map. Secventa de imagini ale texturii mip-map poate fi generata prin apelul functiei glTexImage2D() pentru fiecare nivel, ncepnd cu nivelul 0 (rezolutie maxima) pna la ultimul nivel, cu rezolutie 1 1. Datele fiecarei imagini (tabloul bidimensional de texeli) se obtin din imaginea precedenta prin nlocuirea fiecarui grup de patru texeli cu un texel a carui culoare este media culorilor celor patru texeli din imaginea precedenta. Daca s-a definit imaginea mip-map a texturii, atunci filtrarea de micsorare se poate realiza n mai multe moduri, depinznd de felul n care se selecteaza nivelul imaginii mip-map si de tipul de filtrare n imaginea mip-map selectata. Filtrul de micsorare (GL_TEXTURE_MIN_FILTER) este definit prin mai multe constante simbolice, dintre care cele mai importante sunt: GL_NEAREST: nu se aplica nici-o filtrare, se selecteaza texelul cel mai apropiat de centrul pre-imaginii pixelului din imaginea de nivel 0 a texturii mip-map; GL_LINEAR: se selecteaza imaginea de nivel 0 a texturii mip-map si se mediaza ponderat patru texeli cei mai apropiati de centrul pre-imaginii pixelului; GL_LINEAR_MIPMAP_LINEAR: se selecteaza doua imagini mip-map n care preimaginea pixelului are dimensiunea cea mai apropiata de imaginea texelului; n fiecare

60

din aceste imagini se selecteaza cte un texel dupa criteriul GL_LINEAR (media ponderata a patru texeli cei mai apropiati de centrul pre-imaginii pixelului) si aceste valori se mediaza ponderat pentru obtinerea valorii finale a culorii pixelului. Filtrarea GL_LINEAR_MIPMAP_LINEAR, care se mai numeste si filtrare triliniara, este cel mai eficient mod de eliminare a zgomotului de aliasing al texturii, dar si cel mai costisitor din punct de vedere al puterii de calcul. Chiar din simpla enumerare a operatiilor efectuate, se poate observa cantitatea de calcule extrem de mare necesara pentru fiecare pixel al imaginii generate. Filtrarea triliniara a texturilor genereaza imagini deosebit de realiste, dar este fie lenta, daca este executata software, fie costisitoare, daca este implementata hardware.

5.3.2

ATRIBUIREA COORDONATELOR DE TEXTURARE

Pentru ca o textura sa fie aplicata pe o suprafata, trebuie sa fie calculate si transmise bibliotecii OpenGL coordonatele fiecarui vrf al suprafetei n planul (s, t) al texturii. Coordonatele curente de texturare se transmit prin functiile glTexCoord#(), care pot primi 1, 2, 3 sau 4 argumente de diferite tipuri, rezultnd un numar mare de posibilitati de apel. O parte dintre acestea sunt:
void void void void glTexCoord1f(GLdouble glTexCoord2f(GLdouble glTexCoord3f(GLdouble glTexCoord4f(GLdouble s); s,GLdouble t); s,GLdouble t,GLdouble r); s,GLdouble t,GLdouble r,GLdouble q);

Coordonatele de texturare pot avea 1, 2 sau 3 valori pentru texturi unidimensionale, bidimensionale sau tridimensionale. n spatiul texturii, coordonatele sunt notate s, t, r, corspunzator coordonatelor x, y, z n spatiul obiect. Cea de-a patra componenta (q)este componenta de scala n reprezentarea texturii ntr-un sistem de coordonate omogen, asemanator sistemului de coordonate omogen folosit pentru reprezentarea punctelor n spatiu. Coordonatele de texturare se atribuie tuturor vrfurilor primitivelor care urmeaza (functiile glVertex#()) pna cnd se seteaza noi coordonate curente de texturare, prin apelul unei noi functii glTexCoord#().

Teme - Exercitii
5.1. Crearea imaginilor cu o singura textura. Daca n program se defineste o singura textura, atunci aceasta textura (cu numele implicit 0) este n permanenta textura activa si nu mai este necesara functia glBindTexture() pentru creare sau setare ca textura activa. Pasii necesari pentru crearea imaginilor cu o singura textura sunt urmatorii: A. Definirea texturii si a proprietatilor ei. Crearea imaginii de textura (A1) Se stabileste mai nti modul de aliniere a texelilor n memorie, la nivel de 1, 2 sau 4 octeti (prin functia glPixelStorei()); aceasta setare se face o singura data si ramne valabila pentru ntreg programul. (A2) Imaginea texturii curente (n acest caz, al singurei texturi definite) se obtine prin citirea unui fisier n format RGB sau BMP folosind functia auxRGBImageLoad(), care returneaza pointerul la o structura de tip AUX_RGBImageRec care contine toate datele imaginii de textura (dimensiunile si texelii). (A3) Din imaginea initiala se creeaza apoi imaginea mip-map prin apelul functiei gluBuild2DMipmaps(). Definirea proprietatilor texturii (A4) Modul de texturare se stabileste prin apelul functiei void glTexEnvf(). Se poate folosi unul din modurile GL_DECAL, GL_MODULATE sau GL_BLEND.

61

(A5) Modul de repetare al texturii se stabileste prin apelul functiei glTexParameterf() cu al doilea argument GL_TEXTURE_WRAP_S (pentru modul de repetare pe axa s a texturii) sau GL_TEXTURE_WRAP_T (pentru modul de repetare pe axa t a texturii). La depasirea intervalului [0, 1], textura este repetata sau limitata, n functie de valoarea celui de-al treilea argument (GL_REPEAT, respectiv GL_DECAL). (A6) Modul de filtrare a texturilor: pentru filtrul de marire (GL_TEXTURE_MAG_FILTER) se poate folosi unul din modurile GL_NEAREAST sau GL_LINEAR, dat ca argument functiei glTexParameterf(); pentru filtrul de micsorare (GL_TEXTURE_MIN_FILTER) se poate folosi unul din modurile GL_NEAREAST, GL_LINEAR, sau GL_LINEAR_MIP_MAP_LINEAR dat ca argument functiei glTexParameterf(). (A7) Validarea texturarii prin apelul functiei glEnable(GL_TEXTURE). Toate aceste setari se pot face n partea de initializare a programului (functia Init() ntr-un GLUT) care va arata n felul urmator:
AUX_RGBImageRec *image; void Init(){ . .. // Definire imagine de textura glPixelStorei(GL_UNPACK_ALIGNMENT, 1); image = auxRGBImageLoad("../../textures/floor.rgb"); gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image->sizeX, image->sizeY, GL_RGB, GL_UNSIGNED_BYTE, image->data); // Definire mod de texturare glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); // Definire mod de repetare al texturii glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Definire filtre de texturare glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // Validare texturare glEnable(GL_TEXTURE_2D); }

Daca n cursul programului (n comenzile de interfata) se doreste modificarea uneia din proprietatile texturii, se apeleza functia de setare adecvata. si textura va capata noua proprietate imediat. B. Definirea coordonatelor de texturare n vrfuri. Pentru exemplul simplu al unui patrat, coordonatele de texturare se pot deduce usor din coordonatele vrfurilor, iar functia de desenare a patratului (DrawRectangle()) va fi modificata astfel:
void DrawRectangle(){ glBegin(GL_POLYGON); glTexCoord2f(0,0); glVertex3f(-1.0,-1.0, 0.0); glTexCoord2f(1, 0); glVertex3f( 1.0,-1.0, 0.0); glTexCoord2f(1,1); glVertex3f( 1.0, 1.0, 0.0); glTexCoord2f(0,1); glVertex3f(-1.0, 1.0, 0.0); glEnd(); }

62

Binenteles, functia de redare va contine si normalele sau culorile n vrfuri, daca se doreste modularea texturii cu culoarea primitivei (modul GL_MODULATE). La executia programului se va obtine un patrat pe care este aplicata textura din fisierul folosit. Observati diferenta dintre modurile de texturare GL_MODULATE si GL_DECAL, prin setarea corespunatoare a parametrilor. 5.2. Studierea modului de filtrare al texturii. n programul de generare al imaginii cu textura introduceti comenzi (de meniu sau n bara de dialog n proiectele MFC sau comenzi de tastatura n proiectele GLUT) pentru schimbarea parametrilor de filtrare (GL_NEAREST, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR). Observati influienta modului de filtrare asupra imaginii, mai ales atunci cnd suprafata este nclinata fata de directia de observare. 5.3. Crearea imaginilor cu mai multe texturi. n marea majoritate a cazurilor, pentru a obtine efecte de realism al imaginilor, se folosesc mai multe texturi si programele trebuie sa fie modificate n mod corespunzator. n orice moment al executiei (att la setarea parametrilor texturilor, ct si la aplicatia texturii) se foloseste textura curenta care este setata prin functia glBindTexture(). Pentru crearea mai multor texturi si aplicarea lor suprafetelor obiectelor se procedeaza n felul urmator: A. Definirea texturilor si a proprietatilor lor. (A1) Se creeaza numele obiectelor de textura prin apelul functiei glGenTextures(), al carui prim parametru este numarul de texturi necesare. (A2) Pentru fiecare textura n parte se stabilesc proprietatile de texturare (imaginea texturii, functia de texturare, modul de repetare si filtrele de marire si micsorare), la fel ca n exemplul cu o singura textura. Pentru aceasta se seteaza textura respectiva ca textura curenta (prin functia glBindTexture()), iar toate functiile de setare a proprietatilor care urmeaza se vor referi la textura curenta. (A3) Validarea texturarii prin apelul functiei glEnable(GL_TEXTURE). Aceste operatii se fac, de regula n functia de initializare care va arata astfel:
AUX_RGBImageRec *image[2]; // pointeri la imaginile celor 2 texturi GLuint texName[2]; // vectorul de nume al celor 2 texturi void Init(){ .. // Se definesc 2 texturi glGenTextures(2,texName); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // Definirea proprietatilor primei texturi glBindTexture(GL_TEXTURE_2D,texName[0]); image[0] = auxRGBImageLoad("../../textures/floor.rgb"); gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image[0]->sizeX, image[0]->sizeY,GL_RGB, GL_UNSIGNED_BYTE, image[0]->data); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // Definirea proprietatilor celei de-a doua texturi glBindTexture(GL_TEXTURE_2D,texName[1]); image[1] = auxRGBImageLoad("../../textures/girl.rgb"); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image[1]->sizeX, image[1]->sizeY,GL_RGB, GL_UNSIGNED_BYTE, image[1]->data); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);

63

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // Validarea texturarii glEnable(GL_TEXTURE_2D); }

Daca n cursul programului (n comenzile de interfata) se doreste modificarea unei proprietati ale uneia dintre texturi, se seteaza mai nti acea textura ca textura curenta (prin functia glBindTexture()) si dupa aceea se efectueaza setarile dorite. B. Activarea texturii corespunzatoare fiecarei suprafete n cursul redarii. n functia de redare se activeaza textura care va fi aplicata suprafetei respective prin apelul functiei glBindTexture() cu argumentul corespunzator. n exemplul urmator se creeaza o scena cu doua suprafete (patrat), fiecare redata cu una din cele doua texturi definite.
void Display(){ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); // Transformarea de observare glRotatef(-angleZv, 0.0,0.0,1.0); glRotatef(-angleXv, 1.0,0.0,0.0); glRotatef(-angleYv, 0.0,1.0,0.0); glTranslatef(-Xv, -Yv, -Zv); // se initializeaza Zv = 5; // Transformare de modelare (pozitionare) obiecte din scena glTranslatef(Xs,Ys,Zs); glRotatef(angleYs, 0.0,1.0,0.0); glRotatef(angleXs, 1.0,0.0,0.0); glRotatef(angleZs, 0.0,0.0,1.0); // Redarea primei suprafete cu prima textura glPushMatrix(); glTranslatef(-1.5f,0,0); // Transformarea de modelare glBindTexture(GL_TEXTURE_2D, texName[0]); DrawRectangle(); glPopMatrix(); // Redarea celei de-a doua suprafete cu cealalalta textura glPushMatrix(); glTranslatef(1.5f,0,0); // Transformarea de modelare glBindTexture(GL_TEXTURE_2D, texName[1]); DrawRectangle(); glPopMatrix(); glPopMatrix(); glFinish(); glutSwapBuffers(); }

Functia DrawRectangle() este cea definita la primul punct al lucrarii, care contine apelurile functiilor de coordonate de texturare glTexCoord#(). 5.4. Modificati functia de redare a cubului (DrawCube()) astfel nct pe fiecare fata a cubului sa fie aplicata alternativ cte una din cele doua texturi definite. 5.5. Adaugati structurile de date necesare pentru memorarea coordonatelor de texturare ale vrfurilor poligonului regulat modelat n lucrarile precedente si modificati functia de redare a poligonului (DrawPolygon()) astfel nct sa obtineti un poligon texturat. Introduceti un parametru (care sa poata fi modificat printr-o comanda) care sa seteze numarul de repetari a texturii pe suprafata poligonului. 5.6. n mod asemanator, calculati si introduceti coordonatele de texturare n modelul piramidei si modificati functia de redare a acesteia (DrawPyramid()) astfel nct sa obtineti o piramida n care fetele sa fie texturate.
64