Asentaminen (Ubuntu Intrepid Ibex)

Asentaminen tapahtuu helpoiten ubuntussa, avaa terminaali ja kirjoita seuraavat komennot:

1
2
3
4
sudo aptitude install python

wget "http://peak.telecommunity.com/dist/ez_setup.py"

sudo python ez_setup.py

sudo easy_install pyglet

Jos aikoo kirjoittaa omia kirjastoja jatkossa, kannattaa tämän lisäksi tehdä http://peak.telecommunity.com/DevCenter/EasyInstall#administrator-installation, joka sallii kirjastojen asentamisen käyttäjäkohtaisesti ilman root-oikeuksia.

Python2.6:ssa on valmiiksi säädettynä käyttäjäkohtainen hakemisto johon voi asentaa moduleita. Tällöin tarvitsee vain luoda kyseinen hakemisto ja kirjoittaa distutils/distutils.cfg pythonin asennushakemistoon (todennäköisesti /usr/lib/python2.6)

Esimerkki distutils.cfg:stä:

1
2
3
4
[install]

install_lib = ~/.local/lib/python2.6/site-packages

# seuraavan rivin voi jättää pois:

install_scripts = ~/.local/bin

Jonka jälkeen voi ladata ez_setup.py -skriptin ja suorittaa sen käyttäjäkohtaisesti.

Asentaminen (Windows)

Ensiksi pitää asentaa python. Kaiken pitäisi toimia hyvin pythonin 2.6 -versiolla. Jollet halua AMD64-asennusta niin normaalin binäärin asentaminen pitäisi riittää: http://www.python.org/ftp/python/2.6.1/p…

Lataa skripti http://peak.telecommunity.com/dist/ez_se… (klikkaa oikealla ja paina ‘tallenna nimellä’) hakemistoon mihin asensit pythonin. Käynnistä cmd ja kirjoita:

1
2
cd "C:\Program Files\Python26\"

python.exe ez_setup.py

Korvaa “C:\Program Files\Python26\” omalla hakemistopolullasi. Tässä välin setuptools asentuu. Asennuksen jälkeen kirjoita:

1
2
cd Scripts

easy_install.exe pyglet

Jos haluat asiat helpoksi, aseta pythonin asennuspolku ja ‘Scripts’ -hakemisto ympäristömuuttujien PATH -arvoon. Tämä artikkeli ei kuitenkaan opeta käyttöjärjestelmän käyttöä joten muuttujien asettaminen jää lukijan selvitettäväksi.

Ensimmäinen ikkuna

Tässä on ensimmäinen ohjelma. Voit joko kirjoittaa sen suoraan pythoniin tai kirjoittaa tekstitiedostoon ja antaa tiedoston tulkille. Rautalangasta kirjoitettuna: ‘python eka.py’

1
2
3
import pyglet

window = pyglet.window.Window(width=200, height=100, caption=u"Ensimmäinen")

pyglet.app.run()

Artikkelin kirjoitti alun perin Cheery.

1. Valaistuksen matematiikkaa

Vasemmalla ilman valoja. Keskellä valojen kanssa ja oikealla myös varjot mukana. Huomaa lisääntynyt realismi. Oikeassa elämässä näkemämme kuva syntyy, kun jostakin valonlähteestä lähtevä valo heijastuu jostakin pinnasta silmämme verkkokalvolle. Voisimme siis teoriassa laskea virtuaalimaailmassa olevan kappaleen valaistuksen sinkoamalla virtuaalisesta valonlähteestä miljardeittain valonsäteitä ja laskemalla mitkä niistä osuvat renderöimäämme pintaan. Miljardien valonsäteiden radan laskeminen ei kuitenkaan sovi reaaliaikasovellukselle. Ajatus voidaan tietenkin kääntää päälaelleen. Jäljitetään pinnan jokaisesta pikselistä valonsäteen rataa nurinkurisesti ja katsotaan johtaako se valonlähteeseen. Tätä menetelmää kutsutaan termillä “ray tracing”. Tekniikka on huomattavasti kevyempi ja sitä käyttäviä demoja on muutamia, mutta myös tämä tekniikka on vielä liian raskas varsinkin peleille. Koska emme voi laskea valon vaikutusta täydellisen tarkasti, täytyy meidän löytää jokin keino arvioida sitä. Arviointitekniikoita on useita, joista tässä artikkelissa esittelen kaksi samankaltaista nimeltään: Blinn ja Phong. Näissä tekniikoissa pinnasta verkkokalvolle saapuva valo jaetaan karkeasti neljään eri tyyppiin: ympäristövaloon (ambient light), hajavaloon (diffuse light), peiliheijastukseen (specular light) ja itsesäteiltyyn valoon (emissive light).

1.1 Hajavalo

Hajavalo on valoa, joka tulee suoraan jostakin valonlähteestä pintaan. Pinta absorboi osan tästä valosta ja heijastaa loput eteenpäin silmän verkkokalvolle. Merkitsemme hajavaloa tässä artikkelissa symbolilla D (niin kuin diffuse). Hajavalon määrä on riippuvainen siitä kulmasta, jossa valonsäde saapuu pintaan. Jos L (niin kuin light) on vektori kohti valonlähdettä ja N (niin kuin normal) pinnan normaalivektori ja kummankin näiden vektorien pituus on yksi, niin hajavalon määrä saadaan näiden pistetulona eli N · L. Pinta ei kuitenkaan heijasta valon kaikkia aallonpituuksia tasapuolisesti, vaan se absorboi osaa paremmin ja osaa huonommin. Tästa muodostuu pinnan väri. Esim. jos pinta absorboi kaiken muun paitsi punaisen valon näyttää pinta punaiselta. Kaiken lisäksi pintaan saapuva valo ei välttämättä ole valkoista eli sisällä kaikkia mahdollisia aallonpituuksia. Meidän tarvitsee siis kertoa hajavalo vielä pinnan värillä, jota merkitsemme symbolilla Cd (niin kuin color ja decal) ja valon värillä, jota merkitsemme symbolilla Cl (niin kuin color ja light). Niinpä saamme hajavalon lopulliseksi yhtälöksi: Cd * Cl * ( N · L ) . Tässä * ei siis tarkoita pistetuloa vaan värien kertomista komponenteittain.

1.2 Ympäristövalo

Ympäristövalo on valoa, jonka ei voida sanoa tulevan mistään tietystä suunnasta ja se vaikuttaa kaikkiin pintoihin samalla tavalla, olkoot ne sitten missä asennossa tahansa suhteessa valonlähteeseen. Tämä johtuu siitä, että valonsäteet kimpoilevat pinnasta toiseen sekoittuen lopulta yhteinäiseksi tasaiseksi valoksi. Merkitsemme tässä artikkelissa ympäristövaloa symbolilla A (niin kuin ambient). Ympäristävalon määrä on koko ajan vakio ja sitä ei oikein voi laskea mitenkään, vaan se sen määrä on arvioitava. Jos minimi on 0 ja maksimi 1, niin realistinen kuva saadaan yleensä hyvin pienillä arvoilla esim 0.1. Koska pinta heijastaa myös ympäristövalosta vain tietyt aallonpituudet, täytyy se kertoa pinnan värillä, joilloin saamme tälle komponentille yhtälön: Cl * A.

1.3 Peiliheijastus

Kun valo osuu pintaan tietyssä kulmassa, ei pinta absorboikkaan yhtään valoa vaan heijastaa sen sellaisenaan eteenpäin. Kutsumme tällaista valoa peiliheijastuneeksi ja merkitsemme sitä symbolilla S (niin kuin specular). Peiliheijastuksen kulma riippuu pinnan materiaalista, kutsumme tätä ominaisuutta pinnan kiiltävyydeksi ja merkitsemme sitä symbolilla G (niin kuin gloss). Lisäksi tähän vaikuttaa pinnan tasaisuus, jota merkitsemme symbolilla M, realistinen M:n arvo on yleensä välillä 8 – 16. Peiliheijastus riippuu valonlähteen sijainnin lisäksi myös siitä mistä kulmasta pintaa katsellaan. Meidän tarvitsee tietää siis vielä vektori, joka osoittaa kohti kameraa. Merkitsemme tätä vektoria symbolilla E (niin kuin eye). Peiliheijastuksen laskemiseeen on kaksi tapaa: ns phong- ja blinn-valaistusmallit. Phong-mallissa meidän tarvitsee tietää vektori R (niin kuin reflection), joka saadaan kun vektori E peilataan vektorin N suhteen. Tämä tehdään kaavalla: R = 2 * (N · L) * N – L. Kun R on tiedossa saadaan peiliheijastus kaavasta Cl * G * (L · R)^M. Eli valon väri kertaa G kertaa L:n ja R:n pistetulo potenssiin M. Pinnan väri ei siis vaikuta peiliheijastukseen. Vektorin R laskeminen on kuitenkin hieman turhan monimutkainen. Tämän takia on olemassa yksinkertaisempi malli Blinn. Blinn-mallissa vektoria R ei tarvita, vaan lasketaan vektori H, joka puolittaa vektoreiden L ja E välisen kulman. Tähän jälkeen peiliheijastus lasketaan yhtälöstä: Cl * G * (N · H)^M. Potenssilasku ^M kuitenkin muodostaa pienen ongelman. Potenssiin korotus nimittäin on kaikesta nykyajan laskentatehosta huolimatta varsin hidas operaatio varsinkin kun se joudutaan laskemaan, jopa tuhansia kertoja per frame. Tämän takia saattaa joskus olla järkevää lukita M arvoon 16 ja aproksimoida funktiota x^16, jollakin toisella yksinkertaisemmalla funktiolla. Tällaisia ovat mm: max( 0, 4*(x-0.75) ) ja max( 0, 4*(x*x-0.75) ).

1.4 Itsesäteilty valo

Viimeinen muoto on itsesäteilty valo. Tämä on valoa, jota pinta itse tuottaa. Tyypillinen itsevalaiseva pinta on fosfori. Merkitsemme tätä valoa symbolilla E (niin kuin emissive). Tätäkään valoa ei voida mitenkään laskea vaan se on arvioitava. Tavallisilla pinnoilla tämä se on yleensä 0. Jos oletamme, että pinta säteilee itsensä väristä valoa saamme tämän komponentin kaavaksi: Cd * E.

1.5 Lopullinen valoyhtälö

Nyt voimme muodostaa yhtälön, joka antaa meille hyvin realistisen valaistuksen. Laskemme vain eri muodot yhteen eli kokonaisvalo, jota merkitsemme symbolilla I (niin kuin illumination) on A+D+S+E. Jos vielä puramme yhtälön auki blinn-mallin mukaisesti saamme I = Cd * A + Cd * Cl * ( N · L ) + Cl * G * ( N · H ) ^ M + Cd * E . Tämä ei ota vielä huomioon sitä tosiasiaa, että valon kirkkaus vaimenee mitä kauempana valonlähteestä ollaan. Yhtälö pitää siis kertoa vaimennustermillä, joka saadaan jakamalla 1 jollakin sopivalla vakiolla k kerrottuna etäisyyden (käytämme symbolia d) neliöllä eli 1/(1+k*d^2). Tämä olisi siis fysikaalisesti oikein, mutta ei välttämättä hyvän näköinen. Niinpä usein käytetään jotain muuta vaimennustermiä esim: max( 0, 1 – ( d / r )^2 ). Tällöin valon kirkkaus on maksimissaan keskellä valonlähdettä ja hiipuu nollaan saavutettaessä etäisyys r ja on nolla kaikkialla tätä kauempana. Lopullinen (blinn-mallin mukainen) yhtälö on siis: I = 1/(1+k*d^2) * ( Cd * A + Cd * Cl * ( N · L ) + Cl * G * ( N · H ) ^ M + Cd * E ). Jos valonlähteitä on useampia pitää valaistus laskea kaikille valoille erikseen ja sitten summata tulokset.

2. Käytännön toteutus

Nyt siis tiedämme valaistukseen tarvittavan yhtälön. Mutta kuinka kappale sitten oikein valaistaan sillä? Helposti, lasketaan yhtälö kappaleen jokaiselle verteksille ja annetaan tulos värinä OpenGL:lle glColor3f()-funktiolla. Tehdään seuraavaksi funktio, joka laskee tämän valoyhtälön syötteenään saamalle verteksille. Se saa syötteenään verteksin sijainnin (Pv), valon sijainnin (Pl), pinnan värin (Cd), valon värin (Cl) ja pinnan normaalin (N). Funktio laskee verteksille valon ja antaa sen OpenGL:lle värinä. Yksinkertaisuuden vuoksi se jättää vaimenemisen huomiotta ja olettaa itsesäteillyn valon olevan nolla.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
void valo(float Pv[3], float Pl[3], float Cd[3], float Cl[3], float N[3])

{

  const float A=0.1;

  const float G=0.9;

  const float M=16;



  float L[3], E[3], H[3], I[3];

  float temp;



  // Laske vektori L, joka osoittaa kohti valoa.

  L[0]=Pl[0]-Pv[0];

  L[1]=Pl[1]-Pv[1];

  L[2]=Pl[2]-Pv[2];

  temp=sqrt(L[0]*L[0]+L[1]*L[1]+L[2]*L[2]);

  L[0]/=temp;

  L[1]/=temp;

  L[2]/=temp;



  // Laske vektori E, joka osoittaa kohti kameraa.

  E[0]=-Pv[0];

  E[1]=-Pv[1];

  E[2]=-Pv[2];

  temp=sqrt(E[0]*E[0]+E[1]*E[1]+E[2]*E[2]);

  E[0]/=temp;

  E[1]/=temp;

  E[2]/=temp;



  // Laske vektori H, joka puolittaa vektorien E ja L välisen kulman.

  H[0]=L[0]+E[0];

  H[1]=L[1]+E[1];

  H[2]=L[2]+E[2];

  temp=sqrt(H[0]*H[0]+H[1]*H[1]+H[2]*H[2]);

  H[0]/=temp;

  H[1]/=temp;

  H[2]/=temp;



  // Laske ympäristövalo + hajavalo + peiliheijastus

  I[0]= A*Cd[0] + Cd[0]*Cl[0]*pisteTulo(N, L) + G*Cl[0]*pow(pisteTulo(N, H), M);

  I[1]= A*Cd[1] + Cd[1]*Cl[1]*pisteTulo(N, L) + G*Cl[1]*pow(pisteTulo(N, H), M);

  I[2]= A*Cd[2] + Cd[2]*Cl[2]*pisteTulo(N, L) + G*Cl[2]*pow(pisteTulo(N, H), M);



  // Anna tulos OpenGL:lle.

  glColor3f(I[0], I[1], I[2]);

}

Tämä johtaa kuitenkin ongelmaan teksturoinnin yhteydessä. Pinnan värihän saadaan tällöin tekstuurista, joten se voi olla eri jokaisella pikselillä. Miten siis tekstuuri suhtautuu valaistukseen? Jos luit sarjan edellisen osan muistat varmaan, että värin ja tekstuurin yhdistämisestä huolehtii texture environment, joka oletuksena kertoo värin ja tekstuurin keskenään (GL_MODULATE). Jos jätemme valoyhtälöstä pois komponentin Cd saamme yhtälön: I = 1/(1+k*d^2) * ( A + Cl * ( N · L ) + Cl * G * ( N · H ) ^ M + E ). Jos nyt laskemme valaistuksen tämän yhtälön mukaisesti ja annamme texture environmentin kertoa värin tektuurilla saamme lopulliseksi väriksi: I = Cd * ( 1/(1+k*d^2) * ( A + Cl * ( N · L ) + Cl * G * ( N · H ) ^ M + E ) ), joka on muuten sama kuin alkuperäinen yhtälömmekin paitsi, että myös peiliheijastus tulee kerrottua pinnan värillä. Tämä ei ole suuri katastrofi, jos peiliheijastuksen arvo on mitättömän pieni ( G on noin 0 ), mutta pilaa koko vaikutelman, jos peiliheijastuksen osuus on merkittävä. Tämän ongelman voi korjata toissijaisella värillä, josta puhumme seuraavaksi.

2.1 Toissijainen vär

glColor3f()-funktiolla annettua väriä kutsutaan ensisijaiseksi väriksi. On kuitenkin olemassa laajennus GL_EXT_secondary_color, joka sallii toissijaisen värin määrittämisen. Tämä laajennus tuo mukanaan mm. funktion glSecondaryColor3fEXT(Glfloat red, Glfloat green, Glfloat blue), jolla toissijainen väri annetaan. Toissijainen väri ei osallistu texture environmenttiin, vaan se lisätään (siis lasketaan yhteen) pikselin väriin vasta sen jälkeen kun teksture environment on tehnyt tehtävänsä. Tämä kuitenkin tapahtuu vain, jos GL_COLOR_SUM_EXT on päällä. Se saadaan päälle kutsulla glEnable(GL_COLOR_SUM_EXT). Korjataan nyt edellisen kappaleen funktiota niin, että se olettaa pinnan värin tulevan tekstuurista ja erottaa peiliheijastuksen toissijaiseen väriin. Funktio olettaa, että GL_EXT_secondary_color-laajennos on tuettu ja että GL_COLOR_SUM_EXT ja GL_TEXTURE_2D ovat päällä ja texture environment on GL_MODULATE-moodissa.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
void valo2(float Pv[3], float Pl[3], float Cl[3], float N[3])

