OpenGL megjelenítési listák

Az előadások a következő témára: "OpenGL megjelenítési listák"— Előadás másolata:

1 OpenGL megjelenítési listák

2 OpenGL display list Lista: olyan OpenGL parancsok csoportja, amelyet a rendszer lefordított (compiled) formában tárol Nem minden hívás tárolható listákban Nem mindig érhető el jelentős sebességnövekedés

3 Példa 1. void kirajzol(void) {
glClearColor (0.5f, 0.5f, 0.5f, 0.0f); // szürke szín glClear (GL_COLOR_BUFFER_BIT); // képernyőtörlés int points = 100; glBegin(GL_LINE_LOOP); for (int i = 0; i < points; i++) float szog = 2 * PI * i / points; glVertex2f(cos(szog), sin(szog)); } glEnd(); glFlush(); Nem hatékony módszer, mivel minden fázis kirajzolásánál újra kell számolni a vertexeket.

4 Példa 2. int points = 100; float korkoords[points][2];
void kirajzol(void) { glClearColor (0.5f, 0.5f, 0.5f, 0.0f); // szürke szín glClear (GL_COLOR_BUFFER_BIT); // képernyőtörlés glBegin(GL_LINE_LOOP); … // korkoords feltöltése for (int i = 0; i < points; i++) glVertex2fv(&korkoords[i][0]); // vektoros forma } glEnd(); glFlush(); Hatékonyabb módszer, de a ciklust nem lehet kikerülni ebben az esetben sem.

5 Megoldás listával int points = 100; void listakeszites(void) {
glNewList(1, GL_COMPILE); glBegin(GL_LINE_LOOP); for (int i = 0; i < points; i++) float szog = 2 * PI * i / points; glVertex2f(cos(szog), sin(szog)); } glEnd(); glEndList(); void kirajzol { glCallList(1); // csak 1 függvényhívás!

6 Listatervezési filozófia
A listák specifikálásának fő oka az OpenGL hálózatban történő gyors működtetése volt kliens-szerver modell esetén a kliens nem küldi el a teljes geometriát, csak a megjelenítési lista sorszámát Az OpenGL megjelenítési lista nem dinamikus adatstruktúra Létrehozás után nem módosítható Ha lehetne módosítani, nagymértékű teljesítmény csökkenést tapasztalnánk. Dinamikus allokáció de-allokáció memória „töredezettséghez” vezethet. Legalább olyan gyors, mint a közvetlen mód. (immediate-mode) A sebességnövekedés függ az adott implementációtól

7 Listatervezési filozófia
A legvalószínűbb optimálási lehetőségek: Mátrix operációk szükség van mátrixok inverzének számítására, listás tárolás esetén az előre kiszámított inverz tárolódik, nem kell kiszámítani. Bittérképek ezek megadásakor az eredeti formátum (általában) nem optimális az adott videohardver szempontjából Anyagtulajdonságok, megvilágítási modellek anyagtulajdonságok és komplex megvilágítások definiálásakor jelentős a számítási igény Textúrák hasonló okok miatt érdemes használni, mint a bittérképek esetén számos modern videohardver támogatja a textúra tömörítést

8 Feladat glRotatef(45, 1.0, 0.0, 0.0); glNewList(1, GL_COMPILE); geometriarajzolas(); glEndList(); glRotatef(45, 1.0, 0.0, 0.0); glCallList(1); glNewList(1, GL_COMPILE); glRotatef(45, 1.0, 0.0, 0.0); geometriarajzolas(); glEndList(); glCallList(1); Mi a különbség a két megoldás között? Melyik megoldás gyorsabb? Mi a hátránya a második megoldásnak?

9 Megjelenítési listák hátrányai
A lista nem módosítható float c[3] = {1.0,1.0,1.0}; glNewList(1,GL_COMPILE); glColor3fv(c); glEndList(); c[0]=0.0; // mi történik ekkor? Léteznek memóriakorlátok A listák számozása okozhat nehézségeket Nagyobb rugalmasságot és egyszerűbb menedzselhetőséget ad a vertex-tömbök alkalmazása. (vertex-arrays)

10 Egyszerű példa GLuint listName; void display(void) void init (void) {
listName = glGenLists (1); glNewList (listName, GL_COMPILE); glColor3f (1.0, 0.0, 0.0); glBegin (GL_TRIANGLES); glVertex2f (0.0, 0.0); glVertex2f (1.0, 0.0); glVertex2f (0.0, 1.0); glEnd (); glTranslatef (1.5, 0.0, 0.0); glEndList (); glShadeModel (GL_FLAT); } void drawLine (void) glBegin (GL_LINES); glVertex2f (0.0, 0.5); glVertex2f (15.0, 0.5); void display(void) { GLuint i; glClear (GL_COLOR_BUFFER_BIT); glColor3f (0.0, 1.0, 0.0); for (i = 0; i < 10; i++) glCallList (listName); drawLine (); glFlush (); } void reshape(int w, int h) glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (w <= h) gluOrtho2D (0.0, 2.0, -0.5 * (GLfloat) h/(GLfloat) w, 1.5 * (GLfloat) h/(GLfloat) w); else gluOrtho2D (0.0, 2.0 * (GLfloat) w/(GLfloat) h, , 1.5); glMatrixMode(GL_MODELVIEW);

11 Listákkal kapcsolatos függvények
GLuint glGenLists(GLsizei n) n darab listát generál a visszatérési értéktől kezdődően. Ha i a visszatérési érték: i … (i+n-1) a listák azonosítói. listindex=glGenLists(1); if(listindex!=0) {glNewList(listindex, GL_COMPILE);…} GLboolean glIsList(GLuint list) GL_TRUE, ha a lista azonosító már foglalt, GL_FALSE ha nem void glNewList(GLuint list, GLenum mode) mode: GL_COMPILE , GL_COMPILE_AND_EXECUTE void glEndList() void glCallList(GLuint list) void glDeleteLists(GLuint list, GLsizei n)

12 Mi nem tárolható megjelenítési listában?
glDeleteLists() glIsEnabled() glFeedbackBuffer() glIsList() glFinish() glPixelStore() glFlush() glReadPixels() glGenLists() glRenderMode() glGet*() glSelectBuffer() Az ok legtöbbször a kliens-szerver architektúrában keresendő. pl. glReadPixels() – mit olvasna?

13 Állapotváltozások perzisztenciája
glNewList(1,GL_COMPILE); glColor3f(1.0, 0.0, 0.0); glBegin(GL_POLYGON); glVertex(); … glEnd(); glTranslatef(10.0,10.0,10.0); glEndList(); A listában letárolásra kerülnek az állapotgép attribútumai, pl. színek, transzformációs mátrixok. A glCallList() alkalmazásakor zavaró lehet a piros színre váltás és az eltolás Már megtanultuk, hogy a transzformációs mátrixok lementhetőek a glPush/PopMatrix()-al.

14 Állapotváltozások perzisztenciája
glNewList(1,GL_COMPILE); glPushMatrix(); glPushAttrib(GL_CURRENT_BIT); glColor3f(1.0, 0.0, 0.0); glBegin(GL_POLYGON); glVertex(); … glEnd(); glTranslatef(10.0,10.0,10.0); glPopAttrib(); glPopMatrix(); glEndList(); A glPush/PopAttrib() pár lementi az állapotgép attribútumait. GL_CURRENT_BIT paraméter többek között a színinformációkat menti.

15 Hierarchikus megjelenítési listák
Egy megjelenítési listán belül meghívhatunk más listákat is glCallList()-el. glNewList (listindex, GL_COMPILE); // összetett alkatrész glCallList (part1); glCallList (part2); glCallList (part3); glTranslatef(…); glCallList (part3); glEndList(); A listák mélysége minimum 64 és implementáció függő. glGetIntegerv(GL_MAX_LIST_NESTING, GLint *);

16 Hierarchikus megjelenítési listák
A listák hierarchikus rendezésével dinamikus listákat is képezhetünk. glNewList(1, GL_COMPILE); glVertex3fv(v1); glEndList(); glNewList(2, GL_COMPILE); glVertex3fv(v2); glEndList(); glNewList(3, GL_COMPILE); glVertex3fv(v3); glEndList(); glNewList(4, GL_COMPILE); glBegin(GL_POLIGON); glCallList(1); glCallList(2); glCallList(3); glEnd(); glEndList(); Poligon rendereléshez a 4. listát kell meghívni. Vertexek módosításához az 1..3 listákat újra lehet definiálni.

17 Rugalmasabb vertex tömbök alkalmazása
void glVertexPointer( GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer ); Paraméterek: size Koordináták száma: 2, 3 vagy 4. type Koordináták adatípusa: GL_SHORT, GL_INT, GL_FLOAT vagy GL_DOUBLE. stride Byte offset. 0 estén a vertexek sorban vannak a tömbben count vertexek száma pointer pointer az első elemre

18 Rugalmasabb vertex tömbök alkalmazása
void glDrawArrays( GLenum mode, GLint first, GLsizei count ); mode Geometriai primitív fajtája: GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES, GL_QUAD_STRIP, GL_QUADS, and GL_POLYGON. first kezdő index count a kirajzolandó elemszám

19 Rugalmasabb vertex tömbök alkalmazása
float *kor; int points = 100; void init() { kor = new float [points * 2]; // memória foglalás for (int i = 0, j = 0; i < points; i++) // tömb feltöltése float szog = 2 * PI * i / points; kor[j] = cos(szog); kor[j+1] = sin(szog); j+=2; } void kirajzol(void) glClearColor (0.5f, 0.5f, 0.5f, 0.0f); // a szokásos  glClear (GL_COLOR_BUFFER_BIT); glVertexPointer(2, GL_FLOAT, 0, kor); // tömb struktúra megadása glEnableClientState(GL_VERTEX_ARRAY); // a vertex array használható glDrawArrays(GL_LINE_LOOP, 0, points); // kirajzolás glFlush();

20 Rugalmasabb vertex tömbök alkalmazása
Összetettebb példa: glColorPointer(), glNormalPointer() használatára: glNormalPointer(GL_SHORT, 0, normals); // normálvektorok tömbje glVertexPointer(3,GL_FLOAT,0, vertices); // vertexek tömbje glEnableClientState(GL_NORMAL_ARRAY); // bekapcsolás glEnableClientState(GL_VERTEX_ARRAY); glDrawArrays(GL_TRIANGLES, 0, db); // kirajzolás

21 Listakezelő osztály C++ nyelven
Példa osztályok: CTriangleObject SObjectIndex Funkciók: Slp fájl betöltése: LoadObject() Listakészítés és megjelenítés egy függvénnyel Show()

22 Listakezelő osztály C++ nyelven
SLP formátum: (Pro/Engineer) példa: solid PRT # partfájl név color # szín facet # háromszög jön normal e e e+000 outer loop # kifelé mutató normálvektor vertex e e e+002 vertex e e e+002 vertex e e e+002 endloop endfacet

23 Standard Template Library (STL) alkalmazása
Az STL segít a dinamikus memória objektumok (tömbök, listák, sztringek, stb.) létrehozásában: vector<short int> normal; normal.push_back(1); //feltöltés normal.push_back(2); for(int i=0; i < normal.size(); i++) { do_something(normal[i]); // kiolvasás } normal.clear(); // törlés #include <vector>

24 Színek A látható fény nm hullámhossz tartományban helyezkedik el A fehér fény egyenlő mértékben tartalmaz minden frekvenciát A lézer fény azonos frekvenciájú fényt tartalmaz A számítógépek monitorai a színeket a piros, zöld és kék kombinációjaként emulálják

25 Színek RGBA – általában 4 bájt tartozik minden egyes pixelhez
Az ‘A’ (alpha) értéke az átlátszóságnál jut szerephez. A ‘color-index’ módban minden pixelhez egy számérték tartozik. Az értékhez tartozó szín ‘color-map’-ból jön. A color-map vezérlését az ablakozó rendszer végzi, nem az OpenGL. A color-index mód mára már kihalt.

26 RGBA és color-index módok
Mindkét esetben a megjeleníthető színek számát a ‘bitplane’-k száma határozza meg. A 24-bites képernyő 3x8 bitet enged meg színenként: egyenlően elosztva a három komponens között. A bitek száma lekérdezhető: glGetIntegerv() - GL_RED_BITS, GL_GREEN_BITS, GL_BLUE_BITS, GL_ALPHA_BITS A 255 a teljes intenzitás 0 a zéro intenzitás

27 Példa smooth.c

28 Dithering A színbitek korlátozott kapacitás miatt kvantálást kell alkalmazni. 0/255 … 255/255 A rendszer a színek számításait lebegőpontos alakban végzi, majd az eredményt tartományba kvantálja Ha a szín lassan változó akkor ugrásszerű változásokat tapasztalhatunk. A dithering a végső kvantálás előtt egy 0 várható értékű nagyfrekvenciás zajt kever a megjelenítendő színekhez, majd a zajos jelet kvantálja.

29 Dithering A végeredményként számolt színt, a zavarás és a kvantálás lefelé vagy felfelé kerekíti azzal a valószínűséggel, amennyire közel vagyunk a kvantálási szintekhez. A szem átlagolja a nagyfrekvenciás zajt és az átlagértéket, vagyis a tényleges színt érzékeli. glEnable vagy glDisable GL_DITHER; Néhány hardver dupla buffereléskor a bitplane-okat felezi bit.

30 Megvilágítás (lighting)

31 Lokális illuminációs algoritmusok
Adott pixelben látható felületi pont színe függ az adott pontból látható többi felülettől és azok fényerősségéből (radianciájából) számítható a pixel fényerőssége. A lokális illuminációs algoritmusok az árnyalási egyenlet drasztikus leegyszerűsítésén alapulnak. Nem veszik figyelembe a többi felület fényességét Megvilágítás csak a képen közvetlenül nem látható absztrakt fényforrásokból érkezhet Az absztrakt fényforrást minden pontból láthatóként kezelik

32 Lokális illuminációs algoritmusok
Illuminációs (megvilágítás) képlet: ahol: Az l. absztrakt fényforrásból az pontba az irányból érkező fényerősség. ambiens tag feladata, hogy az elhanyagolásokat kompenzálja. A felület által kibocsátott fény

33 Árnyalási modellek (shading modells)
Saját színnel történő árnyalás (nem árnyékolás!) 2D képszintézis árnyalási módszerének direkt alkalmazása. Nem igényel számítást, nem térhatású a keletkezett kép. Konstans árnyalás: glEnable(GL_FLAT) A poligonokra csak egyszer számítja ki a fényforrások hatását. Minden poligon egy színnel lesz árnyalva. Gourand-árnyalás: glEnable(GL_SMOOTH) Phong-árnyalás

34 Gourand-árnyalás A háromszögek csúcspontjában értékeli ki a fényforrásokból odajutó fény visszaverődését. Az eredeti felület normálvektoraival dolgozik. A háromszög belső pontjainak színét a csúcspontok színéből lineárisan interpolálja. Akkor ad helyes eredményt, ha a háromszögön belüli szín valóban közelítően lineárisan változik.

35 Phong árnyalás Az illuminációs képletben felhasznált normálvektort interpolálja a háromszög csúcspontjában érvényes normálvektorokból. Az illuminációs képletet pedig minden pixelre külön határozza meg. Ez nemlineáris árnyalásnak felel meg. A Phong árnyalás a Gourand árnyalás olyan határesete, amikor a poligonok vetített területe 1 pixel méretű.

36 Fénytípusok Emmited light: kibocsátott fény, objektumok által kibocsátott fény. Ambient light: környezeti fény, nem lehet az irányát meghatározni, pl: borús, felhős időben is van fény, de az iránya nem meghatározott. Diffuse light: fényforrásból jön. Specular light: visszavert fény

37 RGB értékek fény és anyagok esetén
Anyagok esetén R=1, G=0.5, B=0 azt jelenti, hogy a tárgy visszaveri a piros színt a zöldet félig, a kéket pedig teljesen elnyeli. Ha megvilágítjuk a tárgyat LR, LG, LB színű fénnyel: az eredő fény (LR*R, LG*G, LB*B) színű lesz. (pl. LR=0,LG=0,B=1 esetén nem látunk semmit!) Több fényforrás esetén: (R1, G1, B1) és (R2, G2, B2) = (R1+R2, G1+G2, B1+B2). Ha az érték nagyobb mint 1, akkor a rendszer 1-re kerekít.

38 Fényforrások létrehozása
Alapvető tulajdonságok: szín, helyzet, irány. glLight*() segítségével minden tulajdonság állítható: void glLight{if}[v](GLenum light, GLenum pname, TYPE param); light: GL_LIGHT0, GL_LIGHT1, … GL_LIGHT7 pname: tulajdonság kiválasztása param: az adott tulajdonságtól függő paraméter

39 Alapértelmezett érték
Paraméter neve Alapértelmezett érték Jelentés GL_AMBIENT (0.0,0.0,0.0,1.0) Ambiens (környezeti) RGB intenzitás GL_DIFFUSE (1.0,1.0,1.0,1.0) Diffuse (szórt) RGB intenzitás GL_SPECULAR Specular (visszavert) RGB intenzitás GL_POSITION (0.0,0.0,1.0,0.0) fényforrás (x,y,z,w) helyzet GL_SPOT_DIRECTION (0.0,0.0,-1.0) (x,y,z) irány GL_SPOT_EXPONENT 0.0 exponent GL_SPOT_CUTOFF 180.0 szög GL_CONSTANT_ATTENUATION 1.0 elhalványodási faktor GL_LINEAR_ATTENUATION GL_QUADRATIC_ATTENUATION

40 Példa fényforrás float light_ambient[] = {0.0,0.0,0.0,1.0}; float light_diffuse[] = {1.0,1.0,1.0,1.0}; float light_specular[] = {1.0,1.0,1.0,1.0}; float light_postion[] = {1.0,1.0,1.0,0.0}; glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_POSITION, light_position);

41 Fényforrás pozíciója két alapvető típus: directional light – positional light GL_POSITION paraméter (x, y, z, w) negyedik értéke határozza meg a típust. w=0 – directional light w=1 – position light alapértelmezett értéke: (0,0,1,0), amely negatív z irányú fényt jelent. megadható (0,0,0) irányú (directional) fényforrás is. (de értelmetlen)

42 Fényforrás gyengülése (attenuation)
ahol: d - távolság a fényforrás és a vertex között kc - GL_CONSTANT_ATTENUATION kl – GL_LINEAR_ATTENUATION kq – GL_QUADRIC_ATTENUATION Csak ‘positional’ fényforrásokra van hatással! A kibocsátott és a globális ambiens fényre nincs hatással.

43 Fényszórók (spotlights)
Tulajdonságok: félkúpszög, intenzitás eloszlás. GL_SPOT_CUTOFF: 0..90, 180 az alapértelmezett értéke, ami a kikapcsolást jelenti. GL_SPOT_DIRECTION: a fénysugár irányát adja meg GL_SPOT_EXPONENT: intenzitás eloszlás érték

44 Paraméterek gyakorlati beállításai
Figyeljük meg: Light_pos negyedik paraméterállításának hatása jobb egérgomb, majd spotlight attenuation CUTOFF szög, EXPONENT a három ATTENUATION faktor hatása

45 Fényforrások helyzete
A fényforrásokon ugyanolyan mátrix transzformációk mennek végbe, mint a geometriai primitíveken. A projekciós mátrix nem befolyásolja a fényforrás irányát vagy a helyét. Háromféle hatás érhető el: A fényforrás pozíciója fix marad A fényforrás egy objektum körül mozog A fényforrás a nézőponttal együtt mozog

46 Fényforrások helyzete
A fényforrás pozíciója fix marad: glViewport (0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode (GL_PROJECTION); glLoadIdentity(); gluPerspective(40.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0); glMatrixMode(GL_MODELVIEW); … … később a init függvényben glLightfv (GL_LIGHT0, GL_POSITION, position); A fényforrás helyzete nem változik, mivel a pozíció az init() függvényben csak egyszer hívódik meg.

47 Fényforrások helyzete
A fényforrás egy objektum körül mozog void display(void) { GLfloat position[] = { 0.0, 0.0, 1.5, 1.0 }; glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glPushMatrix (); glTranslatef(0.0,0.0,-5.0); glRotatef (spin, 1.0, 0.0, 0.0); glLightfv(GL_LIGHT0, GL_POSITION, position); glPopMatrix(); glutSolidSphere(1.0,16,16); glPopMatrix (); … …

48 Fényforrások helyzete
A fényforrás a nézőponttal együtt mozog void display(void) { glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix (); glTranslatef(0.0,0.0,-5.0); glRotatef (spin, 1.0, 0.0, 0.0); glLightfv(GL_LIGHT0, GL_POSITION, position); glutSolidSphere(1.0,16,16); glPopMatrix(); glFlush(); } CAD és egyéb mérnöki rendszerek ezt a modellt alkalmazzák

49 Mozgó fényforrás (példa)
movelight.c

50 Megvilágítási modell OpenGL megvilágítási modellnek három komponense van: globális ambiens (szórt) fény lokális vagy végtelen nézőpont ‘kétoldalas’ megvilágítás (two-sided lighting)

51 Globális szórt fény 8 fényforrás adható meg, de ezen kívül egy globális szórt fényt is definiálhatunk, amely egyik fényforráshoz sem köthető: float lma [] = {0.2, 0.2, 0.2, 1.0}; glLightModelfv (GL_LIGHT_MODEL_AMBIENT, lma); Ha más fényforrás nincs megadva akkor globális szórt szürke lesz minden objektum a képernyőn! Próbáljuk ki az arnyalas.cpp mintafájlban!

52 Lokális vagy végtelen nézőpont
A visszaverődő fény számítása szempontjából a nézőpont helyzete meghatározó. A nézőpont, a fényforrás helyzete a vertex normálisa meghatározza a poligonok fényességét. (highlight) Végtelen távoli nézőpontot feltételezve vertexekkel bezárt szög konstans. Így gyorsabban számolhat a rendszer. De a képminőség gyengébb. glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); alapértelmezetten a rendszer végtelen távoli nézőpontot feltételez

53 Kétoldalas megvilágítás
Lehetőséget ad a poligonok mindkét oldalának (front and back face) megvilágítási tulajdonságainak megadására glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE); alapértelmezés szerint: GL_FALSE Az arnyalas.cpp display() függvényében próbáljuk ki a következőt: GLdouble egy1[4] = {1.0, 0.0, 0.0, 0.0}; glClipPlane(GL_CLIP_PLANE0, egy1); glEnable(GL_CLIP_PLANE0); majd a kétoldalas megvilágítással is próbáljuk ki!

54 Anyagtulajdonságok megadása
Anyagtulajdonságok a következő függvényhívás segítségével adhatjuk meg: glMaterial{if}[v](GLenum face, GLenum pname, GLenum param); face: GL_FRONT, GL_BACK, GL_FRONT_AND_BACK pname: a tulajdonság neve param: a tulajdonsághoz tartozó paraméter

55 Alapértelmezett érték
Paraméter neve Alapértelmezett érték Jelentés GL_AMBIENT (0.2,0.2,0.2,1.0) ambiens (környezeti) szín GL_DIFFUSE (0.8,0.8,0.8,1.0) diffuse (szórt) szín GL_AMBIENT_AND_DIFFUSE ambiens és diffuse szín együtt GL_SPECULAR (0.0,0.0,0.0,1.0) visszavert fény GL_SHININESS 0.0 fényesség (visszavert fény exponens) GL_EMISSION Kibocsátott szín GL_COLOR_INDEXES (0, 1, 0) Ambiens, diffuse, specular szín index

56 Diffuse és ambiens tulajdonságok
Egyik sem függ a nézőpont helyzetétől Gyakran egyforma értékűre állítják mindkét tulajdonságot A diffuse (szórt) tulajdonság határozza meg legjobban a színt float mat_amb_diff[]={0.1,0.5,0.8,1.0}; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff);

57 Visszatükröződés és kibocsátott fény
Visszatükröződés: float mat_specular[] = {1.0, 1.0, 1.0, 1.0}; float low_shininess[] = {5.0}; glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess); a shininess között változhat Kibocsátott fény: float mat_emission[] = {0.3,0.2,0.2,0.0}; glMatrialfv(GL_FRONT, GL_EMISSION, mat_emission); mat_emission a kibocsátott fény színe

58 ‘Tutorial’ alapján az anyagtulajdonságok gyakorlása
Feladatok önálló gyakorláshoz: 1. A fényforrás globális ambiens összetevőjét állítsuk (0.0,0.0,0.0,0.0)–ra. És a light_ka[]-t is állítsuk (0.0,0.0,0.0,0.0)-ra. 2. Figyeljük meg, hogy a material_ka[] változtatásának most nincs hatása. Miért? 3. Állítsuk be a light_Ka[] = {1.0,0.0,0.0,0.0}-t és így a material_Ka[] piros (red) összetevője megváltozásának hatását megfigyelhetjük. 4. Nullázzuk le a light_Ka és material_Ka vektorokat. 5. Állítsuk be a material_Ks[]={1.0,0.0,0.0,1.0} – ra. És állítsuk be a material_Se értékét 100-tól nagyobbra. 6. Változtassuk meg a material_Ke első paraméterét, vörösen ízzó tóruszt kapunk. Ha az attenuation értéket növeljük, akkor a kibocsátott szín jobban érvényesül. 7. szabadon próbáljunk beállítani tetszőleges tulajdonságokat.