Suomipelit – OpenGL:n perusteet - Osa 3: Teksturointi

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.

void glTexCoord2f(GLfloat s, GLfloat t);

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

void glBindTexture(GLenum target, GLuint texture);

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

glDeleteTextures(GLsizei n,	 const GLuint * textures);

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

Mahdollisuus laittaa GL_CLAMP-bugi päälle GeForce4-kortin ajureissa.

Vasemmalla ilman suodatusta ja oikealla sen kanssa.

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

Vasemmalla ilman mipmap:eja ja oikealla niiden kanssa.

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ä.

void glAlphaFunc(GLenum func, GLclampf ref);	

glBlendFunc(GLenum sfactor, GLenum dfactor);

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

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

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

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

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

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

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 ( http://www.suomipelit.com/files/artikkel... ). Paketti sisältää myös oheisen lähdekoodin ja valmiiksi käännetyn version.

#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>

ilInit();

ILvoid ilGenImages( ILsizei Num,  ILuint *Images );

ILvoid ilBindImage(ILuint Image);

ILboolean ilLoadImage(char *FileName);

ILint ilGetInteger( ILenum Mode ); 

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

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

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