{

  const float A=0.1;

  const float G=0.9;

  const float M=16;



  float L[3], E[3], H[3], I[3], S[3];

  float temp;



  // Laske vektori L, joka osoittaa kohti valoa.

  L[0]=Pl[0]-Pv[0];

  L[1]=Pl[1]-Pv[1];

  L[2]=Pl[2]-Pv[2];

  temp=sqrt(L[0]*L[0]+L[1]*L[1]+L[2]*L[2]);

  L[0]/=temp;

  L[1]/=temp;

  L[2]/=temp;



  // Laske vektori E, joka osoittaa kohti kameraa.

  E[0]=-Pv[0];

  E[1]=-Pv[1];

  E[2]=-Pv[2];

  temp=sqrt(E[0]*E[0]+E[1]*E[1]+E[2]*E[2]);

  E[0]/=temp;

  E[1]/=temp;

  E[2]/=temp;



 // Laske vektori H, joka puolittaa vektorien E ja L välisen kulman.

  H[0]=L[0]+E[0];

  H[1]=L[1]+E[1];

  H[2]=L[2]+E[2];

  temp=sqrt(H[0]*H[0]+H[1]*H[1]+H[2]*H[2]);

  H[0]/=temp;

  H[1]/=temp;

  H[2]/=temp;



  // Laske ympäristövalo + hajavalo

  I[0]= A     +     Cl[0]*pisteTulo(N, L);

  I[1]= A     +     Cl[1]*pisteTulo(N, L);

  I[2]= A     +     Cl[2]*pisteTulo(N, L);

  //  Laske  peiliheijastus

  S[0]= G*Cl[0]*pow(pisteTulo(N, H), M);

  S[1]= G*Cl[1]*pow(pisteTulo(N, H), M);

  S[2]= G*Cl[2]*pow(pisteTulo(N, H), M);



  // Anna tulos OpenGL:lle.

  glColor3f(I[0], I[1], I[2]);

  glSecondaryColor3fEXT(S[0], S[1], S[2]);

}

3. OpenGL:n oma valojärjestelmä

Ei kuitenkaan ole pakko kirjoittaa omaa funktiota, joka laskee valaistuksen, sillä OpenGL sisältää myös oman valaistusjärjestelmän. Valaistus saadaan päälle kutsulla glEnable(GL_LIGHTING);. Kun valaistus on päällä laskee OpenGL valot automaattisesti ja korvaa värit saamillaan tuloksilla. glColor3f()-funktiolla ei siis ole mitään vaikutusta silloin kun valaistus on päällä! Valonlähteitä on maksimissaan kahdeksan ja niitä voidaan laittaa päälle ja pois yksitellen glEnable() ja glDisable()-funktioilla, joille annetaan parametrina GL_LIGHTx, jos x on valon numero väliltä 0-7. Valon attribuutteja (sijaintia, väriä jne…) voidaan muuttaa glLightfv()-funktiolla, jonka prototyyppi näyttää tältä: void glLightfv(GLenum light, GLenum pname, const GLfloat *params); Ensimmäinen parametri kertoo valon, jonka attribuutteja muutetaan (siis GL_LIGHTx). Toinen on muuttava attribuutti.

Tärkeimmät ovat GL_AMBIENT (ympäristovalon eli A:n arvo), GL_DIFFUSE ja GL_SPECULAR (valon väri eli Cl, OpenGL siis sallii eri valon värit hajavalolle ja peiliheijastukselle), GL_QUADRATIC_ATTENUATION (vaimenemisen vakio k) ja GL_POSITION (valon sijainti). Viimeinen parametri on osoitin 4-komponenttiseen taulukkoon, joka sisältää attribuutin uuden arvon. 3 ensimmäistä kenttää ovat attribuutin uusi arvo ja viimeisen kentän on oltava 1. Paitsi GL_QUADRATIC_ATTENUATION tapauksessa, jossa taulukko sisältää vain yhden arvon. Valaistavan pinnan ominaisuuksia voidaan asettaa glMaterialfv()-funktiolla.

Prototyyppi näyttää tältä: void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params); Ensimmäisen parametrin on oltava GL_FRONT_AND_BACK. Toisen parametrin mahdolliset arvot ovat: GL_AMBIENT_AND_DIFFUSE (pinnan väri), GL_SPECULAR (pinnan kiiltävyys eli G:n arvo), GL_EMISSION (itsesäteillyn valon määrä eli E:n arvo) ja GL_SHININESS (vakion M arvo). Viimeinen parametri on jälleen kerran osoitin 4 komponenttiseen taulukkoon, joka sisältää uuden arvon. Paitsi GL_SHININESS tapauksessa, jossa taulukko sisältää vain yhden arvon. Koska pinnan normaalia tarvitaan valaistuksen laskemiseen täytyy se antaa OpenGL:lle. Tämä tehdään funktiolla glNormal3f(), jonka prototyyppi näyttää tältä: void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);

Se siis ottaa normaalivektorin x, y ja z komponentit parametrinaan. Huomaa, että tämän vektorin pituuden tulee olla 1. Tätä funktiota kutsutaan glBegin() ja glEnd()-funktioiden välissä ja jokaiselle verteksille erikseen. On olemassa GL_EXT_separate_specular_color-laajennus, joka saa OpenGL erottamaan laskemansa valon peiliheijastuskomponentin toissijaiseksi väriksi. Tämä tehdään kutsulla glLightModel(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, GL_ SEPARATE_SPECULAR_COLOR_EXT);

4. Pikselin tarkka valaistus

Huomattavaa on, että OpenGL:n sisäinen valojärjestelmä laskee valot vain vertekseille. Ei siis jokaiselle pikselille erikseen. Tämän jälkeen jokaiselle verteksille lasketut valoarvot (värit), interpoloidaan pikseleille. Kaikki näyttää ihan hyvältä niin kauan kuin polygonien koko on tarpeeksi pieni ja valon lähde kaukana niistä. Jos näin ei ole alkavat virheet näkyä. Parempi olisikin, jos voisimme laskea valoarvot jokaiselle pikselille erikseen jolloin tuloksena olisi huomattavasti realistisempi kuva. glColor3f()-funktiolla ei kuitenkaan voi antaa väriä erikseen jokaiselle pikselille. Ainoastaan vertekseille. Seuraavassa kappaleessa esittelen pikselivarjostimiksi kutsutun tekniikan, jolla tämä ongelma saadaan pois päiväjärjestyksestä, mutta sitä ennen esittelen muutaman kiertotien. Jos sekä valo että piirrettävä polygoni ovat staattisia eli ne eivät liiku voidaan valon vaikutus piirtää etukäteen tekstuuriin esim. jollakin kuvankäsittelyohjelmalla.

Tällöin säästetään myös tehoa, kun mitään valaistukseen liittyvää ei tarvitse laskea ajon aikana. Tätä tekniikkaa kutsutaan termillä “lightmapping” ja sitä käyttävät mm. pelit Quake 2 ja 3 sekä half-life. Ajatus voidaan viedä vieläkin pidemmälle. Miksei valoefektejä lasketa tekstuureihin ajon aikana ja muuttuneita tekstuureja sitten ladata uudestaan näytönohjaimen muistiin glTexImage2D()-funktiolla. Jos tekstuurit ovat tarpeeksi matalaresoluutioisia, tämä on ihan toimiva vaihtoehto. Jos tekstuurit kuitenkin ovat kovin korkearesoluutioisia kuluu tekstuurien päivittämiseen liikaa aikaa ja menetelmä ei toimi.

Tämän tekniikan nimi on ”dynamic lightmapping”. Mm. pelit Alien vs Predator 1 ja 2 käyttävät tätä tekniikkaa. Texture environment osaa laskea erilaisia funktioita jokaiselle pikselille, yhdistäen eri tekstuureja. On itse asiassa mahdollista laskea texture environment:in avulla valoyhtälöt jokaiselle pikselille. Tähän tarvitaan laajennukset GL_ARB_texture_env_combine, GL_ARB_texture_env_crossbar (tai GL_NV_texture_env_combine4) ja GL_ARB_texture_env_dot3 ja vähintään 4 teksturointiyksikköä. Lisäksi peiliheijastuksessa tarvittava potenssiinkorotus ei ole mahdollinen, joten sitä on arvioitava jollakin yksinkertaisemmalla funktiolla.

5. Verteksi- ja pikselivarjostinohjelmat

Verteksi- tai pikselivarjostin on ohjelma tai pidemminkin funktio, jonka OpenGL suorittaa jokaista verteksiä/pikseliä kohden. Parasta tässä on, että voit kirjoittaa tämän funktion itse. Näitä funktioita kutsutaan varjostimiksi, koska niitä käytetään usein nimenomaan valaistuksen laskentaan. Varjostinohjelmat saavat syötteenään verteksin/pikselin kaikki arvot, kuten värin ja sijainnin ja tuottavat tuloksenaan uudet arvot.

Huomaa, että koska pikselivarjostinohjelmat suoritetaan kerran jokaista pikseliä kohden, ja kuvassa voi helposti olla miljoonia pikseleitä kasvaa tarvittavan tehon määrä valtavaksi. Tämän takia pikselivarjostimet toimivat vain kaikkein uusimmissa näytönohjaimissa, kuten GeForceFX ja Ati Radeon 9500. Nämä varjostimet ovat saatavilla laajennusten GL_ARB_vertex_program, GL_ARB_fragment_program, GL_ARB_vertex_shader ja GL_ARB_fragment_shader muodossa. Verteksivarjostimet eivät tuo varsinaisesti mitään uutta. Ne saavat syötteenään verteksin sijainnin, värin jne. Suorittavat näillä jotain laskentaa ja korvaavat arvot uusilla.

Olisit voinut tietenkin laskea nämä uudet arvot omassa ohjelmassasi ja antaa ne OpenGL:lle alkuarvoina, joilloin koko verteksivarjostinta ei olisi tarvittu. Etu on siinä, että verteksivarjostimen koodi suoritetaan näytönohjaimen prosessorilla, joka on nimenomaan erikoistunut grafiikan piirtämiseen ja suorittaa verteksivarjostinohjelman yleensä (joskaan ei aina) nopeammin kuin tietokoneen keskusyksikkö. Näin ollen verteksivarjostimet nostavat ohjelman suorituskykyä, ei sen graafista laatua.

Pikselivarjostimet ovat sen sijaan toinen juttu. Ei nimittäin ole muuta keinoa tehdä pikselikohtaisia laskutoimituksia (texture environment:illa kikkailua lukuunottamatta). Niiden avulla on mahdollista laskea blinnin tai phongin valoyhtälöt jokaiselle pikselille erikseen. Mm. Doom 3:n hieno grafiikka perustuu tähän. Valitettavasti pikselivarjostimilla on katastrofaalinen vaikutus suorituskykyyn. Esim. 800×600 resoluutioisessa ikkunassa on 480000 pikseliä (olettaen että yhtään pikseliä ei piirretä kahdesti). Jos pikselivarjostin, jossa on vain 10 rivia koodia, suoritetaan jokaiselle pikselille tekee se lähes 5 miljoonaa suoritettavaa koodiriviä.

On siinä näytönohjaimella laskemista. Varjostinohjelmat voidaan kirjoittaa, joko konekielellä (laajennukset GL_ARB_vertex_program ja GL_ARB_fragment_program) tai korkeamman tason glSlang-kielellä (laajennukset GL_ARB_vertex_shader ja GL_ARB_fragment_shader) (myös Direct3D:llä on vastaavanlainen korkeamman tason kieli nimeltä HLSL). Lisäksi on olemassa NVidian kehittämä Cg. Se on siitä vekkuli, että se toimii sekä OpenGL:ssä, että Direct3D:ssä. Jotta voisit käyttää varjostinohjelmia sinun täytyy opetella jokin näistä kielistä. En kuitenkaan aijo esitellä niitä sen enempää, sillä niistä saisi vaikka oman artikkelinsa. Varjostinohjelmat ovat kuitenkin tulevaisuutta, joten niitä kannattaa joskus edes vilkaista.

6. Sapluunapuskuri

Ennen kuin voimme mennä eteenpäin pitää minun esitellä sinulle yksi kätevä työkalu nimeltä sapluunapuskuri (englanniksi stencil buffer). Sapluunapuskuri toimii nimensä mukaan sapluunana. Ensin sapluunapuskuriin piirretään jotain, jonka jälkeen sapluunatestaus asetetaan päälle. Tämän jälkeen pikselit piirtyvät vain niihin kohtiin, joissa sapluunapuskuriin on piirretty jotain (tai halutessa toisin päin).

Ennen kuin sapluunapuskuria voidaan käyttää pitää se laittaa päälle. Tämä tehdään kutsulla glEnable(GL_STENCIL_TEST). Sapluunapuskuriin ei kuitenkaan voida tallentaa syvyysarvoja (kuten syvyyspuskuriin) tai väriarvoja kuten väripuskuriin, vaan lukuja väliltä 0 – 255 (olettaen, että sapluunapuskurille varattujen bittien määrä per pikseli on 8). Se mitä sapluunapuskurissa olevalle luvulle tapahtuu sinne piirrettäessä valitaan glStencilOp()-funktiolla.

Prototyyppi näyttää tältä: void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); Kolme eri tapausta. Eli mitä tehdään kun pikseli ei läpäise sapluunatestiä (fail), mitä tehdään, kun pikseli läpäisi sapluunatestin, mutta ei syvyystestiä (zfail) ja mitä tehdään, kun pikseli läpäisi molemmat (zpass). Kaikkien parametrien mahdolliset arvot ovat: GL_KEEP (ei muutosta), GL_ZERO (korvataan nollalla), GL_REPLACE (korvataan jollakin vakioarvolla, joka annetaan myöhemmin esiteltävällä glStencilFunc() -funktion ref-parametrina), GL_INCR (kasvattaa lukua yhdellä), GL_DECR (vähentää lukua yhdellä) ja GL_INVERT (kääntää bitit).

Käytettävä sapluunatesti voidaan valita funktiolla glStencilFunc(). Sen prototyyppi on tämän näköinen: void glStencilFunc(GLenum func, GLint ref, GLuint mask); Parametri func kertoo käytettävän funktion. Mahdollisia vaihtoehtoja ovat GL_NEVER (pikseliä ei koskaan piirretä), GL_ALWAYS (pikseli läpäisee testin aina, eli sapluunatesti on pois päältä), GL_EQUAL (pikseli piirretään vain jos sen kohdalla oleva arvo sapluunapuskurissa on sama kuin ref-parametrin arvo), GL_LESS ja GL_GREATER. Viimeinen parametri on maski. Sen arvo on yleensä ~0 eli binääriluku 11111111.

Ennen käyttöä sapluunapuskuri on tietenkin tyhjennettävä. Se tapahtuu kutsulla glClear(GL_STENCIL_BUFFER_BIT). Lisäksi on huomattava, että kun kirjoitamme sapluunapuskuriin emme varmaan halua samalla piirtää mitään väripuskuriin. Tämä voidaan estää kutsulla glColorMask(0,0,0,0); ja äskeisen vaikutus saadaan kumottua kutsulla glColorMask(1,1,1,1);.

7. Varjot

OpenGL ei sisällä valmista glEnable(GL_SHADOWS)-mekanismia, jolla varjot voisi loihtia helposti. Tämä sen takia, että piirtäessään yhtä polygonia OpenGL ei tiedä mitä kaikkea se tulee vielä piirtämään ennen kuin kuva on valmis. On kuitenkin paljon algoritmeja, joilla varjoja voi tehdä. Helpointa olisi tietenkin käyttää ns. feikkivarjoja eli piirtää kuvaan jotain mikä näyttää hieman varjolta esim. musta ympyrä kappaleen alle. Kun halutaan fysikaalisesti realistisia varjoja tarvitaan hieman enemmän työtä. Kaksi kuuluisinta varjoalgoritmia ovat “shadow map”-algoritmi ja ”stencil shadow volumes”-algoritmi.

Kumpikaan algoritmi ei perustu siihen, että ne piirtäisivät varjon, vaan pidemminkin piirtävät kaiken muun paitsi varjon, jolloin varjon kohdat jäävät mustiksi. Itse pidän enemmän “stencil shadow volumes”-algoritmista, jota käytämme myös esimerkkiohjelmassamme, mutta esittelen ensin hieman hankalamman “shadow map”-algoritmin perusidean ja jätän yksityiskohdat lukijan oman tutkisen varaan.

7.1 “Shadow map”-algoritmi

“Shadow map”-algoritmin idea on seuraavanlainen. Renderoidaan kuva ensin valonlähteen näkökulmasta. Valonlähteen on siis oltava suunnattu, eikä “shadow map”-algoritmi toimi pistemäisille valonlähteille (yksi syy miksi en pidä siitä). Kopioidaan tämän kuvan syvyyspuskuri tekstuuriin. Kutsukaamme tätä tekstuuria nimellä shadow map.

Teksturoidaan tällä tekstuurilla kaikki kappaleet valiten tekstuurikoordinaatit niin, että tekstuuri tulee projisoitua kappaleiden päälle valonlähteestä katsottuna. Tämän jälkeen renderoidaan kuva normaalisti samalla testaten jokaiselle pikselille, onko sen etäisyys valonlähteestä suurempi kuin sen kohdalla shadow map:issa oleva arvo. Jos on, pikseli on varjossa ja se voidaan jättää piirtämättä, muuten ei.

Itse kuvan renderointi valonlähteestä nähtynä ei ole hankalaa. Syvyyspuskurin kopiointi tekstuuriin taas voidaan tehdä glCopyTexSubImage2D()-funktiolla. Sen prototyyppi näyttää tältä. void glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ); Ensimmäisen parametrin on oltava GL_TEX_IMAGE_2D ja toisen 0. Offset-parametrit kertovat kohdan tekstuurista, johon kuva kopioidaan (yleensä 0,0) ja x, y kohdan ruudulta, josta data kopioidaan (yleensä 0,0). Width ja height ovat kopioitavan alueen koko.

Huomaa, että tektuurin, johon data tällä funktiolla kopioidaan pitää olla jo valmiiksi olemassa eli se on täytetty jollakin datalla käyttäen glTexImage2D()-funktioita. Lisäksi tämän tekstuurin tulee olla ns. “depth texture”, tai muuten glCopyTexSubImage2D() kopioi väridatan eikä syvyysdataa.. Tämä uusi tekstuurimuoto tulee GL_ARB_depth_texture-laajennoksen mukana ja tekstuuri on tätä muotoa, kun glTexImage2D()-funktion components-parametri asetetaan symboliin GL_DEPTH_TEXTURE_ARB. Tekstuurikoordinaattien laskeminen eli tekstuurin projisointi kappaleiden päälle on aika matemaattinen juttu, jonka jätän käsittelemättä. Mainittakoon kuitenkin, että OpenGL sisältää automaattisen tekstuurikoordinaattien generoinnin, jolla tämä voidaan hoitaa.

Kun shadow map on luotu ja kappaleet teksturoitu sillä jää enää jäljelle kysymys: Kuinka oikein testaamme onko pikseli kauempana valosta kuin sen shadow map arvo? Voisimme tietenkin suorittaa tämän testin pikselivarjostimessa, mutta OpenGL sisältää ihan valmiin laajennoksen tätä varten. Tämän laajennoksen nimi on GL_ARB_shadow. Jätän tähän laajennokseen tutustumisen lukijan oman mielenkiinnon varaan ja siirryn “stencil shadow volumes”-algoritmiin.

