A pontok, szakaszok és sokszögek tulajdonságai

- Pontok
- Szakaszok
- Sokszögek

Pontok

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

Szakaszok

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

A vonal stílust a

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.

Szakasz színe

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

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);

<-elõzõ oldal
-> következõ oldal
<-- fõoldal