példa vonal stílusra
Pont méret
A pontok mérete a
void glPointSize(float size);
eljárással állítható be. A size
specifikálja a pont méretét. Az alapértelmezett
érték 1.0. 0.0, vagy annál kisebb érték
a GL_INVALID_VALUE hibát generálja. Ha a pont mérete
1.0, akkor a pont pontosan egy pixelbõl fog állni. Ha a méret
2.0 akkor minden pontot egy 2×2-es négyzet reprezentál.
Furcsának tûnhet, hogy miért
lebegõpontos szám jelzi a pont méretét, ugyanis
ha az 1.0-ás méret jelenti az egy pixel nagyságot,
akkor hogyan tudunk pl. 2.5 pixelt rajzolni? Az OpenGL-ben azonban a pont
méret nem azt jelenti, hogy a pont pontosan ilyen széles
négyzet lesz, hanem azt, hogy a pontunk átlagos átmérõje
a pont mérettel egyezik meg.
Lehetõség van pont élsimítás
(antialiasing) használatára is, amely letiltható,
ill. engedélyezhetõ, ha a generikus glEnable
ill. glDisable
parancsot a POINT_SMOOTH szimbolikus konstanssal hívjuk meg. Alapértelmezés
szerint a pont élsimítás le van tiltva. Ha az élsimítás
le van tiltva, akkor a pixelek négyzet alakú régiója
rajzolódik ki; pl.: ha a szélesség 1.0, akkor egy
1×1-es négyzet, ha 2.0, akkor pedig egy 2×2-es négyzet
rajzolódik ki. Ha az élsimítás engedélyezett,
akkor a pixelek kör alakú régiója rajzolódik
ki, úgy, hogy a széleken lévõ pixelek intenzitása
kisebb, mint a középen lévõ pixeleké.
pl.:
glPointSize(5.0);
Pontok színe
Egy pont színét egyszerûen úgy tudjuk beállítani, hogy a pont specifikációja elõtt megadjuk a kívánt színt a glColor vagy a glIndex paranccsal.
pl.:
glBegin(GL_POINTS);
glColor3d(1.0,1.0,1.0);
glVertex3d(0.0,1.0,0.0);
glEnd();
egy fehér pontot specifikál a (0.0,1.0,0.0) koordinátákba
Szakasz vastagság
A szakaszok a szakasz sorozat (GL_LINE_STRIP), szakasz hurok (GL_LINE_LOOP) illetve független szakasz (GL_LINES) Begin/End objektumokból származnak. A raszterizált szakasz szélességét a
void glLineWidth(float width);
paranccsal állíthatjuk be, úgy, hogy width-ben
megadjuk a kívánt szélességet. Az alapértelmezett
szélesség 1.0. Ha width
<= 0, akkor ez GL_INVALID_VALUE hibát eredményez. A szakaszok
élsimítását a generikus glEnable
ill. glDisable
parancsokkal lehet szabályozni, ha azokat a GL_LINE_SMOOTH argumentummal
hívjuk meg. Ha az élsimítás engedélyezett,
akkor nem egész szélességek is megadhatók,
és ekkor a szakasz szélén kirajzolt pixelek intenzitása
kisebb, mint a szakasz közepén lévõ pixeleké.
pl.:
glLineWidth(3.0);
Szakasz stílus
void glLineStipple(int factor, ushort pattern);
paranccsal állíthatjuk be. A pattern 16 bit hosszú sor csupa 1-esekbõl és 0-kból. Az 1-esek azt jelentik, hogy rajzolni kell a pixelt, a 0-ás pedig azt, hogy nem az alacsony helyiértékû bittel kezdõdõen. A pattern megnyújtható a factor használatával, amely minden csak 1-esekbõl és csak 0-kból álló részsorozatot megsokszoroz. pl.: ha a pattern tartalmaz három 1-est egymás után, és a factor 2, akkor a három 1-es helyén hat 1-es lesz. A szakasz stílust engedélyezni ill. letiltani lehet a generikus glEnable ill. glDisable paranccsal, ha azt a GL_LINE_STIPPLE szimbolikus konstanssal hívjuk meg.
példa vonal stílusra
pl:
glLineStipple(1, 0x3F07);
glEnable(GL_LINE_STIPPLE);
Ebben az esetben a minta: 0011111100000111, ami azt jelenti, hogy 3 pixelt kirajzolunk, utána 5 pixelt nem, 6 pixelt igen, majd 2 pixelt megint nem ( mielõtt nekiállnánk gondolkodni, emlékezzünk, hogy az alacsony helyiértékû bittel kezdünk ).
glLineStipple(2,
0x3F07);
glEnable(GL_LINE_STIPPLE);
esetén a minta: 00001111111111110000000000111111.
Mivel egy szakaszt két vertex határoz meg, ezért a szakaszhoz tartozó pixelek színe is valamiképpen ezen két vertex színébõl származik. Mivel a két vertex színe különbözõ lehet, a szakasz színe az árnyékolási modelltõl függ. Smooth árnyékolási modellben a szakasz egyes pontjainak színe a két különbözõ színû vertex között átmenetet képez. Flat árnyékolási modellben a szakasz egyszínû lesz, mégpedig olyan színû, amilyen az utolsóként specifikált vertex színe. Az árnyékolási modellt a
void glShadeModel(GLenum mode);
paranccsal állíthatjuk be. A mode a GL_FLAT illetve GL_SMOOTH valamelyike lehet.
pl.:
glBegin(GL_LINES);
glColor3d(1.0,0.0,0.0);
glVertex3d(0.0,0.0,0.0);
glColor3d(0.0,0.0,1.0);
glVertex3d(1.0,1.0,0.0);
glEnd();
Sokszögek színének beállítása
A színeket (mint tudjuk) nem primitívekhez,
hanem vertexekhez rendeljük hozzá, így a sokszögek
színe is valamiképpen a vertexeinek színébõl
származik. Az árnyalási modell aszerint dolgozik,
hogy a sokszögek egyszínûek (ebben az esetben az adott
sokszög színe megegyezik az utolsóként specifikált
vertexének színével, kivételt képeznek
ezalól a GL_POLYGON-nal létrehozott primitívek: itt
az elsõként specifikált vertex színe lesz a
primitív színe), vagy a belsõ pontok színe
a vertexek színébõl jön valamilyen interpolációval.
Azt, hogy az OpenGL melyik módszert alkalmazza, a glShadeModel
paranccsal állíthatjuk be.
A
glShadeModel(GL_FLAT);
paranccsal érjük el, hogy a sokszögek egyazon színnel
legyenek kitöltve, mégpedig a sokszög utolsóként
specifikált vertexének a színével.
A
glShadeModel(GL_SMOOTH);
paranccsal azt érjük el, hogy a sokszög pontjainak színe a vertexeinek színébõl interpolációval elõállított szín.
pl.:
glBegin(GL_TRIANGLES);
glColor3d(1.0,0.0,0.0);
glVertex3d(0.0,0.0,0.0);
glColor3d(0.0,0.0,1.0);
glVertex3d(1.0,0.0,0.0);
glColor3d(0.0,0.0,1.0);
glVertex3d(0.5,1.0,0.0);
glEnd();
Látható felszínek, mélységbeli összehasonlítás
A látható felszínek meghatározásának alapelve egyszerû: ha egy pixelt kirajzolunk, akkor hozzárendelünk egy z értéket, amely a pixel megfigyelõtõl való távolságát jelzi. Ezután, ha egy új pixelt akarunk rajzolni ugyanarra a helyre, akkor az új pixel z értéke összehasonlítódik az eredeti pixel z értékével. Ha az új pixel z értéke nagyobb, akkor közelebb van a megfigyelõhöz, ezért az eredeti pixelt felülírjuk az új pixellel, egyébként marad az eredeti pixel. Ezt az eljárást a mélységi- vagy z-buffer segítségével végzi el az OpenGL. A mélységibeli összehasonlítást engedélyezhetjük illetve letilthatjuk a generikus glEnable parancs GL_DEPTH_TEST szimbolikus konstanssal való meghívásával.
A sokszögek oldalainak megkülönböztetése; a glPolygonMode parancs
Egy sokszögnek két oldala van - elülsõ és hátulsó oldal - és ezért különbözõképpen jelenhet meg a képernyõn, attól függõen, hogy melyik oldalát látjuk. Alapértelmezésben mindkét oldal ugyanúgy rajzolódik ki. Ezen tulajdonságon a
void glPolygonMode(enum face, enum mode);
paranccsal lehet változtatni, amely kontrollálja a polygon elülsõ és hátulsó oldalának rajzolási módját. A face paraméter a GL_FRONT_AND_BACK, GL_FRONT ill. GL_BACK; a mode paraméter pedig a GL_POINT, GL_LINE ill. GL_FILL szimbolikus konstansok valamelyike lehet, aszerint, hogy csak a poligon pontjai, határvonala legyen kirajzolva, vagy ki legyen töltve. Alapértelmezésben a poligon mindkét oldala kitöltve rajzolódik ki. (kérdés az, hogy melyik oldal az elülsõ oldal; nos az elülsõ oldal alapértelmezésben az, melynek vertexei az óramutató járásával ellentétes irányban vannak specifikálva).
A sokszögek elülsõ és hátulsó oldalának definiálása; a glFrontFace parancs
Felvetõdhet a kérdés, hogy miért fontos a sokszögek két oldalát megkülönböztetni. Sokszor lehet szükség arra, hogy egy sokszög elülsõ és hátulsó oldalának különbözõ fizikai tulajdonságai legyenek. A hátoldalt el lehet például rejteni, vagy eltérõ színt lehet hozzárendelni. Ha ellenkezõjére akarjuk változtatni az elülsõ és hátulsó oldalak meghatározását, akkor ezt a
glFrontFace(GLenum mode);
paranccsal tehetjük meg. A glFrontFace parancs tehát azt definiálja, hogy a sokszög melyik oldala lesz az elülsõ ill. hátulsó oldal. mode a GL_CW és GL_CCW szimbolikus konstansok valamelyike, ahol GL_CW azt jelenti, hogy az elülsõ oldal az az oldal lesz, amelynek vertexeit az óramutató járásával megegyezõ irányban specifikáltunk, GL_CCW pedig az ellenkezõje.
Felszínek elrejtése a jobb teljesítmény érdekében; a glCullFace parancs
Ha egy objektumot specifikálunk, akkor elõfordulhatnak olyan felszínek, melyek soha nem fognak látszani. Például egy kockát határoló négyzetek belsõ oldala soha nem látszik. Alapértelmezés szerint az OpenGL azonban minden oldalt kirajzol, tehát a határoló négyzetek belsõ oldalát is. Ha elkerülnénk a belsõ oldalak kirajzolását, sok idõt spórolnánk meg a kép kirajzolásakor. A sokszögek elülsõ vagy hátulsó oldalának figyelmen kívül hagyását culling-nak nevezzük. Tehát a
glCullFace(GLenum mode);
paranccsal specifikálhatjuk, hogy a sokszögek elülsõ vagy hátulsó oldalát figyelmen kívül hagyjuk a rajzolásnál. A parancs a sokszög meghatározott oldalán letiltja a világítási, árnyalási és szín számítási mûveleteket. mode a GL_FRONT vagy a GL_BACK szimbolikus konstan valamelyike lehet. A culling-ot engedélyezhetjük illetve letilthatjuk a glEnable ill. glDisable paranccsal, ha azt a GL_CULL_FACE paraméterrel hívjuk meg.
Kitöltési minta
Alapértelmezés szerint a sokszögek teljesen kitöltöttek. A kitöltési mintát (amelyet egy 32×32-es bináris mátrix reprezentál) a
void glPolygonStipple(const ubyte *mask);
paranccsal lehet beállítani. A mask egy 32×32-es bittérképre mutat, amely 1-esekbõl és 0-sakból áll. 1 esetén a megfelelõ pixel kirajzolódik, 0 esetén nem. A sokszög minta engedélyezhetõ illetve letiltható a generikus glEnable ill. glDisable paranccsal, ha azt a GL_POLYGON_STIPPLE szimbolikus konstanssal hívjuk meg.
példa kitöltési mintára
pl.:
glEnable(GL_POLYGON_STIPPLE);
glPolygonStipple(minta);