7.2 ”Stencil shadow volumes”-algoritmi

Shadow volume eli “katvetila” (jos tiedät paremman suomennoksen niin kerro toki minullekkin) on monitahokas, joka sulkee sisäänsä kaikki ne pisteet, jotka jäävät varjoon ja vastaavasti mikään katvetilan ulkopuolella oleva piste ei ole varjossa. Algoritmin idea on muodostaa monitahokkaalle valonlähteestä päin katsottu silhuetti. Venyttää tätä silhuettia valonlähteestä poispäin joilloin muodostuu monitahokkaan katvetila valonlähteen suhteen.

Monitahokkaan silhuetin löytäminen saattaa aluksi tuntua hankalalta tehtävältä, mutta se on itse asiassa aika helppoa. Seuraavassa yksi algoritmi. Parempiakin varmasti löytyy, mutta uskon tämän olevan aika helppo ymmärtää.

for (jokaiselle monitahokaan taholle)
{
  if (tämä taho osoittaa kohti valoa)
  {
    for (jokaiselle tämän tahon vierustaholle)
    {
      if (tämä vierustaho EI osoita kohti valoa)
      {
        Tahojen välinen särmä kuuluu silhuettiin.
      }
    }
  }
}

Silhuetin löytymisen jälkeen se täytyy venyttää katvetilaksi. Tämä on yksinkertaista. Projisoidaan jokaisesta särmästä kopio poispäin valonlähteestä ja yhdistetään tämä särmä alkuperäisen kanssa nelikulmioksi, joka muodostaa yhden katvetilan tahoista. Näin saadaan päistä avoin katvetila. Tämä katvetila voidaan vielä tarvittaessa sulkea käyttämällä alkuperäisen monitahokkaan omia polygoneja.

Kun katvetila on muodostettu herää enää kysymys: Kuinka testataan mitkä pikselit ovat sen sisässä ja mitkä sen ulkopuolella? Kikka on seuraavanlainen. Ensin kuva renderöidään normaalisti, mutta tummemmalla värillä (esim. käyttäen pelkkää ympäristövaloa) täyttäen samalla syvyyspuskuri. Tämän jälkeen syvyyspuskurin päivitys laitetaan pois päältä ( glDepthMask(GL_FALSE) ), mutta säilyttäen syvyystestaus päällä. Tämän jälkeen katvetila piirretään sapluunapuskuriin ja saplaanaoperaatio asetetaan sellaiseksi, että sapluunapuskurin bitit, käännetään aina, kun sinne piirretään jotain ( glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT) ).

Näin katvetilan sisään jäävät pikselit saadaan arvoon 1 ja sen ulkopuoliset arvoon 0. Tämä sen takia, että syvyystestauksesta johtuen katvetilan ulkopuoliset bitit käännetään parillinen määrä kertoja, kun taas sisällä olevat pariton määrä kertoja. Tämän jälkeen kuva piirretään uudestaan oikealla värillä, mutta tällä kertaa saplaanatestaus päällä niin, että piirto tapahtuu vain niihin kohtiin missä saplaanapuskurin arvo on 0 ( glStencilFunc(GL_EQUAL, 0, ~0) ). Näin ollen varjostetulle alueelle ei piirry mitään ja niihin jää tumma varjon väri. Valitettavasti koverien monitahokkaiden tapauksessa antamani algoritmi tuottaa silhuetteja, jotka leikkaavat itsensä. Tällöin bittien kääntäminen sapluunapuskurissa ei anna oikeaa tulosta (kuten käy myös silloin kun kamera on katvetilan sisässä). Bittien kääntämisen sijaan voidaan käyttää jotain muuta algoritmia kuten “z-pass” tai ”Carmack’s reverse”. Näiden idea on piirtää katvetila kaksi kertaa.

Ensimmäisellä kerralla sen etupuoli sapluunapuskurin arvoa kasvattaen ja toisella sen takapuoli sapluunapuskurin arvoa vähentäen, jolloin saadaan taas katvetilan ulkopuolella olevat bitit arvoon 0 ja muut johonkin nollasta poikkeavaan arvoon. Jätän kuitenkin näihin algoritmeihin tutustumisen lukijan omalle vastuulle.

8. Esimerkkiohjelma

Esimerkkiohjelma piirtää tason ja sen päälle kuution ja yhden valonlähteen. Sekä taso, että kuutio valaistaan OpenGL:n omilla valoilla ja varjot tehdään käyttäen ”stencil shadow volumes”-algoritmia. Tämä on tähän astisista esimerkkiohjelmista monimutkaisin, mutta ei mahdoton ymmärtää. Voit imuroida oheisen lähdekoodin ja valmiiksi käännetyn version tästä: testi4.zip.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
#include <windows.h>

#include <gl\gl.h>

#include <gl\glu.h>

#include <math.h>

#include <stdio.h>

//#include <gl\glext.h>  // Ei tarvita tässä ohjelmassa



// Määrittele laitekonteksti globaaliksi sitä nimittäin tarvitaan myös pääfunktiossa.

HDC hdc;



// Valon sijainti

float lightPos[4]={ 0, 5, 0, 1 };



// Viestinkäsittelijä

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

  switch (uMsg)

  {

    // Koska piirrämme ikkunan sisällön pääsilmukassa jatkuvasti uudelleen

    // reakoimme WM_PAINT-viestiin vain tyhjentämällä ikkunan mustaksi.

    case WM_PAINT:

    {

      PAINTSTRUCT p;

      BeginPaint(hwnd, &p);

      glClear(GL_COLOR_BUFFER_BIT);

      SwapBuffers(hdc);

      EndPaint(hwnd, &p);

      return 0;

    }



    // Ikkuna yritetään sulkea kutsu PostQuitMessage()-funktiota.

    case WM_CLOSE:

    {

      PostQuitMessage(0);

      return 0;

    }



    // Käsittele myös WM_SIZE se lähetetään ikkunalle aina kun sen kokoa muutetaan.

    // Tämä on oiva tilaisuus muuttaa viewport

    // oikean kokoiseksi peittämään koko ikkuna.

    case WM_SIZE:

    {

      // Ikkunan uusi koko saadaan lParam parametrista LOWORD ja HIWORD makroilla.

      glViewport(0, 0, LOWORD(lParam), HIWORD(lParam));

      return 0;

    }

  }



  // Viestiä ei käsitelty kutsu DefWindowProc()-funktiota.

  return DefWindowProc(hwnd, uMsg, wParam, lParam);

}



int luoIkkuna(unsigned int leveys, unsigned int korkeus,

              char *otsikko)

{

  // Rekisteröi ikkunaluokka

  WNDCLASS wc;

  memset(&wc, 0, sizeof(WNDCLASS));

  wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

  wc.hCursor= LoadCursor(NULL, IDC_ARROW);

  wc.lpfnWndProc = (WNDPROC) WindowProc;

  wc.hInstance = GetModuleHandle(NULL);

  wc.lpszClassName = "OpenGLtutoriaali";

  if (!RegisterClass(&wc)) return 0;



 // Luo ikkuna

  RECT r;

  r.left=GetSystemMetrics(SM_CXSCREEN)/2-leveys/2;

  r.top=GetSystemMetrics(SM_CYSCREEN)/2-korkeus/2;

  r.right=r.left+leveys;

  r.bottom=r.top+korkeus;

  AdjustWindowRectEx(&r,

    WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW,

    FALSE,  WS_EX_APPWINDOW);

  HWND hwnd;

  hwnd=CreateWindowEx(WS_EX_APPWINDOW,

    "OpenGLtutoriaali", otsikko,

    WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW,

    r.left, r.top, r.right-r.left, r.bottom-r.top,

    NULL, NULL, GetModuleHandle(NULL), NULL);



  // Luo laitekonteksti

  hdc=GetDC(hwnd);

  if (!hdc) return 0;



  // Valitse pikseliformaatti

  PIXELFORMATDESCRIPTOR pfd;

  memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));

  pfd.nSize=sizeof(PIXELFORMATDESCRIPTOR);

  pfd.nVersion=1;

  pfd.dwFlags=PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER;

  pfd.iPixelType=PFD_TYPE_RGBA;

  pfd.cRedBits=8;

  pfd.cGreenBits=8;

  pfd.cBlueBits=8;

  pfd.cAlphaBits=8;

  pfd.cStencilBits=8;

  pfd.cDepthBits=16;

  pfd.iLayerType=PFD_MAIN_PLANE;

  int pixelFormat;

  pixelFormat=ChoosePixelFormat(hdc, &pfd);

  if (!pixelFormat) return 0;

  if (!SetPixelFormat(hdc, pixelFormat, &pfd)) return 0;



  // Luo renderöintikonteksti

  HGLRC hrc;

  hrc=wglCreateContext(hdc);

  if (!hrc) return 0;

  if (!wglMakeCurrent(hdc, hrc)) return 0;



  // Tuo ikkuna näkyviin

  ShowWindow(hwnd, SW_SHOW);

  SetForegroundWindow(hwnd);

  SetFocus(hwnd);



  // Palauta onnistuminen

  return 1;

}



// Laskee kahden vektorin pistetulon

float pistetulo(float v1[3], float v2[3])

{

  return v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2];

}



// Taso piirretään käyttäen useita pieniä nelikulmioita

// paremman valaistuksen saavuttamiseksi

void piirraTaso(void)

{

  int x, z;



  glBegin(GL_QUADS);

  glNormal3f(0,1,0);

  for (z=0; z<22; z+=2)

  {

    for (x=0; x<22; x+=2)

    {

      glVertex3f(-10+x, 0, -10+z);

      glVertex3f(-10+x, 0, -10+z+2);

      glVertex3f(-10+x+2, 0, -10+z+2);

      glVertex3f(-10+x+2, 0, -10+z);

    }

  }

  glEnd();

}



// Piirtää kuution tai sen katvetilan, jos katvetila-parametri on TRUE

void piirraKuutio(BOOL katvetila)

{

  // Data piirrettävää kuutiota varten

  static float vertex[8][3]={{-1,0,-1},{1,0,-1},{-1,2,-1},{1,2,-1},

                             {-1,0,1}, {1,0, 1},{-1,2, 1},{1,2, 1}};

  static int index[6][4]={ {0,2,3,1}, {4,5,7,6}, {5,1,3,7},

                           {4,6,2,0}, {7,3,2,6}, {4,0,1,5} };



  // Tahojen normaalit

  static float normal[6][3]={{0,0,-1},{0,0,1},{1,0,0},{-1,0,0},{0,1,0},{0,-1,0}};



  // Katvetilan muodostusta varten jokaisen tahon on tiedettävä naapurinsa.

  static int naapuri[6][4]={{3,4,2,5},{5,2,4,3},{5,0,4,1},

                            {1,4,0,5},{2,0,3,1},{3,0,2,1}};



  // Jokaiselle verteksille valoa kohti osoittava vektori.

  static float L[8][3];



  if (!katvetila)

  {

    // Piirrä kuutio

    glBegin(GL_QUADS);

    int i, j;

    for (i=0; i<6; i++)

    {

      glNormal3f(normal[i][0], normal[i][1], normal[i][2]);

      for (j=0; j<4; j++)

      {

        glVertex3f(vertex[ index[i][j] ][0],

                   vertex[ index[i][j] ][1],

                   vertex[ index[i][j] ][2]);

      }

    }

    glEnd();

  }

  else

  {

    int i,j;



    // Laske valoa kohti osoittavat vektorit.

    for (i=0; i<8; i++)

    {

      L[i][0]=lightPos[0]-vertex[i][0];

      L[i][1]=lightPos[1]-vertex[i][1];

      L[i][2]=lightPos[2]-vertex[i][2];

    }



    // Piirrä katvetila.

    // Tässä tulee sairaan paljon indeksointia, joka olisi voitu välttää

    // jonkinlaisen verteksi-structuren ja osoittimien käytöllä.

    glBegin(GL_QUADS);

    // Jokaiselle taholle

    for (i=0; i<6; i++)

    {

      // Jos tämä taho osoittaa kohti valoa

      if (pistetulo( normal[i], L[ index[i][0] ] )>=0)

      {

        // Jokaiselle vierustaholle

        for (j=0; j<4; j++)

        {

          // Jos tämä vierustaho EI osoita kohti valoa

          if (pistetulo(normal[ naapuri[i][j] ], L[ index[ naapuri[i][j] ][0] ])<0)

          {

            // Tahojen välinen särmä kuuluu silhuettiin

            // venytä se nelikulmioksi poispäin valosta.

            glVertex3f(vertex[ index[i][j] ][0],

                       vertex[ index[i][j] ][1],

                       vertex[ index[i][j] ][2]);

            glVertex3f(vertex[ index[i][(j+1)%4] ][0],

                       vertex[ index[i][(j+1)%4] ][1],

                       vertex[ index[i][(j+1)%4] ][2]);

            glVertex3f(vertex[ index[i][(j+1)%4] ][0]-100*L[ index[i][(j+1)%4] ][0],

                       vertex[ index[i][(j+1)%4] ][1]-100*L[ index[i][(j+1)%4] ][1],

                       vertex[ index[i][(j+1)%4] ][2]-100*L[ index[i][(j+1)%4] ][2]);

            glVertex3f(vertex[ index[i][j] ][0]-100*L[ index[i][j] ][0],

                       vertex[ index[i][j] ][1]-100*L[ index[i][j] ][1],

                       vertex[ index[i][j] ][2]-100*L[ index[i][j] ][2]);

          }

        }

      }

    }

    glEnd();

  }

}



// Pääfunktio

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

                   LPSTR lpCmdLine, int nCmdShow)

{

  float angle=0;



  unsigned int aika;

  unsigned int piirtoaika;

  unsigned int alkuaika;



  // Luo ikkuna

  if (!luoIkkuna(800, 600, "OpenGL:n perusteet - Osa 4: Valot ja varjot")) return 0;



  // Määrittele viewport koko ikkunan kokoiseksi

  glViewport(0, 0, 800, 600);



  // Koska koordinaatisto on itseasiassa matriisi täytyy meidän ottaa

  // projektiomatriisi käsiteltäväksi ennen gluPerspective-kutsua.

  glMatrixMode(GL_PROJECTION);

  gluPerspective(60, 800.0/600.0, 1, 100);



  // Kaikki matriisia muuttavat käskyt vaikuttavat tämän jälkeen modelview-matriisiin

  glMatrixMode(GL_MODELVIEW);



  // Laita näkymättömien pintojen poisto ja sysyyspuskurialgoritmi päälle.

  glEnable(GL_CULL_FACE);

 // Valitse syvyystestausfunktio "<=" oletuksena olevan "<" tilalle.

  glDepthFunc(GL_LEQUAL);

  glEnable(GL_DEPTH_TEST);



  // Aseta valo nro. 0 päälle

  float Cl[4]={0.8,0.8,0.8,1};

  float A[4]={0.2,0.2,0.2,1};

  float Cd[4]={1,1,1,1};

  glLightfv(GL_LIGHT0, GL_DIFFUSE, Cl);  // Väri

  glLightfv(GL_LIGHT0, GL_AMBIENT, A);   // Ympätisrövalon määrä

  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Cd); // Pinnan väri

  glEnable(GL_LIGHT0);



  // OpenGL lisää valaistukseen vielä yhden valonlähteistä

  // riippumattoman ympäristövalon, josta haluamme päästä eroon.

  float nolla[4]={0,0,0,1};

  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, nolla);



  // Viestinkäsittelysilmukka

  alkuaika=GetTickCount();

  MSG msg;

  while(1)

  {

    if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))

    {

      if (msg.message==WM_QUIT) break;

      TranslateMessage(&msg);

      DispatchMessage(&msg);

    }

    else

    {

      // Käytämme GetTickCount()-funktiota, joka palauttaa ajan millisekunneissa,

      // laskemaan kuvan piirtämiseen kuluneen ajan.

      // Näin voimme ajastaa valon liikkumaan samalla nopeudella kaikilla kokeilla.

      aika=GetTickCount();

      piirtoaika=aika-alkuaika;



      if (piirtoaika>0)

      {

        alkuaika=aika;



        // Kasvata pyörityskulmaa hieman seuraavaa framea varten.

        angle+=0.03*piirtoaika;



        // Tyhjennä väripuskuri, syvyyspuskuri ja sapluunapuskuri

        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);



        // Aseta modelview-matriisi

        glLoadIdentity();          // "Resetoi" matriisi yksikkömatriisiksi

        glTranslatef(0, -3, -10); // Siirrä hieman kauemmaksi kamerasta

        glRotatef(angle, 0, 1, 0); // Pyöritä hieman Y-akselin ympäri



        // Siirrä valoa

        lightPos[0]=5*sin(angle*-0.04);

        lightPos[1]=5+sin(angle*0.1);

        lightPos[2]=5*cos(angle*-0.04);

        glLightfv(GL_LIGHT0, GL_POSITION, lightPos);



        // Ensimmäinen vaihe.

        // täytetään syvyyspuskuri ja piirretään kuva käyttäen pelkkää ympäristövaloa

        glDisable(GL_LIGHTING);

        glDisable(GL_STENCIL_TEST);

        glColor3f(A[0], A[1], A[2]);

        piirraTaso();

        piirraKuutio(FALSE);



        // Toinen vaihe

        // Piirrä katvetila sapluunapuskuriin

        // Jos haluat päästä eroon varjoista kommentoi tämä toinen vaihe pois

        glDisable(GL_CULL_FACE); // Katvetilasta pitää piirtää kaikki osat

        glEnable(GL_STENCIL_TEST); // Sapluunapuskuri päälle

        glColorMask(0, 0, 0, 0);   // Emme halua päivittää väripuskuria

        glDepthMask(0);            // Emmekä syvyyspuskuria

        glStencilFunc(GL_ALWAYS, 0, 0);

        glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); // Käännä bitit piirtäessä

        piirraKuutio(TRUE);

        glEnable(GL_CULL_FACE);

        glColorMask(1, 1, 1, 1);

        glDepthMask(1);



        // Viimeinen vaihe

        // Piirrä lopullinen kuva kohtiin, jossa sapluunapuskurin arvo on 0

        glEnable(GL_LIGHTING);

        glStencilFunc(GL_EQUAL, 0, ~0);

        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

        piirraTaso();

        piirraKuutio(FALSE);



        // Piirrä vielä valonlähde

        glDisable(GL_LIGHTING);

        glDisable(GL_STENCIL_TEST);

        glPointSize(5);

        glBegin(GL_POINTS);

        glColor3f(1,1,0);

        glVertex3f(lightPos[0], lightPos[1], lightPos[2]);

        glEnd();



        // Vaihda puskuri näytölle.

        SwapBuffers(hdc);

      }

    }

  }



  return 0;

}

9. Loppusanat

Tässä artikkelissa opit valoista ja varjoista. Tässä artikkelisarjassa olemme nyt käyneet läpi pintapuolisesti kaikki 3d grafiiikan perusasiat. Lopuksi listaan vielä joitakin linkkejä, joista löydät rutkasti lisää luottevaa OpenGL:stä ja 3D grafiikasta yleensäkkin.

http://www.opengl.org – OpenGL:n virallinen kotisivu. Uutisia, viralliset speksit ja keskustelufoorumit löytyvät täältä.

http://nehe.gamedev.net – NeHe Productions. Netin ylivoimaisesti suosituimmat openGL tutoriaalit.

http://www.gamedev.net/download/redbook…. – The Red Book. Virallinen OpenGL:n opaskirja. Tämä netistä löytyvä ilmaisversio on aika hemmetin vanha, mutta ajaa asiansa. Uusin versio on saatavilla vain kirjakaupoista, mutta siitä on netissä yksi näyteluku:

http://www.opengl.org/documentation/red_… . http://oss.sgi.com/projects/ogl-sample/r… – SGI:n ylläpitämä OpenGL:n laajennusrekisteri. Sama löytyy myös kaikkien näytönohjainvalmistajien kotisivuilta.

http://www.delphi3d.net/hardware/index.p… – OpenGL Hardware Registry. Rekisteri, jossa on lueteltu valtavasti näytönohjaimia ja kerrottu mitä laajennuksia ne tukevat. http://www.mesa3d.org/ – Mesa 3D Graphics Library. Software OpenGL “ajurit”. Voit kokeilla näiden “ajurien” avulla laajennuksia, joita oma näytönohjaimesi ei tue. http://www.opengl.org/resources/faq/tech… – OpenGL faq. Usein kysytyt kysymykset OpenGL:stä.

http://www.gametutorials.com/gtstore/c-1… – Game tutorials. 50 aloittelijoille tarkoitettua OpenGL-tutoriaalia.

http://www.ultimategameprogramming.com – Ultimate game programming. Lähes 100 hieman edistyneimmille tarkoitettua OpenGL-tutoriaalia. http://www.codesampler.com/oglsrc.htm – CodeSampler. Paljon OpenGL tutoriaaleja aina aloittelijoille tarkoitetuista edistyneimpiin. Raportoithan kaikki tästä artikkelista löytämäsi virheet (niin kirjoitus-, kuin asiavirheetkin) osoitteeseen markus.ilmola@pp.inet.fi , niin korjaan ne mahdollisimman nopeasti. Myös kaikki kommentit ja kysymykset ovat tervetulleita

1. Johdatus tekstuureihin

Monitahokkaalla voidaan siis helposti jäljitellä kappaleen muotoa, mutta entäpä sen pintakuviota? Tietysti voimme värittää monitahokkaan glColor3f()-funktion kutsuilla, mutta harvan kappaleen pinnan väritys on kauniin tasainen. Voisimme tietenkin jakaa monitahokkaan tahot yhä pienempiin ja pienempiin polygoneihin, jolloin saisimme aikaiseksi millaisen värikuvion tahansa, mutta vähänkään shakkilautaa monimutkaisemmissa kuvioissa polygonien määrä nousisi valtavan suureksi. Olisikin hyvä, jos voisimme päällystää monitahokkaan valmiilla kuvalla, joka sisältäisi tarvittavan pintakuvion. Juuri tätä varten ovat olemassa tekstuurit. Tekstuuri voidaan piirtää erikseen jollakin kuvankäsittelyohjelmalla tai se voidaan generoida ajon aikana. Esim. shakkilautakuvion tuottaminen algoritmillisesti ei ole kovin hankalaa.

Asteroidin malli ilman tekstuuria ja sen kanssa. Oikealla käytetty tekstuuri.

Kuinka sitten määritellään miten tekstuuri asettuu monitahokkaan pinnalle? Tämä tehdään tekstuurikoordinaattien avulla. Jokaiselle verteksille määritellään sen sijainnin lisäksi myös missä kohtaa tekstuuria se sijaitsee. Tekstuurin origo sijaitsee sen vasemmassa alakulmassa. X-akseli kasvaa oikealle ja Y-akseli ylöspäin. Siis tavallisen koordinaatiston tapaan. Huomattavaa kuitenkin on, että riippumatta tektuurin koosta tai sen leveyden ja korkeuden suhteesta oikean ylänurkan koordinaatit ovat aina ( 1, 1 ).

Tekstuurikoordinaatit annetaan OpenGL:lle glTexCoord2f()-funktiolla. Funktiota kutsutaan jokaiselle verteksille erikseen. Sen prototyyppi näyttää tältä:

void glTexCoord2f(GLfloat s, GLfloat t);

s ja t ovat siis tekstuurikoordinaatin x ja y komponentit. Huomattavaa lisäksi on, että teksturointi täytyy myös laittaa päälle glEnable()-funktiolla, jolle annetaan parametrina GL_TEXTURE_2D. Käytimme tässä siis 2D-tekstuureja. On myös muita tekstuurityyppejä kuten 1D-tekstuurit. Silloin koordinaatti annettaisiin funktiolla glTexCoord1f() ja teksturointi laitettaisiin päälle antamalla glEnable()-funktiolle parametriksi GL_TEXTURE_1D.

Kuten glVertex-sarjan funktiolla annetut koordinaatit kerrottiin modelview-matriisilla, niin glTexCoord-sarjan funktioilla annetut koordinaatit kerrotaan tekstuurimatriisilla. Tätä matriisia voi muokata samoin kuin modelview-matriisiakin. Tekstuurimatriisi valitaan glMatrixMode()-funktiolla, jolle annetaan parametrina GL_TEXTURE ja sitä voi muokata samoilla funktioilla kuin kaikkia muitakin matriiseja eli esim. glTranslatef() ja glRotatef().

2. Tekstuuriobjektit

OpenGL:ssä tekstuurit ovat näytönohjaimen muistissa sijaitsevia objekteja (olioita), jotka täytyy luoda ennen käyttöä. Tekstuurin luominen tehdään funktiolla glGenTextures(). Sen prototyyppi näyttää tältä:

void glGenTextures(GLsizei n, GLuint *textures);

Parametri n kertoo kuinka monta tekstuuriobjektia luodaan ja parametri textures on osoitin taulukkoon, johon luotujen tekstuurien tunnukset laitetaan.

Teksturoinnin hoitaa näytönohjaimen teksturointiyksikkö. Jotta teksturointi olisi mahdollista, pitää tekstuuri ensin sitoa tähän teksturointiyksikköön glBindTexture()-funktiolla. Sen prototyyppi näyttää tältä.

void glBindTexture(GLenum target, GLuint texture);

Texture on sidottavan tekstuurin tunnus eli se, joka saatiin glGenTextures()-funktiolta. Vain yksi tekstuuri voi olla sidottuna kerrallaan (tästä on tosin poikkeus, josta puhumme kappaleessa multiteksturointi)!

Target on sidottavan tekstuurin tyyppi. OpenGL:ssä on useita eri tekstuurityyppejä, mutta hyödyllisin niistä on GL_TEXTURE_2D eli 2D-tekstuuri, joka vastaa tavallista kuvaa. Luodessa tekstuuri on tyypitön ja tekstuuri omaa sen tyypin, jona se ensimmäisen kerran sidotaan teksturointiyksikköön.

Kun polygoni piirretään, teksturoidaan se sillä tekstuurilla, joka on sillä hetkellä sidottuna teksturointiyksikköön. Myös kaikki tekstuureihin vaikuttavat funktiot, joista tässä artikkelissa puhumme vaikuttavat siihen tekstuuriin, joka on sillä hetkellä sidottuna.

Luotu tekstuuri on kuitenkin tyhjä, eikä sisällä mitään dataa. Jos kokeilisit teksturoida tyhjällä tekstuurilla saisit tulokseksi pelkkää valkoista väriä. Niinpä tekstuuriin täytyy ladata dataa. 2D-tekstuuriin data ladataan funktiolla glTexImage2D(). Prototyyppi on tämän näköinen:

void glTexImage2D(
GLenum target,
GLint level,
GLint components,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type,
const GLvoid *pixels);

Parametrin target arvon pitää olla aina GL_TEXTURE_2D.

Parametrien level ja border arvojen pitää olla nolla.

Parametri Components kertoo formaatin, jossa OpenGL tallentaa tekstuurin sisäisesti näytönohjaimen muistiin. Tämä voi olla joko tarkka formaatti tai haluttavienvärikomponenttien määrä, jolloin OpenGL valitsee automaattisesti sopivan formaatin. Pitääksemme asiat yksinkertaisena käytämme värikomponenttien määrää. Tämä on yleensä 3 (red, green ja blue). Joskus myös 4 (red, green, blue ja alpha), jos alphakanava on mukana, mutta alphakanavasta enemmän kappaleessa läpinäkyvyys.

Width ja height kertovat tekstuurin leveyden ja korkeuden. Näiden lukujen täytyy olla kakkosen potensseja eli 32, 64, 128, 256 jne. Näillä arvoilla on myös jokin yläraja, jonka saat selville funktiolla glGetIntegerv(), parametrilla GL_MAX_TEXTURE_SIZE. Hyvin vanhoissa näytönohjaimissa raja on 256, kun taas uusissa 4096 tai jopa enemmän.

Format kertoo tekstuuriin syötettävän datan muodon. Tämä on yleensä joko GL_RGB tai GL_RGBA jos alphakin on mukana. Ladattavan datan pitää siis sisältää tekstuurin kaikkien pikselien värit tyyliin RGBRGBRGB… jne. Eli ensimmäisen pikselin värin Red, Green ja Blue komponentit, sitten seuraavan jne. Jos tekstuurissa on alphakanava mukana (GL_RGBA), pitää datan taas olla muodossa RGBARGBARGBA… jne.

Type-parametri kertoo ladattavan datan tyypin. Vaihtoehdot ovat: GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, ja GL_FLOAT. Yleisin käytetty muoto on GL_UNSIGNED_BYTE.

Viimeinen parametri on osoitin varsinaiseen ladattavaan dataan, joka on esim. piirretty kuvankäsittelyohjelmalla tai generoitu jollakin algoritmilla. Jos datan tyyppi on GL_FLOAT pitää näiden arvojen olla välillä 0-1. Muuten suurin käytetyllä tyypillä esitettävissä oleva luku tulkitaan luvuksi 1 ja pienin luvuksi 0. Huomaa, että data ladataan siihen tekstuuriin, joka on sillä hetkellä sidottuna teksturointiyksikköön. Jos tekstuuri sisältää jo dataa, korvautuu se uudella.

Kun tekstuuri käy turhaksi, se voidaan poistaa funktiolla:

glDeleteTextures(GLsizei n,	 const GLuint * textures);

Parametrien merkitykset ovat samat kuin glGenTextures()-funktiossakin, eli poistettavien tekstuurien määrä ja osoitin taulukkoon, joka sisältää poistettavien tekstuurien tunnukset.

3. Tekstuurin reunat ja suodatus

Mitä mahtaakaan tapahtua, jos annetut tekstuurikoordinaatit menevät tekstuurin reunojen ulkopuolelle? Sen voit valita itse. Vaihtoehdot ovat joko korvata ulkopuoliset pikselit jollain vakio värillä (mustalla), korvata ne lähimmällä reunapikselillä tai alkaa toistaa pikseleitä tekstuurin toisesta reunasta. Reunakäyttäytyminen asetetaan funktiolla glTexParameteri(). Prototyyppi näyttää tältä:

void glTexParameteri(GLenum target, GLenum pname, GLint param);

Ensimmäinen parametri on tekstuurin tyyppi (tässä tapauksessa GL_TEXTURE_2D). Toisen parametrin on oltava GL_TEXTURE_WRAP_S tai GL_TEXTURE_WRAP_T. Se ilmaisee asetetaanko käyttäytyminen vaaka vai pystyakselille. Voit siis laittaa kummallekkin akselille erilaisen. Viimeinen parametri on GL_CLAMP, GL_CLAMP_TO_EDGE, tai GL_REPEAT. Vaihtoehdot on kuvattu alla olevassa kuvassa.

Itseasiassa GL_CLAMP:n käyttäytyminen on hieman erilainen kuin tässä annetaan ymmmärtää ja kappaleessa 6 kerrotusta syystä GL_CLAMP_TO_EDGE on määritelty tiedostosssa glext.h eikä gl.h kuten muut, mutta asiat selviävät tarkemmin virallisista spekseistä jos kiinnostaa.

3D-korttien alkuaikoina oli Voodoo-korttien ajureissa bugi, jonka takia GL_CLAMP käyttäytyi samoin kuin GL_CLAMP_TO_EDGE. Monet sovelluksen tekijät luottivat sokeasti tähän käyttäytymiseen tarkistamatta asiaa dokumentaatiosta ja näin ollen kun ohjelmia käytettiin korteilla, joissa tätä bugia ei ollut, oli grafiikka joskus virheellistä. Tämän ja sen takia, että GL_CLAMP:n oikeaoppinen käyttäytyminen on käytännössä hyödytön, monet näytönohjainvalmistajat jättivät mahdollisuuden laittaa tämä bugi päälle omissa näytönohjaimissaan.

Kun teksturoitua kappaletta katsotaan niin läheltä, että yksi tekstuurin kuvapiste eli tekseli näyttää suuremmalta kuin pikseli, kuva ns. puuroutuu eli muuttuu (lego)palikkamaiseksi. Asia voidaan korjata suodatuksella, joka saadaan päälle tutulla glTexParameteri()-funktiolla, joka saa toisena parametrinaan GL_TEXTURE_MAG_FILTER ja viimeisenä parametrinaan joko GL_NEAREST, jos suodatus halutaan pois päältä, tai GL_LINEAR jos suodatus halutaan päälle. Oletuksena suodatus on jo valmiina päällä.

Vastaavasti kun kappale on niin kaukana, että yhden pikselin alalle mahtuu monta tekseliä alkaa kuva ”vilkkua”. Tähänkin ongelmaan on ratkaisu. Sitä kutsutaan termillä ”mipmapping”. Ideana on tallentaa tekstuurista monta erikokoista versiota ja valita niistä sitten se, joka lähinnä vastaa oikeaa kokoa. Mipmapping asetetaan päälle glTexParameteri()-funktiolla. Tällä kertaa keskimmäisenä parametrina on GL_TEXTURE_MIN_FILTER ja viimeisenä GL_LINEAR_MIPMAP_LINEAR. Kun mipmapping halutaan pois päältä, käytetään GL_LINEAR_MIPMAP_LINEAR parametrin sijasta parametria GL_LINEAR tai GL_NEAREST, riippuen siitä, halutaanko myös kaukana olevat tekselit suodattaa. Oletuksena mipmapping on päällä.

Lisäksi meidän on generoitava mipmap:it. OpenGL osaa tehdä tämän automaattisesti useammallakin eri tavalla, mutta helpoimmalla pääset kun lataat datan glTexImage2D()-funktion sijasta gluBuild2Dmipmaps()-funktiolla. Sen prototyyppi on seuraavanlainen.

int gluBuild2DMipmaps(
    GLenum target,
    GLint components,
    GLint width,
    GLint height,
    GLenum format,
    GLenum type,
    const void * data
   );

Parametrien merkitykset ovat samat kuin glTexImage2D()-funktiollakin.

Koska mipmapping on oletuksena päällä, törmää usein tilanteeseen, jossa unohtaa generoida mippappien tarvitseman datan (käyttää siis pelkästään funktiota glTexImage2D). Tämän takia mipmaping tulee muistaa kääntää pois päältä aina, kun sitä ei tarvitse.

4. Läpinäkyvyys

Yksi kysymys, joka usein nousee esille on, kuinka jokin tietty tekstuurin väri saadaan läpinäkyväksi. Mitään väriä ei voida suoraan asettaa läpinäkyväksi, vaan värille täytyy määrittää tavallisten red, green ja blue komponenttien lisäksi vielä neljäs läpinäkyvyyskomponentti eli ns. alphakomponentti. Useimmat kuvankäsittelyohjelmat kuten Paint Shop Pro ja Photo Shop tukevat alphakanavaa. Kuvaformaateista esim. TGA ja PNG tukevat alphakanavaa.

Voit myös generoida alphakanavan ajon aikana. Kun lataat tekstuurin, testaa onko pikselin väri se, jonka haluat läpinäkyväksi. Jos on aseta sen alpha nollaksi, muuten ykköseksi (tai jos et käytä GL_FLOAT-tyyppiä, niin käyttämäsi tyypin maksimi arvoon).

Kuvassa vasemmalla tekstuuri, joka sisältää kuvan avaruushirviöstä. Keskellä tämän tekstuurin alphakanava. Oikealla tekstuuri piirretty taustan päälle, niin että pikselit joiden alphan arvo on pienempi kuin 0.5 (musta) on jätetty piirtämättä.

On kaksi tapaa saada aikaan läpinäkyvyys alphan avulla. Ne ovat GL_ALPHA_TEST ja GL_BLEND. Ne voidaan laittaa päälle glEnable()-funktiolla antamalla kyseinen symboli parametrina.

GL_ALPHA_TEST:n ideana on asettaa funktio, joka joko hyväksyy tai hylkää pikselin sen alphan arvon perusteella. Tämä funktio asetetaan glAlphaFunc()-funktiolla. Sen prototyyppi näyttää tältä:

void glAlphaFunc(GLenum func, GLclampf ref);

Ensimmäinen parametri kertoo funktion. Sen mahdolliset arvot ovat GL_NEVER, GL_LESS, GL_EQUAL, GL_GREATER ja GL_ALWAYS. Nimestä pystyy helposti näkemään mitä ne tekevät. Viimeinen kertoo tämän funktion käyttämän vertailuarvon. Esim. jos haluaisimme, että pikseli piirretään vain kun sen alphan arvo on yli 0.5 käyttäisimme kutsua glAlphaFunc(GL_GREATER, 0.5);.

GL_BLEND:n idea on hieman erilainen. Siinä pikselin lopullinen väri lasketaan sen alkuperäisestä väristä ja ikkunassa pikselin paikalla olevan aikaisemman pikselin väristä. Lopullinen väri lasketaan kaavalla S*uusiPikseli+D*vanhaPikseli. Parametrit S ja D asetetaan funktiolla glBlendFunc(). Prototyyppi on seuraavan näköinen:

glBlendFunc(GLenum sfactor, GLenum dfactor);

sFactor asettaa S parametrin ja sFactor D parametrin. Kummatkin arvot on valittava seuraavista: GL_ZERO, GL_ONE, GL_DST_COLOR, GL_SRC_COLOR, GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA ja GL_ONE_MINUS_DST_ALPHA. Nimistä on helppo päätellä mitä ne ovat, kun panet merkille, että SCR tarkoittaa uutta pikseliä ja DST vanhaa pikseliä. Esim. jos haluaisimme tekstuurin alphakanavan määräävän pikselin läpinäkyvyyden käyttäisimme kutsua: glBlendFunc(GL_SCR_ALPHA, GL_ONE_MINUS_SCR_ALPHA). GL_BLEND siis mahdollistaa osittaisen läpinäkyvyyden toisin kuin GL_ALPHA_TEST.

GL_ALPHA_TEST:llä ja GL_BLEND:llä on vielä yksi merkittävä ero. GL_ALPHA_TEST nimittäin jättää läpinäkyvät pikselit piirtämättä syvyyspuskuriin, kun taas GL_BLEND piirtää kaikki pikselit syvyyspuskuriin. Myös täysin läpinäkyvät. Olettaen tietenkin, että GL_DEPTH_TEST on päällä.

Kaksiulotteista teksturoitua suorakaiteen muotoista osittain läpinäkyvää polygonia kutsutaan joskus kuvahahmoksi (englanniksi sprite). Ne ovat varsin käytännöllisia 2D-grafiikassa. Kaksiulotteisten kuvien piirtoon löytyy OpenGL.stä ihan oma funktionsa: glBitmap(), mutta se on hitaampi ja vähemmän käytännöllinen kuin teksturoidun nelikulmion piirto, joten en suosittele sen käyttöä.

5. Texture environment

Polygoneillehan voitiin määrätä väri glColor3f()-funktiolla, mutta kuinka tämä väri sitten yhdistyy tekstuurin väriin? Tästä asiasta huolehtii ”texture environment”. Texture environment on itse asiassa funktio, joka saa syötteenään varsinaisen värin ja tekstuurin värin ja laskee näistä pikselin lopullisen värin. Tämä funktio pitää valita muutamasta valmiista vaihtoehdosta. Texture environment:in funktio valitaan funktiolla glTexEnvi(), jonka prototyyppi näyttää tältä:

void glTexEnvi(GLenum target, GLenum pname, GLint param);

Ensimmäisen parametrin arvon on aina oltava GL_TEXTURE_ENV ja toisen GL_TEXTURE_ENV_MODE. Kolmas on asetettava funktio. Sen mahdolliset arvot ovat: GL_MODULATE, GL_DECAL ja GL_ADD. GL_MODULATE kertoo värit keskenään ja GL_ADD taas laskee ne yhteen. GL_DECAL sen sijaan interpoloi näiden arvojen välillä käyttäen viitteenä tekstuurin alphakanavaa. Alphan arvolla yksi väri on tekstuurin väri ja arvolla nolla varsinainen väri. Muilla arvoilla jossakin tässä välissä. Jos tekstuurissa ei ole alphakanavaa, katsotaan alphan arvon olevan yksi.

6. OpenGL:n laajennukset

Ennen kuin voimme jatkaa, pitää meidän puhua jokunen sana OpenGL:n laajennuksista (englanniksi extensions).

Näytönohjaimet kehittyvät koko ajan ja niihin ilmestyy uusia ominaisuuksia. Tämän takia myös niitä käyttävien rajapintojen on kehityttävä mukana. Direct3D:n tapauksessa tämä on ratkaistu julkaisemalla siitä uusi versio vuoden parin välein. Tällä uudella versiolla ei ole välttämättä mitään yhteistä vanhan kanssa ja koko rajapinta on pahimmillaan opeteltava uudestaan. OpenGL:ssä sen sijaan rakennetaan vanhan päälle. Aina, kun jokin uusi ominaisuus ilmestyy näytönohjaimiin, julkaistaan siitä laajennus OpenGL:ään. Laajennus tuo mukanaan nipun uusia funktioita ja/tai uusia parametrejä vanhoihin funktioihin. Joskus ei kumpaakaan. Laajennuksista pitää kirjaa SGI:n laajennusrekisteri osoitteessa: http://oss.sgi.com/projects/ogl-sample/r… Lisäksi kaikkien näytönohjainvalmistajien kotisivuilta on löytyy sama rekisteri.

Voidaksesi käyttää laajennuksia tarvitset uuden otsikkotiedoston glext.h. Saat sen osoitteesta: http://oss.sgi.com/projects/ogl-sample/A… Se mitä laajennuksia käytössä on riippuu koneen näytönohjaimesta. Uudet näytönohjaimet tukevat lähes kaikkia laajennuksia, kun taas hyvin vanhat vain muutamaa. Saat selville tuetut laajennukset funktiolla glGetString(), jolle annetaan parametrinä GL_EXTENSIONS. Se palauttaa osoittimen merkkijonoon, joka sisältää kaikkien tuettujen laajennusten nimet välilyönnillä eroteltuna.

Laajennus ei siis tuo välttämättä mitään uusia funktioita tai parametrejä. Se vain sallii jotain sellaista, joka oli aikaisemmin kiellettyä. Hyvä esimerkki tästä on ARB_texture_non_power_of_two-laajennus, joka sallii käytettävän tekstuureja, joiden koko ei ole kakkosen potenssi. Eli jos glGetString(GL_EXTENSIONS) palauttamassa merkkijonossa esiintyy nimi GL_ARB_texture_non_power_of_two voit käyttää minkä kokoisia tekstuureja tahansa.

Jos taas laajennus tuo uusia parametrejä ei laajennuksen käyttö ole hankalaa silloinkaan. Kaikki uudet symbolit on nimittäin määritelty tiedostossa glext.h. Hyvä esimerkki tällaisesta laajennuksesta on GL_ARB_texture_env_combine-laajennos, joka tuo texture environment:iin rutkasti lisää vaihtoehtoja perinteisten GL_MODULATE:n ja GL_ADD:n lisäksi.

Vasta, kun laajennus tuo mukanaan uusia funktioita, on laajennuksen käyttö hieman hankalampaa. Funktioihin pitää nimittäin käydä noutamassa osoittimet. wglGetProcAddress() funktiolla. Sen prototyyppi näyttää tältä:

PROC wglGetProcAddress(
    LPCSTR  lpszProc 	//Name of the extension function
   );

Eli sille annetaan parametrinä uuden funktion nimi ja se palauttaa osoittimen siihen.

Laajennuksia on tällä hetkellä useampi sata, joten niiden hallinnointi käsin alkaa olla sulaa hulluutta. Tämän takia netti on pullollaan erilaisia kirjastoja laajennusten hallintaan. Niiden periaate on, että ne tarjoavat jonkin helppokäyttöisen funktion, joka lataa yhdellä kutsulla osoittimet kaikkiin näytönohjaimen tukemiin laajennuksiin. Yksi hyvä kirjasto tähän on GLEW: http://glew.sourceforge.net/ .

Suosittelen lämpimästi, että heti, kun alat tarvita laajennuksia, lataa GLEW ja käytä sitä. ÄLÄ ala pelleilemään niiden kanssa ”käsin”. GLEW:n avulla sinun tarvitsee tehdä yksi ainut funktio kutsu ja kaikki laajennukset ovat suoraan käytössäsi.

Huomaa vielä, että jokaisella laajennuksen nimellä on jokin etuliite. Esim. ARB, EXT, NV tai ATI. ARB ja EXT ovat laajennuksia, joita kaikkien näytönohjainvalmistajien kortit tukevat. Kun taas muut ovat valmistajakohtaisia laajennuksia. Vältä niiden käyttöä, sillä ne ovat tuettuja yleensä vain yhden valmistajan kortilla. Pyri käyttämään ensisijaisesti ARB-laajennuksia ja toissijaisesti EXT-laajennuksia.

7. Eksoottisemmat tekstuurimuodot

1D- ja 2D-tekstuurien lisäksi OpenGL:ssä kaksi muutakin tekstuurimuotoa: 3D-tekstuurit (GL_TEXTURE_3D_EXT) ja cubemap-tekstuurit (GL_TEXTURE_CUBE_MAP_ARB). Kummatkin nämä tekstuurimuodot ovat laajennuksia eli sinun pitää tarkistaa ennen niiden käyttöä, että käytössä oleva näytönohjain tukee niitä.

7.1 3D-tekstuurit

3D-tekstuurit ovat looginen jatko 1D- ja 2D-tekstuureille. 3D tekstuurit ovat laajennus OpenGL:ään ja tämän laajennuksen nimi on GL_EXT_texture3D. Eli niitä voidaan käyttää vain, jos glGetString(GL_EXTENSIONS)-kutsun palauttama merkkijono sisältää kyseisen nimen. Tämä laajennus tuo mukanaan yhden uuden funktion glTexImage3DEXT(), jonka prototyyppi näyttää tältä:

void glTexImage3DEXT(GLenum target,
		       GLint level,
		       GLenum internalformat,
		       GLsizei width,
		       GLsizei height,
		       GLsizei depth,
		       GLint border,
		       GLenum format,
		       GLenum type,
		       const GLvoid* pixels);

Meidän tarvitsee siis hakea osoitin tähän funktioon ennen sen käyttöä. Se tehdään seuraavasti:

void (*glTexImage3DEXT)(GLenum, GLint, GLenum, GLsizei, GLsizei,
                        GLsizei, GLint, GLenum, GLenum, const GLvoid*) =
  wglGetProcAddress("glTexImage3DEXT ");

Jätin tyyppimuunnoksen selkeyden vuoksi tekemättä. Tai helpommin:

PFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT=
  (PFNGLTEXIMAGE3DEXTPROC )wglGetProcAddress("glTexImage3DEXT ");

PFNGLTEXIMAGE3DEXTPROC-typedef on määritelty tiedostosssa glext.h. Kun osoitin on haettu voidaan funktiota käyttää normaalisti. glTexImage3DEXT()-funktio toimii aivan samoin kuin glTexImage1D() ja glTexImage2D():kin. Siinä vain on tekstuurin leveyden ja korkeuden lisäksi mukana syvyys. Lisäksi tekstuurikoordinaatit pitää antaa glTexCoord3f()-funktiolla ja teksturointi laittaa päälle kutsulla glEnable(GL_TEXTURE_3D_EXT);

7.2 Cube map-tekstuurit

“Cube map”-tekstuuri on nimensä mukaisesti kuution muotoinen tekstuuri. Se muodostuu kuudesta eri 2D-tekstuurista, joista jokainen muodostaa kuution yhden sivun. Myös cube map on laajennus. Sen nimi on ARB_texture_cube_map. Cube map ei tuo uusia funktioita ainoastaan uusia parametrejä.

Data cube map:iin ladataan glTexImage2D()-funktiolla. Ainoa ero on, että ensimmäiseksi parametriksi tulee GL_TEXTURE_2D:n sijaan TEXTURE_CUBE_MAP_POSITIVE_X_ARB, TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, TEXTURE_CUBE_MAP_POSITIVE_Z_ARB tai TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, riippuen siitä mikä kuution kuudesta eri sivusta halutaan asettaa. Vastaavasti cube map teksturointi laitetaan päälle glEnable()-functiolla, jolle annetaan parametrina TEXTURE_CUBE_MAP_ARB.

Tekstuurikoordinaatit toimivat cube map:issa hieman oudosti. Tekstuurikoordinaatti annetaan glTexCoord3f()-funktiolla, mutta koordinaattia vastaa kuutiolla piste, joka saadaan kuution keskipisteestä lähtevän glTexCoord3f()-funktiolla annetun vektorin suuntaisen suoran ja kuution leikkauspisteestä.

8. Multiteksturointi

Multiteksturointi tarkoittaa mahdollisuutta päällystää polygoni usealla tekstuurilla yhtä aikaa. Näytönohjaimissa on ns. teksturointiyksikköjä joista jokaiseen voi sitoa oman tekstuurin. Kun pikseli sitten piirretään vaikuttaa sen väriin jokainen teksturointiyksikkö.

Nykyisissä näytönohjaimissa voi olla jopa 8-16 teksturointiyksikköä, kun taas vanhoissa yleensä vain 2-4. Saat selville näytönohjaimen teksturointiyksiköiden määrän glGetIntegerv()-funktiolla, jolle annetaan parametrina GL_MAX_TEXTURE_UNITS_ARB. Kuten muutkin nykyiset hienoudet on myös multiteksturointi laajennus. Multiteksturointi tuo OpenGL:ään useitakin uusia funktioita kuten:

void glMultiTexCoord1fARB(GLenum texture, GLfloat s);
void glMultiTexCoord2fARB(GLenum texture, GLfloat s, GLfloat t);
void glActiveTextureARB(GLenum texture);.

Jokaiseen teksturointiyksikköön voi olla sidottuna kerrallaan yksi tekstuuri. glBindTexture() sitoo tekstuurin kulloinkin aktiivisena olevaan teksturointi yksikköön. Yksi teksturointiyksiköistä voi olla aktiivisena kerrallaan ja aktiivinen yksikkö valitaan glActiveTextureARB()-funktiolla joka saa syötteenään GL_TEXTURE0_ARB, GL_TEXTURE1_ARB, GL_TEXTURE2_ARB jne. eli aktivoitavan teksturointi yksikön. Huomaa myös, että kutsu glEnable(GL_TEXTURE_2D) laittaa teksturoinnin päälle siihen teksturointiyksikköön, joka on sillä hetkellä aktiivisena, eli funktiota on kutsuttava jokaiselle teksturointiyksikölle erikseen.

Tekstuurikoordinaatit vuorostaan annetaan glMultiTexCoord2fARB()-funktiolla. Sen ensimmäinen parametri kertoo teksturointiyksikön samoin kuin glActiveTextureARB()-funktiollakin ja loput tekstuurikoordinaatit. glTexCoord2f()-funktion kutsu vastaa glMultiTexCoord2fARB()-funktion kutsua, jonka ensimmäinen parametri on GL_TEXTURE0_ARB.

Vielä viimeinen ongelma on, mikä sitten määrää kuinka nämä tekstuurit yhdistyvät? Vastaus on tietenkin teksture environment. glTextureEnvi()-funktio asettaa texture environment funktion aktivoituna olevaan teksturointiyksikköön. Jokaisella teksturointiyksiköllä on siis oma texture environment funktio. Kun pikseli piirretään saa se aluksi glColor3f()-funktiolla annetun värin. Sen jälkeen pikselin väriin vaikuttaa vuoronperään jokainen teksturointiyksikkö, jolle teksturointi on laitettu päälle, omalla texture environment funktiollaan.

9. Esimerkkiohjelma

Vaikka tässä artikkelissa puhuimmekin OpenGL:än laajennuksista ja monista edistyneimmistä teksturointitekniikoista on esimerkkiohjelma varsin yksinkertainen.

Se lataa levyltä kaksi tekstuuria tiedostoista ”alien.kuva” ja ”tausta.kuva”. Ohjelma piirtää kaksi nelikulmaista polygonia, joista toisen se teksturoi alien-tekstuurilla ja toisen taustatekstuurillla.

Data näissä tiedostoissa on ns. raakamuodossa eli se voidaan antaa sellaisenaan glTexImage2D()-funktiolle. Raakadatakuvia voi tallentaa yleisimmillä kuvankäsittelyohjelmilla. Tällaisten raakatiedostojen käyttö ei kuitenkaan ole suositeltavaa sillä ne eivät sisällä esimerkiksi tietoa kuvan koosta, joten se on tiedettävä erikseen.

Yleensä kannattaakin käyttää jotain hyvää standardia tiedostomuotoa kuten JPG tai PNG. Näiden formaattien lataamisesta voisi kuitenkin kirjoittaa vaikka oman artikkelinsa, joten käytän tässä helpompaa raakadataformaattia. On olemassa valmiita kirjastoja, jotka osaavat lukea lukuisia kuvaformaatteja. Yksi hyvä tällainen on DEVIL. DEVIL kirjaston käytöstä on tässä artikkelissa liite seuraavalla sivulla.

Saadaksesi esimerkkiohjelman toimimaan sinun tarvitsee imuroida kuvatiedostot (testi3.zip). Paketti sisältää myös oheisen lähdekoodin ja valmiiksi käännetyn version.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
#include <windows.h>

#include <stdio.h>

#include <math.h>

#include <gl\gl.h>

#include <gl\glu.h>

//#include <gl\glext>  // Ei tarvita tässä ohjelmassa



// Määrittele laitekonteksti globaaliksi sitä nimittäin tarvitaan myös pääfunktiossa.

HDC hdc;



// Viestinkäsittelijä

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

  switch (uMsg)

  {

  // Koska piirrämme ikkunan sisällön pääsilmukassa jatkuvasti uudelleen

    // reakoimme WM_PAINT-viestiin vain tyhjentämällä ikkunan mustaksi.

    case WM_PAINT:

    {

      PAINTSTRUCT p;

      BeginPaint(hwnd, &p);

      glClear(GL_COLOR_BUFFER_BIT);

      SwapBuffers(hdc);

      EndPaint(hwnd, &p);

      return 0;

    }



    // Ikkuna yritetään sulkea kutsu PostQuitMessage()-funktiota.

    case WM_CLOSE:

    {

      PostQuitMessage(0);

      return 0;

    }



    // Käsittele myös WM_SIZE se lähetetään ikkunalle aina kun sen kokoa muutetaan.

    // Tämä on oiva tilaisuus muuttaa viewport

    // oikean kokoiseksi peittämään koko ikkuna.

    case WM_SIZE:

    {

      // Ikkunan uusi koko saadaan lParam parametrista LOWORD ja HIWORD makroilla.

      glViewport(0, 0, LOWORD(lParam), HIWORD(lParam));

      return 0;

    }

  }



  // Viestiä ei käsitelty kutsu DefWindowProc()-funktiota.

  return DefWindowProc(hwnd, uMsg, wParam, lParam);

}



int luoIkkuna(unsigned int leveys, unsigned int korkeus,

              char *otsikko)

{

  // Rekisteröi ikkunaluokka

  WNDCLASS wc;

  memset(&wc, 0, sizeof(WNDCLASS));

  wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

  wc.hCursor= LoadCursor(NULL, IDC_ARROW);

  wc.lpfnWndProc = (WNDPROC) WindowProc;

  wc.hInstance = GetModuleHandle(NULL);

  wc.lpszClassName = "OpenGLtutoriaali";

  if (!RegisterClass(&wc)) return 0;



  // Luo ikkuna

  RECT r;

  r.left=GetSystemMetrics(SM_CXSCREEN)/2-leveys/2;

  r.top=GetSystemMetrics(SM_CYSCREEN)/2-korkeus/2;

  r.right=r.left+leveys;

  r.bottom=r.top+korkeus;

  AdjustWindowRectEx(&r,

    WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW,

    FALSE,  WS_EX_APPWINDOW);

  HWND hwnd;

  hwnd=CreateWindowEx(WS_EX_APPWINDOW,

    "OpenGLtutoriaali", otsikko,

    WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW,

    r.left, r.top, r.right-r.left, r.bottom-r.top,

    NULL, NULL, GetModuleHandle(NULL), NULL);



  // Luo laitekonteksti

  hdc=GetDC(hwnd);

  if (!hdc) return 0;



  // Valitse pikseliformaatti

  PIXELFORMATDESCRIPTOR pfd;

  memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));

  pfd.nSize=sizeof(PIXELFORMATDESCRIPTOR);

  pfd.nVersion=1;

  pfd.dwFlags=PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER;

  pfd.iPixelType=PFD_TYPE_RGBA;

  pfd.cRedBits=8;

  pfd.cGreenBits=8;

  pfd.cBlueBits=8;

  pfd.cAlphaBits=8;

  pfd.cStencilBits=8;

  pfd.cDepthBits=16;

  pfd.iLayerType=PFD_MAIN_PLANE;

  int pixelFormat;

  pixelFormat=ChoosePixelFormat(hdc, &pfd);

  if (!pixelFormat) return 0;

  if (!SetPixelFormat(hdc, pixelFormat, &pfd)) return 0;



  // Luo renderöintikonteksti

  HGLRC hrc;

  hrc=wglCreateContext(hdc);

  if (!hrc) return 0;

  if (!wglMakeCurrent(hdc, hrc)) return 0;



 // Tuo ikkuna näkyviin

  ShowWindow(hwnd, SW_SHOW);

  SetForegroundWindow(hwnd);



  SetFocus(hwnd);



  // Palauta onnistuminen

  return 1;

}



// Pääfunktio

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

LPSTR lpCmdLine, int nCmdShow)

{

  unsigned char *data;

  float angle=0;

  GLuint taustaTekstuuri=0;

  GLuint alienTekstuuri=0;

  FILE *tiedosto=NULL;



  unsigned int aika;

  unsigned int piirtoaika;

  unsigned int alkuaika;



 // Luo ikkuna

  if (!luoIkkuna(800, 600, "OpenGL:n perusteet - Osa 3: Teksturointi")) return 0;



  // Varaa muistia väliaikaiselle datalle

  data=(unsigned char *)malloc(256*256*4*sizeof(unsigned char));

  if (!data) return 0;



  // luo yksi tekstuuriobjekti

  glGenTextures(1, &taustaTekstuuri);

  // Sido äsken luotu tekstuuri teksturointiyksikköön

  glBindTexture(GL_TEXTURE_2D, taustaTekstuuri);

  // Lataa kuvadata tiedostosta.

  tiedosto=fopen("tausta.kuva", "rb");

  if (!tiedosto) return 0;

  fread(data, 3, 128*128, tiedosto);

  fclose(tiedosto);

  // Lataa data tekstuuriin

  glTexImage2D(GL_TEXTURE_2D, 0, 3, 128, 128, 0, GL_RGB, GL_UNSIGNED_BYTE, data);

  // Suodatus päälle

  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);



  // luo yksi tekstuuriobjekti

  glGenTextures(1, &alienTekstuuri);

  // Sido äsken luotu tekstuuri teksturointiyksikköön

  glBindTexture(GL_TEXTURE_2D, alienTekstuuri);

  // Lataa kuvadata tiedostosta

  tiedosto=fopen("alien.kuva", "rb");

  if (!tiedosto) return 0;

  fread(data, 4, 256*256, tiedosto);

  fclose(tiedosto);

  // Lataa data tekstuuriin. Huomaa, että tässä on nyt alpha mukana!

  glTexImage2D(GL_TEXTURE_2D, 0, 4, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);

  // Suodatus päälle

  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);



  // Vapauta väliaikainen data

  free(data);



  // Teksturointi päälle

  glEnable(GL_TEXTURE_2D);



  // Viestinkäsittelysilmukka

  alkuaika=GetTickCount();

  MSG msg;

  while(1)

  {

    if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))

    {

      if (msg.message==WM_QUIT) break;

      TranslateMessage(&msg);

      DispatchMessage(&msg);

    }

    else

    {

      // Käytämme GetTickCount()-funktiota, joka palauttaa ajan millisekunneissa,

      // laskemaan kuvan piirtämiseen kuluneen ajan.

      // Näin voimme ajastaa alienin pyörimään samalla nopeudella kaikilla kokeilla.

      aika=GetTickCount();

      piirtoaika=aika-alkuaika;



      if (piirtoaika>0)

      {

        alkuaika=aika;



        // Kasvata pyörityskulmaa hieman seuraavaa framea varten.

        // Alien pyörii nyt 0.06 astetta millisekunnissa

        // eli 1 kierroksen 6 sekunnissa

        angle+=0.06*piirtoaika;



        // Tyhjennä puskuri

       glClear(GL_COLOR_BUFFER_BIT);



        // Piirretään ensin tausta

        // Luo 2D koordinaatisto

        glMatrixMode(GL_PROJECTION);

        glLoadIdentity();

        gluOrtho2D(0, 800, 0, 600);



        // Aseta modelview-matriisi

        glMatrixMode(GL_MODELVIEW);

        glLoadIdentity();



        // Aseta tekstuurimatriisi niin, että taustaan saadaan hieman liikettä.

        glMatrixMode(GL_TEXTURE);

        glLoadIdentity();

        glTranslatef(sin(0.01*angle), cos(0.01*angle), 0);



        // Ota alpha test pois päältä sitä ei tarvita taustassa

        glDisable(GL_ALPHA_TEST);



        // Sido taustatekstuuri

        glBindTexture(GL_TEXTURE_2D, taustaTekstuuri);



        // Piirrä koko ikkunan peittävä nelikulmio

        glBegin(GL_QUADS);

        glTexCoord2f(0, 0);

        glVertex2f(0, 0);

        glTexCoord2f(6, 0);

        glVertex2f(800, 0);

        glTexCoord2f(6, 4);

        glVertex2f(800, 600);

        glTexCoord2f(0, 4);

        glVertex2f(0, 600);

        glEnd();



        // piirretään sitten alieni



        // Aseta 3D-koordinaatisto

        glMatrixMode(GL_PROJECTION);

        glLoadIdentity();

        gluPerspective(60, 800.0/600.0, 1, 10);



        // Aseta modelview-matriisi

        glMatrixMode(GL_MODELVIEW);

        glLoadIdentity();

        glTranslatef(0, 0, -2);     // Siirrä alienia hieman kauemmaksi kamerasta

        glRotatef(angle, 0, 1, 0);    // Pyöritä alienia y-akselin ympäri



        // Aseta tekstuurimatriisi

        glMatrixMode(GL_TEXTURE);

        glLoadIdentity();



        // laita alpha test päälle

        glEnable(GL_ALPHA_TEST);



        // aseta alpha test niin että vain pikselit,

        // joiden alpha arvo on yli 0.5 piirretään

        glAlphaFunc(GL_GREATER, 0.5);



        // Sido alien tekstuuri

        glBindTexture(GL_TEXTURE_2D, alienTekstuuri);



        // Piirrä alien

        glBegin(GL_QUADS);

        glTexCoord2f(0, 0);

        glVertex3f(-1, 1, 0);

        glTexCoord2f(1, 0);

        glVertex3f( 1, 1, 0);

        glTexCoord2f(1, 1);

        glVertex3f( 1,  -1, 0);

        glTexCoord2f(0, 1);

        glVertex3f(-1,  -1, 0);

        glEnd();



        // Vaihda puskuri näytölle.

        SwapBuffers(hdc);

      }

    }

  }



  return 0;

}

10. Loppusanat

Tässä artikkelissa opit teksturoimaan. Seuraavassa ja viimeisessä osassa puhumme valoista ja varjoista. Raportoithan kaikki tästä artikkelista löytämäsi virheet (niin kirjoitus-, kuin asiavirheetkin) osoitteeseen markus.ilmola@pp.inet.fi , niin korjaan ne mahdollisimman nopeasti. Myös kaikki kommentit ja kysymykset ovat tervetulleita.

Liite 1: DEVIL – kuvatiedostojen pikkupaholainen

Esimerkkiohjelmassa käyttämäni kuvat olivat ns. raakadatakuvia, koska data on niissä sellaisessa muodossa, että se kelpaa suoraan OpenGL:lle, eikä niiden lataus siis vaadi mitään ylimääräisiä toimenpiteitä. Raakadatakuvien käyttö ei kuitenkaan ole suositeltavaa, koska ne eivät sisällä mitään tietoa kuvan tyypistä, koosta jne. Lisäksi raakadatakuvien tallentaminen kuvankäsittelyohjelmilla on ongelmallista. Onkin suositeltavaa käyttää jotain oikeaa kuvaformaattia kuten jpg tai png.

Oikeissa kuvaformaateissa on kuitenkin se vika, että niissä oleva data EI kelpaa sellaisenaan OpenGL:lle. Kuvadata voi olla esim. pakattu tilan säästämiseksi, sen seassa voi olla jotain ylimääräistä metatietoa tai se on vain yksinkertaisesti ”väärässä” järjestyksessä. Jotta kuva voidaan ladata, pitäisi olla tarkka tieto sen rakenteesta. Ensin mahdollinen pakkaus pitäisi purkaa, ylimääräiset tiedot poistaa ja järjestää data sopivaan järjestykseen. Vasta tämän jälkeen datan voi antaa OpenGL:lle.

Kuvatiedostojen speksit ovat yleensä julkisia ja ne löytyvät netistä, mutta koska kuvaformaatteja on tuhottoman paljon, ja eri formaatit sopivat eri tilanteisiin, olisi liian iso urakka kirjoittaa latausfunktiota niille kaikille. On kuitenkin olemassa ilmaisia apukirjastoja, jotka osaavat ladata valtavan määrän erilaisia kuvaformaatteja. Yksi niistä on nimeltään DEVIL. Se on siinä mielessä hyvä aisapari OpenGL:lle, että sen käyttöliittymä on apinoitu suoraan OpenGL:stä.

DEVIL-kirjaston voi ladata osoitteesta: http://openil.sourceforge.net/. Imuroi uusin versio ja kopioi ”.lib”-tiedostot kääntäjäsi ”lib”-hakemistoon ja ”.h”-tiedostot kääntäjäsi ”include/il”-hakemistoon. ”.dll”-tiedostot tulevat samaan hakemistoon projektisi kanssa. Paketti sisältää itseasiassa 3 eri dll-tiedostoa, mutta tavallisesti tarvitset vain tiedoston ”devil.dll”. Jotta voisit käyttää DEVIL:iä, sinun pitää sisällyttää projektiisi otsikkotiedosto il.h. Tämä tehdään seuraavasti:

#include <il\il.h>

Lisäksi ohjelma pitää linkittää tiedoston devil.lib kanssa.

Ensimmäinen toimenpide DEVIL:iä käytettäessä on alustus. Tämä tehdään yhdellä funktiokutsulla.

ilInit();

Siinä kaikki. Alustus pitää tehdä ennen kuin yhtään DEVIL:in funktiota saa kutsua.

Nyt pääsemmekin itse asiaan. Kuten tulet huomaamaan DEVIL:in käyttö on lähes identtistä OpenGL:n tekstuurin latauksen kanssa.

Ensiksi pitää luoda kuvaobjekti. Se tehdään funktiolla:

ILvoid ilGenImages( ILsizei Num,  ILuint *Images );

”Num” kertoo kuinka monta kuvaa luodaan ja ”Images” on osoitin taulukoon, jonne kuvien tunnukset tallennetaan. Kun kuva on luotu, se pitää sitoa nykyiseksi kuvaksi. Kaikki kuvaan vaikuttavat funktiot operoivat sille kuvalle, joka on sillä hetkellä sidottuna nykyisenä kuvana. Kuvan sitominen tehdään funktiolla:

ILvoid ilBindImage(ILuint Image);

”Image” on siis sidottavan kuvan tunnus. Nykyiseen kuvaan voidaan ladata dataa kuvatiedostosta funktiolla:

ILboolean ilLoadImage(char *FileName);

Vain yksi parametri, eli ladattavan tiedoston nimi. DEVIL tunnistaa tiedoston tyypin automaattisesti ja osaa ladata seuraavan tyyppisiä kuvia: bmp, cut, dcx, dds, ico, gif, jpg, lbm. Lif, mdl, pcd, pcx, pic, png, pnm, psd, psp, raw, sgi, tga, tif, wal, act, pal ja hdr.
Funktio palauttaa nollan, jos lataus epäonnistui, ja eri suuren kuin nolla, jos onnistui.

Kuvan latauksen jälkeen kuva on muistissa ja enää tarvitsee saada data ulos siitä OpenGL:n ymmärtämässä muodossa. Sitä ennen tarvitsee kuitenkin udella kuvan tiedot kuten koko jne. Tämä tehdään funktiolla:

ILint ilGetInteger( ILenum Mode );

”Mode” kertoo mikä tieto halutaan ja funktio palauttaa kyseisen tiedon. ”Mode”:lle on iso kasa mahdollisia arvoja, mutta tässä tärkeimmät.

IL_IMAGE_WIDTH – kuvan leveys pikseleinä.

IL_IMAGE_HEIGHT – kuvan korkeus pikseleinä.

IL_IMAGE_FORMAT – Kertoo missä muodossa kuvan data ladatussa tiedostossa oli. Mahdolliset arvot ovat: IL_COLOUR_INDEX, IL_RGB, IL_RGBA, IL_BGR, IL_BGRA ja IL_LUMINANCE. Tätä tarvitaan tutkimaan oliko ladatussa kuvassa alphakanava. Jos formaatti on IL_RGBA tai IL_BGRA kuvassa oli alphakanava, muuten ei.

Varsinainen data saadaan ulos funktiolla:

ILvoid ilCopyPixels(
  ILuint XOff,
  ILuint YOff,
  ILuint ZOff,
  ILuint Width,
  ILuint Height,
  ILuint Depth,
  ILenum Format,
  ILenum Type,
  ILvoid *Data
);

”Off” parametrit kertovat mistä kohdasta lähtien data kopioidaan. Koska yleensä halutaan koko kuva, ovat nämä nollia.

Width, Height ja Depth kertovat kopioitavan palan koon, jotka jälleen kopioitaessa koko kuva, ovat itse kuvan koko (joka saatiin ilGetInteger funktiolla). Depth parametrin pitää olla 1.

”Format” kertoo formaatin, jossa data halutaan ulos. Ei ole mitään merkitystä missä muodossa data ladatussa kuvassa oli, sillä sen saa ulos missä formaatissa haluaa. Jotta data kelpaa OpenGL:lle on sen oltava formaatissa IL_RGB tai IL_RGBA, jos alpha kanavakin halutaan mukaan.

”Data” on osoitin taulukkoon, johon kuvan data kopioidaan. ”Type” on tämän taulukon alkion tyyppi esim.: IL_UNSIGNED_BYTE tai IL_FLOAT .

Lopuksi, kun data on kopioitu talteen, pitää kuva tuhota pois turhia resursseja tuhlaamasta. Tämä tehdään funktiolla:

ILvoid ilDeleteImages( ILsizei Num, const ILuint *Images);

Seuraavassa esimerkissä teemme funktion, joka lataa kuvan ja tekee siitä tekstuurin. DEVIL pitää toki alustaa kutsulla ”ilInit()” ennen kuin tätä funktiota saa kutsua.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
GLuint lataaTekstuuri(char *fileName)

{

  unsigned char *data=NULL;

  GLuint tekstuuri=0;

  ILuint kuva=0;

  unsigned int korkeus=0, leveys=0, komponentteja=0;

  ILuint ilFormat;

  GLuint glFormat;



  // Lataa kuva

  ilGenImages(1, &kuva);

  ilBindImage(kuva);

  if (!ilLoadImage(fileName)) return 0;



  // Kysy kuvan tiedot

  leveys=ilGetInteger(IL_IMAGE_WIDTH);

  korkeus=ilGetInteger(IL_IMAGE_HEIGHT);



  // Onko alpha mukana?

  if (ilGetInteger(IL_IMAGE_FORMAT)==IL_RGBA ||

      ilGetInteger(IL_IMAGE_FORMAT)==IL_BGRA)

  {

    komponentteja=4;

    ilFormat=IL_RGBA;

    glFormat=GL_RGBA;

  }

  else

  {

    komponentteja=3;

    ilFormat=IL_RGB;

    glFormat=GL_RGB;

  }



  // Varaa muistia väliaikaiselle datalle

  data=(unsigned char *)malloc(leveys*korkeus*komponentteja*sizeof(unsigned char));

  if (!data) return 0;



  // Kopio data

  ilCopyPixels(0,0,0, leveys,korkeus,1, ilFormat, IL_UNSIGNED_BYTE, data);



  // Tuhoa kuva

  ilDeleteImages(1, &kuva);



  // luo yksi tekstuuriobjekti

  glGenTextures(1, &tekstuuri);



  // Sido äsken luotu tekstuuri teksturointiyksikköön

  glBindTexture(GL_TEXTURE_2D, tekstuuri);



  // Lataa data tekstuuriin

  glTexImage2D(GL_TEXTURE_2D, 0, komponentteja, leveys, korkeus, 0,

               glFormat, GL_UNSIGNED_BYTE, data);



  // Suodatus päälle

  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);



  // Vapauta väliaikainen data

  free(data);



  // Palauta luotu tekstuuri

  return tekstuuri;

}

1. 3-ulotteisen kappaleen esittäminen tietokoneella

Tapoja kuvata 3-ulotteinen kappale tietokoneella on monta, mutta se tapa, jota lähes kaikki pelit käyttävät, on aproksimoida eli arvioida kappaletta monitahokkaalla (englanniksi polyhedron). Monitahokas on 3-ulotteinen kappale, jota rajoittaa monikulmioista eli polygoneista koostuva suljettu pinta. Nämä polygonit ovat monitahokkaan tahoja. Tahkojen leikkausviivoja kutsutaan särmiksi ja särmien leikkauspisteitä kärjiksi eli vertekseiksi. Alla oleva kuva esittää monitahokasta, jossa verteksit on merkitty sinisellä, särmät punaisella ja polygonit harmaalla.

Monitahokkaat voidaan jakaa kahteen ryhmään: kuperiin ja koveriin. Monitahokas on kupera, jos mitkä tahansa kaksi sen vertekseistä voidaan yhdistää viivalla niin, että tämä viiva ei käy monitahokkaan ulkopuolella. Muussa tapauksessa monitahokas on kovera.

Monitahokkaan särmät ja verteksit muodostavat verkon, josta käytetään yleensä englanninkielistä termiä mesh. Jos monitahokkaasta piirretään pelkät särmät kutsutaan kuvaa rautalankamalliksi (englanniksi wire-frame).

Kun monitahokkaalla halutaan aproksimoida jotain kappaletta rakennetaan monitahokas, jonka pinta mukailee mahdollisimman tarkasti alkuperäisen kappaleen pintaa. Mitä enemmän polygoneja monitahokkaassa on, sitä tarkemmin se jäljittelee alkuperäistä kappaletta. Se ei voi kuitenkaan koskaan mallintaa kappaletta täydellisen tarkasti (ellei sitten alkuperäinen kappale ollut monitahokas itsekkin). Kuitenkin hyvin suurilla polygonimäärillä ihmissilmä ei enää huomaa eroa.

Monitahokkaan tallentaminen tietokoneen muistiin on helppoa. Meidän pitää vain tallentaa jokaisen verteksin koordinaatit, sekä tieto siitä mitkä verteksit aina muodostavat tahon. Tämä voidaan toteuttaa vaikka indeksoimalla verteksejä. Vaikka monitahokkaan tahot voivat olla mitä tahansa monikulmioita, voidaan mikä tahansa monikulmio muodostaa kolmioista. Tämän takia riittää, että voimme tallentaa ainoastaan kolmioita.

Esim. Kuutio, jonka keskipiste sijaitsee origossa ja ”säde” on yksi, voitaisiin tallentaa seuraavasti:

1
2
3
4
float vertex[8][3]={

{-1,-1,-1},{1,-1,-1},{-1,1,-1},{1,1,-1},

{-1,-1,1}, {1,-1, 1},{-1,1, 1},{1,1, 1}};

int index[6*4]={ 0,2,3,1,  4,5,7,6,  5,1,3,7,  4,6,2,0,  7,3,2,6,  4,0,1,5 };

Eli tallennetaan kuution jokaisen 8 verteksin sijainti, sekä indeksit, jotka ilmoittavat mitkä 4 verteksiä aina muodostavat tahon.

2. 3D-koordinaatisto

Tämän artikkelisarjan ensimmäisessä osassa loimme 2D-koordinaatiston gluOrtho2D()-funktiolla. 3D-grafiikan tapauksessa tarvitsemme 3D-koordinaatiston. Tälläinen koordinaatisto luodaan OpenGL:ssä funktiolla gluPerspeksive(), jonka prototyyppi näyttää tältä:

1
2
3
4
5
6
void gluPerspective(

    GLdouble fovy,

    GLdouble aspect,

    GLdouble zNear,

    GLdouble zFar

   );

Koordinaatisto on helpoin käsittää jos ajattelet, että jossain päin kyberavaruutta kelluu kamera. Origo sijaitsee tämän kameran linssin keskellä. X-akseli kulkee vaakatasossa ja sen arvot kasvavat oikealle mentäessä. Y-akseli kulkee pystysuuntaan ja sen arvot kasvavat ylöspäin mentäessä. <b>Kamera katsoo kohti negatiivista Z-akselia.</b> Kameralle on myös määritelty näkökentän leveys (englanniksi field of view eli FOV), joka määrää kuinka monen asteen levyisen kaistaleen kamera näkee. Näin ollen kameran kerralla näkemä alue muodostaa kartion. Koska kappaleita, jotka ovat hyvin kaukana kamerasta tai hyvin lähellä sitä, ei ole järkevää piirtää, rajoitetaan kameran katselukartiota vielä kahdella tasolla ns. lähi- ja kaukoleikkaustasolla. Kaikki kaukotason takana olevat kappaleet jätetään piirtämättä samoin kaikki lähitason edessä olevat. Näin ollen näkyväksi alueeksi jää enää katkaistu kartio eli frustum.

gluPerspective()-funktion fovy-parametri kertoo kameran näkökentän leveyden. Tämän arvon on oltava suurempi kuin 0 ja pienempi kuin 180. Suurilla arvoilla saadaan laajakulmanäkymä ja pienillä arvoilla putkinäkömäinen efekti. Vaikka ihmissilmän näkökentän leveys on lähes 180 astetta astetta (tarkan näön alue noin 30 astetta) peittää monitori vain pienen osan näkökentästä, joten realistinen arvo on noin 45-60 astetta. Near ja far-parametrit kertovat lähi- ja kaukotason etäisyydet kamerasta. Huomaa, että lähitäson etäisyys pitää olla suurempi kuin 0 ja kaukotason on aina oltava kauempana kuin lähitason. Lähitaso kannattaa pitää mahdollisimman kaukana kamerasta ja kaukotaso mahdollisimman lähellä kameraa, jotta näkyvä alue pysyy optimaalisen pienenä. Aspect-parametri kertoo kuvasuhteen. Sen on oltava viewportin_leveys/viewportin_korkeus tai muuten kuva vääristyy.

gluOrtho2D() ja gluPerspektive()-funktioista on olemassa hieman monipuolisemmat versiot glOrtho() ja glFrustum(), mutta en käsittele niitä tässä artikkelissa.

3. Renderöinti

OpenGL:ssä monitahokas piirretään yksinkertaisesti polygoni kerrallaan. Piirtäminen aloitetaan glBegin()-funktiolla, jolle annetaan parametriksi GL_TRIANGLES, jos halutaan piirtää kolmioita tai GL_QUADS, jos halutaan piirtää nelikulmioita. Tämän jälkeen annetaan verteksien sijainnit glVertex3f()-funktiolla. Jos glBegin()-funktion parametri oli GL_TRIANGLES, piirretään jokaisen kolmen annetun verteksin välille aina kolmio. Tai jos se oli GL_QUADS piirretään jokaisen neljän verteksin välille aina nelikulmio. Lopuksi kutsutaan glEnd()-funktioita. Jokaiselle verteksille voidaan myös määrätä väri kutsumalla glColor3f()-funktiota ennen jokaista glVertex3f()-funktion kutsua. Esim. kappaleessa 1 määritelty kuutio voitaisiin piirtää esimerkiksi seuraavalla tavalla:

1
2
3
4
5
6
7
glBegin(GL_QUADS);

int i;

for (i=0; i<6*4; i++)

{

  glVertex3f(vertex[index[i]][0], vertex[index[i]][1], vertex[index[i]][2]);

}

glEnd();

Eli kutsutaan glVertex3f()-funktiota neljä kertaa jokaista kuution kuutta tahoa kohti.

Kun polygonien määrä kasvaa suureksi käy glBegin()-,lEnd()-parin käyttäminen tehottomaksi, sillä jokaista kolmiota kohden tarvitaan aina kolme glVertex3f()-funktion kutsua. Esim. jos meillä olisi 10000 kolmekulmaista polygonia tarvittaisiin 30000 glVertex3f()-funktion kutsua. Ei hyvä! Tämän takia OpenGL:ssä on kolme muutakin tapaa piirtää polygoneja. Ne ovat ”display list”, ”vertex array” ja ”vertex buffer object”.

3.1 Display listit

Display list:in ideana on ”nauhoittaa” funktion kutsuja, jonka jälkeen kaikki nauhoitetut kutsut voidaan ”toistaa” yhdellä funktion kutsulla. Ensin display list pitää luoda glGenLists()-funktiolla. Funktio palauttaa luodun display list:n tunnuksen. Nauhoitus aloitetaan glNewList()-funktiolla, jolle annetaan parametrina glGenLists()-funktiolta saatu tunnus ja symboli GL_COMPILE. Tämän jälkeen voidaan kutsua vapaasti lähes mitä tahansa OpenGL:n funktioita ja ne nauhoittuvat. Kun display list on valmis kutsutaan glEndList()-funktioita. Myöhemmin nauhoitus voidaan toistaa kuinka monta kertaa tahansa glCallList()-funktiolla, jolle annetaan parametrina display list:in tunnus. Huomaa, että display list:in sisältöä ei voi muuttaa. Display list voidaan tuhota glDeleteList()-funktiolla. Esim. äsken piirretty kuutio voitaisiin nauhoittaa display list:iin seuraavasti:

1
2
3
4
5
6
7
8
9
10
11
int tunnus;

tunnus=glGenLists(1);

glNewList(tunnus, GL_COMPILE);

glBegin(GL_QUADS);

int i;

for (i=0; i<6*4; i++)

{

  glVertex3f(vertex[index[i]][0], vertex[index[i]][1], vertex[index[i]][2]);

}

glEnd();

glEndList();

Vastaavasti se voitaisiin tämän jälkeen piirtää koska tahansa kutsulla glCallList(tunnus);.

3.2 Vertex array

Vertex array:n ideana on antaa OpenGL:lle osoitin verteksidataan, jonka jälkeen kaikki polygonit voidaan piirtää yhdellä funktion kutsulla. Ennen kuin vertex array:ta voidaan käyttää pitää se laittaa päälle glEnableClientState()-funktiolla, jolle annetaan parametrina GL_VERTEX_ARRAY. Tämän jälkeen annetaan osoitin verteksidataan glVertexPointer()-funktiolla, jonka prototyyppi näyttää tältä:

1
2
3
4
5
6
void glVertexPointer(

    GLint size,

    GLenum type,

    GLsizei stride,

    const GLvoid *pointer

   );

Ensimmäinen parametri kertoo komponenttien määrän per verteksi (yleensä 3). Seuraava datan tyypin (yleensä GL_FLOAT). Kolmas verteksien etäisyyden toisistaan muistissa (yleensä sizeof(verteksi)). Ja viimeinen on osoitin verteksidataan. Kun osoitin on annettu voidaan varsinainen renderöinti tehdä yhdellä glDrawElements()-funktion kutsulla. Sen prototyyppi näyttää tältä:

1
2
3
4
5
6
void glDrawElements(

    GLenum mode,

    GLsizei count,

    GLenum type,

    const GLvoid *indices

   );

Ensimmäisellä parametrilla on sama merkitys kuin glBegin()-funktionkin parametrilla. Viimeinen on osoitin taulukkoon, joka indeksoi glVertexPointer()-funktiolla annettuja verteksejä. Toinen parametri kertoo alkioiden määrän tässä taulukossa. Toiseksi viimeinen kertoo tämän taulukon alkioden tyypin (yleensä GL_UNSIGNED_INT). Seuraava esimerkki piirtää kappaleessa yksi määritellyn kuution käyttäen vertex array:ta.

1
2
3
glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex);

glDrawElements(GL_QUADS, 6*4, GL_UNSIGNED_INT, index);

3.3 Vertex buffer object

Se viimeinen tapa on sitten vertex buffer object eli VBO. Se on muuten sama kuin vertex array, mutta siinä verteksidata siirretään keskusmuistista nopeampaan näytönohjaimen muistiin. Koska VBO:n edut tulevat esiin vasta valtavan suurilla polygonimäärillä ja tämä on vain OpenGL:n perusteet-artikkeli, en käsittele sitä.

4. Näkymättömien pintojen poisto

Koska monitahokkaat ovat määritelmän mukaan suljettuja, emme voi koskaan nähdä tahojen takapuolia, ainoastaan niiden etupuolet. Tämän takia olisi tehokkuuden kannalta järkevää, jos polygoni jätettäisiin piirtämättä silloin kun sen takapuoli on kameraan päin. Nyt ilmestyykin ongelma. Mistä oikein tietää kumpi polygonin puolista on sen takapuoli ja kumpi etupuoli? Eivätkös ne ole ihan samanlaisia kummatkin? OpenGL:ssä polygonin etupuoli määritellään niin, että jos numeroimme sen verteksit järjestyksessä, on etupuoli se, jolta katsottuna verteksien numerot kasvavat vastapäivään.

Näkymättömien pintojen poisto kytketään päälle glEnable()-functiolla, jolle annetaan parametrina GL_CULL_FACE. Vastaavasti sen saa pois päältä glDisable()-funktiolla samalla parametrilla. Voit myös halutessasi päättää jätetäänkö piirtämättä taka-, vai etupuolet. Tämä tehdään glCullFace()-funktiolla, jolle annetaan parametrina, joko GL_FRONT tai GL_BACK. Oletusarvo on GL_BACK. Sinun ei tietenkään tarvitse itse numeroida verteksejä, vaan OpenGL numeroi ne siinä järjestyksessä, kun se saa ne esim. glVertex3f()-funktiolta.

5. Päällekkäisyysongelma

Aina kun piirrät OpenGL:ssä jotain, se peittää alleen kaiken ennen sitä piirretyn. Tästä seuraa se, että jos monitahokkaan takenpana olevat polygonit piirretään etummaisten jälkeen, peittävät ne etummaiset alleen ja saatu kuva on näin ollen virheellinen. Jos näkymättömien pintojen poisto laitetaan päälle, ei tätä ongelmaa esiinny, jos monitahokas on kupera, sillä siinä mitkään kaksi kameraan päin olevaa polygonia ei peitä toisiaan. Sen sijaan koveran monitahokkaan tapauksessa ei pelkkä näkymättömien pintojen poisto auta, vaan tarvitaan avuksi jotain toista algoritmia. Kaksi kuuluisinta ovat: maalarin algoritmi ja syvyyspuskurialgoritmi.

5.1 Maalarin algoritmi.

Maalarin algoritmin idea on yksinkertainen. Polygonit lajitellaan ja piirretään tämän jälkeen järjestyksessä takimmaisesta etummaiseen, samoin kuin maalari tekee maalatessaan taulua. On kuitenkin muutama tapaus, joissa maalarin algoritmi ei toimi, eli kuva on aina virheellinen riippumatta siitä missä järjestyksessä polygonit piirretään. Alla pari esimerkkiä.

Tämän takia maalarin algoritmia ei kannatakkaan käyttää kuin joissakin erikoistapauksissa.

5.2 Syvyyspuskurialgoritmi

Syvyyspuskurialgoritmin ideana on tallentaa pikselin värin lisäksi myös sen etäisyys kamerasta. Tämä syvyysarvo tallennetaan ns. syvyyspuskuriin eli Z-puskuriin. Aina ennen pikselin piirtoa lasketaan sen syvyysarvo. Tarkistetaan puskurista, onko kyseisellä paikalla olevan pikselin syvyysarvo jo pienempi kuin uuden pikselin syvyys. Jos on, niin pikseli jätetään piirtämättä. Jos taas ei, niin pikseli piirretään ja syvyyspuskuriin päivitetään uusi arvo.

OpenGL:ssä on syvyyspuskuri sisäänrakennettuna. Se tarvitsee vain kytkeä päälle glEnable()-funktiolla, jolle annetaan parametrina GL_DEPTH_TEST. Syvyyspuskuri on tietenkin tyhjennettävä ennen piirtämistä. Tämä tehdään glClear()-funktiolla, jolle annetaan parametrina GL_DEPTH_BUFFER_BIT.

6. Matriisit

Voidaksesi käyttää OpenGL:ää sinun ei tarvitse ymmärtää matriisien syvintä olemusta. Riittää, että tiedät niiden perusperiaatteen. Matriisi on taulukko (OpenGL:n tapauksessa 4×4 taulukko), jonka jokaisessa solussa on jokin mielivaltainen luku. Matriisilla voidaan kertoa vektori, jolloin vektori muuntuu toiseksi vektoriksi. Millaiseksi, se riippuu siitä, mitä lukuja matriisi sisälsi. Valitsemalla matriisin alkiot sopivasti saadaan vektori vaikka pyörimään jonkin akselin ympäri jonkin kulman verran.

Jos matriisin alkiot valitaan niin, että vinorivillä on ykkösiä ja kaikkialla muualla nollia, saadaan ns. yksikkömatriisi (englanniksi identity matrix), jolla kertomalla vektori ei muutu miksikään.

Myös matriiseja voidaan kertoa keskenään, jolloin matriisien ominaisuudet yhdistyvät. Esim. jos meillä on matriisi, joka pyörittää 30 astetta Z-akselin ympäri ja matriisi, joka pyörittää 50 astetta Z-akselin ympäri saadaan niiden tulona matriisi, joka pyörittää 80 astetta Z-akselin ympäri. Jos haluat tarkempia tietoja matriiseista lue artikkeli: Matriisimatematiikkaa peliohjelmoijille.

OpenGL:ssä on sisäänrakennettuna useitakin matriiseja. Tässä artikkelissa olemme kiinnostuneita modelview-matriisista ja projektiomatriisista. Aina kun annat OpenGL:lle verteksin glVertex-sarjan funktiolla kerrotaan kyseinen verteksi ensin modelview-matriisilla ja sitten projektiomatriisilla. Kummatkin nämä matriisit ovat oletuksena yksikkömatriiseja eli verteksi ei muutu miksikään.

OpenGL sisältää kasan funktioita, joilla sen sisäisiä matriiseja voidaan muokata. Ennen kuin voimme käyttää niitä meidän on kuitenkin päätettävä mitä matriisia haluamme muokata. Tämä tehdään glMatrixMode()-funktiolla, joka saa parametrikseen, joko GL_MODELVIEW tai GL_PROJECTION riippuen siitä kumpaa matriiseista haluamme muokata. Myös muita vaihtoehtoja on, mutta emme käsittele niitä tässä artikkelissa.

Seuraavassa tärkeimmät matriiseja muokkaavista funktioista:

glLoadIdentity() – korvaa nykyisen matriisin yksikkömatriisilla.

glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) – kertoo nykyisen matriisin matriisilla, joka pyörittää vektoria angle astetta akselin x, y, z ympäri.

glTranslatef(GLfloat x, GLfloat y, GLfloat z ) – siirtää vektoria parametrien x, y ja z verran.

Seuraava esimerkki siirtää ensin -5 yksikköä z-akselin suuntaan ja pyörittää sitten 60 astetta x-akselin ympäri.

1
2
3
glLoadIdentity();

glTranslatef(0, 0, -5);

glRotatef(60, 1, 0, 0);

Eli jos nyt annat OpenGL:lle yhdenkin verteksin, siirretetään sitä ensin 5 yksikköä negatiivisen z-akselin suuntaan ja pyöritetään sitten 60 astetta x-akselin ympäri ennen piirtämistä.

Myös koordinaatistot tallennetaan matriisiin. Niille on varattu varta vasten projektiomatriisi. gluOrtho2D() ja gluPerspektive() ovatkin itse asiassa matriiseja muokkaavia funktioita, jotka kertovat nykyisen matriisin luomallaan koordinaatistomatriisilla. Tämän takia projektiomatriisi on ensin valittava glMatrixMode()-funktiolla ennen kummankaan kutsua.

Nykyinen matriisi voidaan halutessa tallentaa varastoon pinoon kutsulla glPushMatrix();. Pinon päällimmäinen matriisi taas voidaan ladata takaisin kutsulla glPopMatrix();. Pinoon mahtuu maksimissaan 32 modelview-matriisia ja 2-projektiomatriisia (kummallakin on oma pino).

7 Esimerkkiohjelma

Seuraava ohjelma avaa ikkunan ja piirtää siihen pyörivän värikkään kuution. Koska se kuinka monta kertaa sekunnissa tietokone piirtää kuvan riippuu sen tehosta, pyörisi kuutio eri nopeudella eri kokeilla. Tämän takia käytämme GetTickCount()-funktiota, joka palauttaa ajan millisekunteina, mittaamaan kuvan piirtämiseen kuluvan ajan. Näin voimme ajastaa pyörimisnopeuden samaksi kaikilla koneilla. Voit imuroida oheisen lähdekoodin ja valmiiksi käännetyn version tästä: testi2.zip .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
#include <windows.h>

#include <gl\gl.h>

#include <gl\glu.h>

//#include <gl\glext.h>  // Ei tarvita tässä ohjelmassa



// Määrittele laitekonteksti globaaliksi sitä nimittäin tarvitaan myös pääfunktiossa.

HDC hdc;



// Viestinkäsittelijä

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

  switch (uMsg)

  {

    // Koska piirrämme ikkunan sisällön pääsilmukassa jatkuvasti uudelleen

    // reagoimme WM_PAINT-viestiin vain tyhjentämällä ikkunan mustaksi.

    case WM_PAINT:

    {

      PAINTSTRUCT p;

      BeginPaint(hwnd, &p);

      glClear(GL_COLOR_BUFFER_BIT);

      SwapBuffers(hdc);

      EndPaint(hwnd, &p);

      return 0;

    }



    // Ikkuna yritetään sulkea kutsu PostQuitMessage()-funktiota.

    case WM_CLOSE:

    {

      PostQuitMessage(0);

      return 0;

    }



    // Käsittele myös WM_SIZE se lähetetään ikkunalle aina kun sen kokoa muutetaan.

    // Tämä on oiva tilaisuus muuttaa viewport

    // oikean kokoiseksi peittämään koko ikkuna.

    case WM_SIZE:

    {

      // Ikkunan uusi koko saadaan lParam parametrista LOWORD ja HIWORD makroilla.

      glViewport(0, 0, LOWORD(lParam), HIWORD(lParam));

      return 0;

    }

  }



  // Viestiä ei käsitelty kutsu DefWindowProc()-funktiota.

  return DefWindowProc(hwnd, uMsg, wParam, lParam);

}



int luoIkkuna(unsigned int leveys, unsigned int korkeus,

              char *otsikko)

{

  // Rekisteröi ikkunaluokka

  WNDCLASS wc;

  memset(&wc, 0, sizeof(WNDCLASS));

  wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

  wc.hCursor= LoadCursor(NULL, IDC_ARROW);

  wc.lpfnWndProc = (WNDPROC) WindowProc;

  wc.hInstance = GetModuleHandle(NULL);

  wc.lpszClassName = "OpenGLtutoriaali";

  if (!RegisterClass(&wc)) return 0;



  // Luo ikkuna

  RECT r;

  r.left=GetSystemMetrics(SM_CXSCREEN)/2-leveys/2;

  r.top=GetSystemMetrics(SM_CYSCREEN)/2-korkeus/2;

  r.right=r.left+leveys;

  r.bottom=r.top+korkeus;

  AdjustWindowRectEx(&r,

    WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW,

    FALSE,  WS_EX_APPWINDOW);

  HWND hwnd;

  hwnd=CreateWindowEx(WS_EX_APPWINDOW,

    "OpenGLtutoriaali", otsikko,

    WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW,

    r.left, r.top, r.right-r.left, r.bottom-r.top,

    NULL, NULL, GetModuleHandle(NULL), NULL);



  // Luo laitekonteksti

  hdc=GetDC(hwnd);

  if (!hdc) return 0;



  // Valitse pikseliformaatti

  PIXELFORMATDESCRIPTOR pfd;

  memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));

  pfd.nSize=sizeof(PIXELFORMATDESCRIPTOR);

  pfd.nVersion=1;

  pfd.dwFlags=PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER;

  pfd.iPixelType=PFD_TYPE_RGBA;

  pfd.cRedBits=8;

  pfd.cGreenBits=8;

  pfd.cBlueBits=8;

  pfd.cAlphaBits=8;

  pfd.cStencilBits=8;

  pfd.cDepthBits=16;

  pfd.iLayerType=PFD_MAIN_PLANE;

  int pixelFormat;

  pixelFormat=ChoosePixelFormat(hdc, &pfd);

  if (!pixelFormat) return 0;

  if (!SetPixelFormat(hdc, pixelFormat, &pfd)) return 0;



  // Luo renderöintikonteksti

  HGLRC hrc;

  hrc=wglCreateContext(hdc);

  if (!hrc) return 0;

  if (!wglMakeCurrent(hdc, hrc)) return 0;



  // Tuo ikkuna näkyviin

  ShowWindow(hwnd, SW_SHOW);

  SetForegroundWindow(hwnd);

  SetFocus(hwnd);



  // Palauta onnistuminen

  return 1;

}



// Pääfunktio

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,

                   LPSTR lpCmdLine, int nCmdShow)

{

  // Data piirrettävää kuutiota varten

  float vertex[8][3]={{-1,-1,-1},{1,-1,-1},{-1,1,-1},{1,1,-1},

                      {-1,-1,1}, {1,-1, 1},{-1,1, 1},{1,1, 1}};

  float color[8][3]={{0,0,0},{1,0,0},{0,1,0},{1,1,0},

                      {0,0,1}, {1,0, 1},{0,1, 1},{1,1, 1}};

  int index[6*4]={ 0,2,3,1,  4,5,7,6,  5,1,3,7,  4,6,2,0,  7,3,2,6,  4,0,1,5 };

  float angle=0;



  unsigned int aika;

  unsigned int piirtoaika;

  unsigned int alkuaika;



  // Luo ikkuna

  if (!luoIkkuna(800, 600, "OpenGL:n perusteet - Osa 2: 3D grafiikka")) return 0;



  // Määrittele viewport koko ikkunan kokoiseksi

  glViewport(0, 0, 800, 600);



  // Koska koordinaatisto on itseasiassa matriisi täytyy meidän ottaa

  // projektiomatriisi käsiteltäväksi ennen gluPerspective-kutsua.

  glMatrixMode(GL_PROJECTION);

  gluPerspective(60, 800.0/600.0, 1, 100);



  // Kaikki matriisia muuttavat käskyt vaikuttavat tämän jälkeen modelview-matriisiin

  glMatrixMode(GL_MODELVIEW);



  // Laita näkymättömien pintojen poisto ja sysyyspuskurialgoritmi päälle.

  glEnable(GL_CULL_FACE);

  glEnable(GL_DEPTH_TEST);



  // Viestinkäsittelysilmukka

  alkuaika=GetTickCount();

  MSG msg;

  while(1)

  {

    if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))

    {

      if (msg.message==WM_QUIT) break;

      TranslateMessage(&msg);

      DispatchMessage(&msg);

    }

    else

    {

      // Käytämme GetTickCount()-funktiota, joka palauttaa ajan millisekunneissa,

      // laskemaan kuvan piirtämiseen kuluneen ajan.

      // Näin voimme ajastaa kuution pyörimään samalla nopeudella kaikilla kokeilla.

      aika=GetTickCount();

      piirtoaika=aika-alkuaika;



      if (piirtoaika>0)

      {

        alkuaika=aika;



        // Kasvata pyörityskulmaa hieman

        // Kuutio pyörii nyt 0.06 astetta millisekunnissa

        // eli 1 kierroksen 6 sekunnissa

        angle+=0.06*piirtoaika;



        // Tyhjennä väripuskuri ja syvyyspuskuri

        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);



        // Aseta modelview-matriisi

        glLoadIdentity();           // "Resetoi" matriisi yksikkömatriisiksi

        glTranslatef(0, 0, -5);     // Siirrä kuutiota hieman kauemmaksi kamerasta

        glRotatef(angle, 1, 0, 0);  // Pyöritä kuutiota hieman joka akselin ympäri

        glRotatef(angle, 0, 1, 0);

        glRotatef(angle, 0, 0, 1);



        // Piirrä kuutio

        glBegin(GL_QUADS);

        int i;

        for (i=0; i<6*4; i++)

        {

          glColor3f(color[index[i]][0], color[index[i]][1], color[index[i]][2]);

          glVertex3f(vertex[index[i]][0], vertex[index[i]][1], vertex[index[i]][2]);

        }

        glEnd();



        // Toinen tapa piirtää kuutio vertex array:lla.

        /*

        glEnableClientState(GL_VERTEX_ARRAY);

        glEnableClientState(GL_COLOR_ARRAY);

        glVertexPointer(3, GL_FLOAT, sizeof(float[3]), vertex);

        glColorPointer(3, GL_FLOAT, sizeof(float[3]), color);

        glDrawElements(GL_QUADS, 4*6, GL_UNSIGNED_INT, index);

        */



        // Vaihda puskuri näytölle.

        SwapBuffers(hdc);

      }

    }

  }



  return 0;

}

8 Loppusanat

Tässä artikkelissa opit piirtämään kolmeulotteisia kappaleita OpenGL:llä. Seuraavassa osassa puhumme tekstuureista. Raportoithan kaikki tästä artikkelista löytämäsi virheet (niin kirjoitus-, kuin asiavirheetkin) osoitteeseen markus.ilmola@pp.inet.fi , niin korjaan ne mahdollisimman nopeasti. Myös kaikki kommentit ja kysymykset ovat tervetulleita.

1. Johdanto

Ennen vanhaan grafiikkaa piirrettiin kirjoittamalla se suoraan näytönohjaimen muistiin. Kun tiettyyn osoitteeseen näytönohjaimen muistissa kirjoitettiin tavu, syttyi vastaavaan kohtaan näyttöä vastaavan värinen pikseli. Ja kun yksi pikseli kerran osattiin piirtää, niin monesta pikselistähän sai aikaan mitä tahansa kuvia. Kaikki kuitenkin muuttui 3D-kiihdytinten myötä. Enää grafiikkaa ei piirrettykään tietokoneen prosessorin avulla, vaan näytönohjaimen prosessorin avulla, joka on varta vasten suunniteltu grafiikan piirtämiseen ja suoriutuu tehtävästä näin ollen jopa 300 kertaa nopeammin vastaavan kellotaajuiseen keskussuorittimeen verrattuna.

Ongelmaksi muodostuu kuitenkin se, että jokainen näytönohjain on erilainen ja eri grafiikkakoodin kirjoittaminen kaikille mahdollisille näytönohjaimille olisi mahdotonta. Tämän takia asia hoidetaan niin sanottujen rajapintojen kautta. Eli näytönohjaimesi ajurit tarjoavat sinulle standardoituja funktioita, jotka toimivat samoin kaikilla näytönohjaimilla. Toinen ilmiselvä hyöty on, että ohjelmoijan ei itse tarvitse kasata kuviota yksittäisistä pikseleistä vaan yksinkertaisten primitiivien (kuten viivojen ja kolmioiden) piirtoon on valmiit funktiot.

3D-korttien alkuaikoina tällaisia rajapintoja oli kolme: Glide, Direct3D ja OpenGL. Glide:ä ylläpitäneen 3Dfx:n hävittyä myös Glide kuoli pois. Niinpä nykyään on olemassa kaksi rajapintaa: Microsoftin DirectX-paketin osana oleva Direct3D ja SGI:n alun perin kehittämä, nykyään ARB:n (suurimpien näytönohjainvalmistajien yhteenliittymä) ylläpitämä OpenGL. Molemmat ovat yhtä nopeita ja molemmilla voi tehdä samat asiat. Ainut ero on, että siinä missä Direct3D toimii vain Windows-käyttöjärjestelmässä (ja sen 8-version muunnos Xbox-pelikonsolissa), OpenGL toimii käytännössä kaikissa käyttöjärjestelmissä ja jopa kämmenmikroissa ja matkapuhelimissa (OpenGL ES). Tämä artikkeli käsittelee OpenGL-rajapintaa, jonka aloituskynnys on Direct3D:tä hieman pienempikin. Käytämme tässä artikkelisarjassa Windows-käyttöjärjestelmää, mutta ikkunan luontia lukuunottamatta OpenGL:n käyttö on kaikilla käyttöjärjestelmillä samanlaista.

OpenGL:n virallisen speksin voit imuroida täältä: http://www.opengl.org/documentation/spec…
OpenGL:n opetteleminen spesifikaatiota tutkimalla on kuitenkin vaivalloista, joten aloittakaamme tutoriaali.

2. Tarvittavat kirjastot

OpenGL:n otsikkotiedostot tulevat kaikkien yleisimpien kääntäjien mukana. Ne ovat nimeltään opengl.h ja glu.h . Lisäksi, koska tässä artikkelissa teemme Windows-ohjelmia, pitää mukaan liittää windows.h. Ohjelma pitää myös linkittää kirjastojen opengl32.lib ja glu32.lib kanssa. Katso kääntäjäsi ohjeista kuinka tämä tehdään. Esim. Dev-Cpp:lla tämä tehdään kirjoittamalla projektin asetuksista löytyvään linker-kenttään “-lopengl32 -lglu32″. Myöhemmin tulet tarvitsemaan vielä tiedostoa glext.h . Kyseinen tiedosto päivittyy vähän väliä, joten imuroi itsellesi uusin versio osoitteesta: http://oss.sgi.com/projects/ogl-sample/A…

OpenGL:ää käyttävän C/C++-kielisen tiedoston alku näyttäisi siis tyypillisesti tältä:

1
2
3
4
#include <windows.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glext.h>

3. Ikkunan luominen

Ennen kuin voit piirtää yhtään mitään on sinun luotava ikkuna. Ikkunalla ei varsinaisesti ole mitään tekemistä OpenGL:n kanssa. Se on vain välttämätön paha, joka on tehtävä ennen kuin pääsemme asiaan. Vaikka OpenGL onkin käyttöjärjestelmäriippumaton on ikkunan luominen jokaisella käyttöjärjestelmällä aina erilainen prosessi. Tämä artikkeli käsittelee Windows-ohjelmointia, joten näytän kuinka ikkuna luodaan Windowssissa. Ikkunan luonnissa on periaatteessa 3 eri vaihetta:

1. Rekisteröi ikkunaluokka
2. Luo ikkuna
3. Luo ikkunaan renderöintikonteksti

Ensimmäinen vaihe on helppo. Täytetään WNDCLASS-tyyppinen rakenne ja rekisteröidään se RegisterClass()-funktiolla. Kummatkin on määritelty windows.h:ssa. Sinun ei siis itse tarvitse toteuttaa kumpaakaan!

WNDCLASS-rakenteen määrittely näyttää tältä:

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef struct _WNDCLASS

{

  UINT style;

  WNDPROC lpfnWndProc;

  int cbClsExtra;

  int cbWndExtra;

  HANDLE hInstance;

  HICON hIcon;

  HCURSOR hCursor;

  HBRUSH hbrBackground;

  LPCTSTR lpszMenuName;

  LPCTSTR lpszClassName;

} WNDCLASS;

ja RegisterClass()-funktion prototyyppi tältä:

1
2
3
ATOM RegisterClass(

CONST WNDCLASS *lpWndClass // address of structure with class data

);

Luodaan nyt yksi WNDCLASS-rakenne, täytetään se asianmukaisesti ja rekisteröidään se.

1
2
3
4
5
6
7
8
WNDCLASS wc;

memset(&wc, 0, sizeof(WNDCLASS));

wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

wc.hCursor= LoadCursor(NULL, IDC_ARROW);

wc.lpfnWndProc = (WNDPROC) WindowProc;

wc.hInstance = GetModuleHandle(NULL);

wc.lpszClassName = "OpenGLtutoriaali";

if (!RegisterClass(&wc)) return 0;