Suomipelit – DirectX 8 - Ensimmäinen kosketus

Kaikki vähänkin tietokoneita käyttäneet ovat varmasti tutustuneet Microsoftin DirectX ohjelmointirajapintaan vähintään pelien pelaamisen yhteydessä. Tämä artikkeli käy ensin lyhyesti läpi mistä DirectX:ssä on oikein kysymys, ja aloittaa DirectX -ohjelmointi artikkelisarjan Direct3D:n käynnistämisellä. Myöhemmät artikkelit kertovat kuinka muita DirectX:n sisältämiä osia käytetään. Lukijalta vaaditaan c/c++ perusosaaminen. Artikkelisarjan tarkoituksena on antaa lukijalleen DirectX:n käytön perusosaaminen, eikä se käsittele sivuviittauksia kummemmin eri alueiden optimointimenetelmiä. Näihin lukijat saavat tutustua omalla ajallaan, kun tuntevat olevansa valmiita siihen.
Koska kyseessä on opetustarkoitukseen tehty artikkeli, ei kaikki sen sisältämä koodi ole suoraan oikeaan ohjelmaan soveltuvaa ja muutenkin pääasiana on selkeys, ei tehokkuus. Artikkeli on pyritty jakamaan sopivan kokoisiin osioihin ja jokainen läpikäyty asia on pyritty selvittämään mahdollisimman selkokielisesti ilman aiheelle ominaisia monimutkaisia vieraskielestä johdettuja termejä. Artikkelin mukana tulee lähdekoodit esimerkkiohjelmaan, jota analysoiden asiat käydään lävitse. Lähdekoodi esimerkit on testattu Microsoft Visual C++ 6.0 ohjelmointiympäristössä.

Esimerkkien kääntymisen onnistuminen vaatii oikein asennettujen DirectX8.0 ohjelmointikirjastojen olemassaoloa, sekä d3d8.lib ja d3dx8.lib tiedostojen linkittämistä projektiin.

Koko artikkelin lähdekoodeineen voit imuroida tästä: http://www.suomipelit.com/artikkelit/art... .

Microsoftin DirectX on käytännössä ensimmäinen varteen otettava yritys helpottaa multimediaohjelmoijien, pääasiassa peliohjelmoijien, arkea Windows-ympäristössä. Kyseessä on ohjelmointirajapinta, jonka avulla useiden eri laitteiden käyttö on yksinkertaistettu yhden yhteisen liittymän alle. DirectX helpottaa äänikorttien, 2 ja 3 -ulotteisen grafiikan, näppäimistön, hiiren ja muiden peliohjainten käyttöä Microsoft Windows-ympäristöissä huomattavasti antaen samalla tuen usealle eri laitetyypille. Rajapinta on myös oikein käytettynä erittäin tehokas ja nopea. Ennen DirectX:n tulemista oli itse ohjelmien tekijöiden harteilla tukea eri laitteita, mikä rajoitti asiakaskuntaa sekä mahdollisten erikoistekniikoiden käyttöä.

DirectX:n rinnalla on myös kilpailevia ohjelmointirajapintoja, mutta nämä rajapinnat keskittyvät yleensä vain yhteen osa-alueeseen. Yleisemmin käytössä olevat näistä ovat OpenGL (2 ja 3-ulotteinen grafiikka), ja OpenAL (2 ja 3 -ulotteinen ääni), jotka ovat käyttöjärjestelmäriippumattomia, eli niitä voi käyttää (pienin muutoksin) Linuxista Windowsiin ilman ongelmia. Peliohjainten sekä multimedian (videokuva, musiikkitiedostot) käyttöjärjestelmäriippumatonta ohjelmointirajapintaa ei vielä ole vastaan tullut. Koska nämä rajapinnat ovat kuitenkin toisistaan erillisiä, ei niiden käyttö ole aina ruusuilla tanssimista vaikka varsinkin OpenAL on tehty erittäin läheisesti OpenGL:n kanssa käytettäväksi.

Myös DirectX:n käytössä on omat ongelmansa. Versiosta toiseen siirryttäessä rajapinta voi muuttua merkittävästi (esimerkkinä DirectX7.0 = > DirectX 8.0), ja ohjelmakoodi täytyy lähes aina uusia jotta uudet ominaisuudet saadaan käyttöön. Useimmille ohjelmoijille on myös Microsoftin käyttämä COM (Component Object Model) vähintäänkin järkyttävä kokemus vanhojen C-ohjelmointi päivien jälkeen. Kyseessä on kuitenkin asioita usein helpottava tapa hallita tiettyjä DirectX:n ohjelmakoodin osasia. Käytännössä ennen jokaisen COM-objektin käyttöä niiden rajapintaa \'pyydetään\' Windowsilta, Windows lisää COM-objektin viittausten määrää, ja useampi ohjelma voi käyttää siten samaa objektia yhtäaikaisesti. Kun ohjelma lopetetaan se vapauttaa pyytämänsä rajapinnat, jolloin niiden viittausten lukumäärää vähennetään. Kun viittauksia ei enää ole, COM-objektille varattu muisti vapautetaan. COM:ia ei kuitenkaan tarvitse käyttää kuin DirectX:n osioita luodessa, ellei halua itse tehdä omia COM-objektejaan (jossa yleensä onkin jo vaiva suurempi kuin saavutettu hyöty).

Direct3D käyttökuntoon #

Ennen DirectX:n versiota 8.0 tarkoitti Direct3D:n käyttökuntoon saaminen paria sivua koodia ja valmisteluja. Ja kun siihen lisäsi pelkän kolmion piirtämisen olikin koodia jo sen verran, että siihen määrään olisi mahtunut useammankin aloittelijan ensimmäinen peliprojekti. Tätä helpottamaan Microsoft teki D3DX-apukirjaston, joka nykyään käsittää muitakin helpotuksia. DirectX8.0:ssa Direct3D:n saa kuitenkin käyttöön helposti ja nopeasti myös ilman D3DX-kirjastoa, ja se prosessi neuvotaan seuraavaksi.

Laitteen luominen #

Ennen kuin varsinaiseen Direct3D asiaan päästään käsiksi, täytyy luoda ikkuna johon kaikki piirtäminen tapahtuu. Ikkunan luominen on kuvailtu tarkemmin edellisessä artikkelissa, joten siihen ei tässä tutustuta koodia tarkemmin. Sivulla oleva koodi pohjautuu edellisessä artikkelissa esiteltyyn ikkunointikoodiin.

Direct3D käyttää 3D-näytönohjainta, eli laitetta, kahden osoittimen kautta. LPDIRECT3D8 luo osoittimen Direct3D-rajapintaan, ja LPDIRECT3DDEVICE8 itse laitteeseen. Laitteen osoitin hankitaan Direct3D-rajapinnan kautta. Myöhemmin kaikki piirtäminen ruudulle tapahtuu laite-osoittimen avulla, eikä osoitinta Direct3D-rajapintaan juurikaan tarvita. Vaikka tämä voi kuulostaa monimutkaiselta, niin ei kuitenkaan ole. Seuraava koodi selventää mistä tässä kaikessa on oikein kyse.

// 
// Globaaleja muuttujia. 
// 
LPDIRECT3D8       g_pD3D;     // Globaali osoitin Direct3D-objektiin
LPDIRECT3DDEVICE8 g_pD3DLaite; // Globaali osoitin D3D-laitteeseen. 


//-------------------------------------------- 
// Nimi  : LuoD3D()  
// Kuvaus: Luo liittymän Direct3D-laitteeseen.  
//         Olettaa että g_hWnd sisältää 
//         kahvan ohjelman ikkunaan. 
//--------------------------------------------  
HRESULT LuoD3D( void )    
{ 
    HRESULT hr = S_OK; // palautusarvot 

    //  
    // Nollataan Direct3D:n käyttämät osoittimet. 
    //  
    g_pD3D      = NULL; 
    g_pD3DLaite = NULL; 


    // 
    // Luodaan Direct3D-objekti, joka toimii liittymänä
    // Direct3D-rajapintaan. 
    // 
    g_pD3D = Direct3DCreate8( D3D_SDK_VERSION );

    // 
    // Jos liittymää ei saatu on g_pD3D-osoitin nolla. 
    // 
    if( g_pD3D == NULL ) 
        return S_FAIL; 

    //
    // Hankitaan Direct3D-rajapinnalta tiedot nykyisestä 
    // näyttötilasta ja luodaan niiden avulla Direct3D- 
    // laite. 
    // 
    D3DDISPLAYMODE D3DDM;
    g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &D3DDM ); 
     
     
    //
    // Asetetaan laitteelle tiedot siitä kuinka kuva 
    // tulee piirtää ruudulle. 
    //
    D3DPRESENT_PARAMETERS D3DPP; 
    ZeroMemory( &D3DPP, sizeof( D3DPP ) ); // muistin nollaus 
     
    D3DPP.Windowed         = TRUE;
    D3DPP.SwapEffect       = D3DSWAPEFFECT_DISCARD; 
    D3DPP.BackBufferFormat = D3DDM.Format; 
    D3DPP.EnableAutoDepthStencil = TRUE;
    D3DPP.AutoDepthStencilFormat = D3DFMT_D16;
    
   
    // 
    // Luodaan Direct3D-laite yllä annettujen tietojen 
    // mukaan.
    //
    hr = g_pD3D->CreateDevice( D3DADAPTER_DEFAULT,  
                               D3DDEVTYPE_HAL, 
                               g_hWnd,
                               D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                               &D3DPP, 
                               &g_pD3DLaite ); 


    //
    // Palautetaan CreateDevice()-funktion palautusarvo. 
    // Se kertoo suoraan onnistuiko laitteen hankkiminen. 
    // 
    return hr; 
} 

Laitteen vapauttaminen #

DirectX:ssä laitteiden vapauttaminen on ohjelmakoodin puolesta helpoin osuus. Ainoa asia joka tulee muistaa on vapauttamisjärjestys, joka on käänteinen luomisjärjestykseen verrattuna.

//-------------------------------------------- 
// Nimi  : VapautaD3D()  
// Kuvaus: Vapauttaa liittymän Direct3D-  
//         laitteeseen. 
//--------------------------------------------  
void VapautaD3D( void )    
{  

    //  
    // Tarkistetaan ennen vapauttamista onko osoitin  
    // laitteeseen edes olemassa. Jos on, tehdään vapautus.  
    //  
    if( g_pD3DLaite != NULL )
    { 
        g_pD3DLaite->Release();  
        g_pD3DLaite = NULL;
    }   
      
    // 
    // Laitteen vapauttamisen jälkeen vapautetaan  
    // Direct3D-rajapinta. 
    // 
    if( g_pD3D != NULL )
    { 
        g_pD3D->Release();  
        g_pD3D = NULL;
    }   
} 

Piirtäminen ruudulle #

Direct3D:ssä kaikki piirtäminen tapahtuu Direct3D-laitteen avulla BeginScene(), EndScene() -funktioparin välissä (scene = näkymä). Jos BeginScene()-funktio antaa palautusarvona virheen, ei ruudulle voi piirtää. Alla oleva koodi siis tarkistaa ennen piirtoa onnistuiko BeginScene():n kutsuminen ja aloittaa piirron vain jos se on mahdollista.

//-------------------------------------------- 
// Nimi  : Piirto()  
// Kuvaus: Kaikki ohjelman piirtäminen  
//         tehdään tässä funktiossa.   
//--------------------------------------------  
HRESULT Piirto( void )    
{ 
    //  
    // Jos Direct3D-laitetta ei ole luotu, ei 
    // voida mitään piirtääkään. 
    //   
    if( g_pD3DLaite == NULL )   
        return S_FAIL; 

    HRESULT hr = S_OK; // palautusarvot 

 

    //    
    // Tyhjennetään ikkuna mustaksi.  
    //    
    g_pD3DLaite->Clear( 0,    
                        NULL,    
                        D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,    
                        D3DCOLOR_XRGB( 0, 0, 0 ),    
                        1.0f,    
                        0 );    
         

    //  
    // Aloitetaan piirto BeginScene():llä. Tarkistetaan 
    // ennen varsinaista piirtoa virheet hr-muuttujalla.  
    //   
    hr = g_pD3DLaite->BeginScene(); 

    if( hr == S_OK ) 
    {   
             
        //   
        // Lopetetaan piirto EndScene()-funktiolla. 
        //   
        g_pD3DLaite->EndScene();  

        //   
        // Esitetään piirretty kuva ruudulla.   
        //  
        g_pD3DLaite->Present( NULL, NULL, NULL, NULL );
   
     } 


      
    //
    // Palautetaan BeginScene()-funktion palautusarvo. 
    // Se kertoo suoraan onnistuiko piirtäminen vai ei. 
    // 
    return hr; 
} 

Ensimmäinen kolmio ruudulle #

Kolmio, ja kolmioista koostuvia muita monikulmioita

Tietokoneille luodut 3-ulotteiset maailmat koostuvat pääasiassa polygoneista, eli monikulmioista. Yleisin 3-ulotteisessa grafiikassa käytetty polygonimuoto on kolmio. Kolmiolla voidaan luoda kaikki muut monikulmiot, ja sillä on helppo koostaa monimutkaisiakin 3-ulotteisia malleja eri esineistä. Oheiset kuvat selventävät asiaa.

Kuten huomaat, käytännössä kaikki esineet voidaan koostaa kolmioista. Mitä enemmän kolmioita koostamisessa käytetään, sitä luonnollisemmalta ja hienommalta mallinnettava esine näyttää. Mutta mitä enemmän kolmioita piirrettävä esine sisältää, sitä hitaammin se piirtyy. Jokainen kolmio on nimittäin muutettava kolmiuloitteisesta koordinaatistostaan ruudulle, 2-ulotteiseen koordinaatistoon. Tämän hoitaa Direct3D:ssä erilaiset matriisit, joihin ei vielä tässä vaiheessa syvällisemmin puututa. Matriiseilla voi kuitenkin helposti pyöritellä, siirrellä sekä muuttaa kolmiulotteisten mallien kokoa ruudulla. Tarkempi kuvaus matriiseista tehdään niille omistetussa osiossaan hieman myöhemmin.

Verteksit, verteksipuskurit ja muut uudet tuttavat #

Beethovenin pään kolmiomalli

Jokainen kolmio itsessään koostuu kolmesta verteksistä (engl. sanasta Vertex). Kyseinen termi tarkoittaa käytännössä koordinaattipistettä joka kuvaa pisteen paikan kolmiulotteisessa koordinaatistossa, mutta voi sisältää myös muutakin tietoa tämän tiedon lisäksi. 2-ulotteisella ruudulla verteksin vastine on pikseli (engl. sanasta Pixel), eli yksi kuvapiste. Direct3D:ssä verteksien eri ominaisuuksia kuvaamaan käytetään FVF-lippumuuttujia (Flexible Vertex Format, Joustava Verteksi Muoto), ja näitä tarvitaan kertomaan 3D-näytönohjaimelle miten sille lähetetty verteksitieto tulee tulkita.
Direct3D säilöö verteksitiedon VerteksiPuskureihin (VertexBuffer). Tämä siksi, että näin 3D-näytönohjain saa helpoiten aseteltua verteksitiedon parhaaseen mahdolliseen paikkaan tietokoneesi muistissa ja saa siten lisää nopeutta itse 3-ulotteisen kuvan piirtämiseen. Seuraava koodi esittelee yhden verteksi-tyypin luomisen, verteksipuskurin luomisen sekä kolmion piirtämisen ruudulle.

   
//-------------------------------------------- 
// Nimi  : LuoVerteksipuskuri() 
// Kuvaus: Luo verteksipuskurin, joka sisältää
//         tiedon piirrettävästä geometriasta. 
//-------------------------------------------- 
HRESULT LuoVerteksipuskuri( void void ) 
{

       HRESULT hr = S_OK;
    //
    // Luodaan kolmio kolmesta verteksistä.
    //
    VERTEKSIMME verteksit[] = { 
        { -1.0f,-1.0f, 0.0f, D3DCOLOR_XRGB( 0, 0, 255 ), }, //x,y,z, sininen
        {  1.0f,-1.0f, 0.0f, D3DCOLOR_XRGB( 0, 255, 0 ), }, //x,y,z, vihreä
        {  0.0f, 1.0f, 0.0f, D3DCOLOR_XRGB( 255, 0, 0 ), }, //x,y,z, punainen
    };
    //
    // Verteksipuskurin luominen. Verteksipuskurit
    // luodaan Direct3D-laitteen avulla.
    //
        g_pVerteksiPuskuri = NULL;
        hr = g_pD3DLaite->CreateVertexBuffer( 3*sizeof(VERTEKSIMME),
             0, FVF_VERTEKSIMME,
             D3DPOOL_DEFAULT,
             &g_pVerteksiPuskuri );
    //
    // Tarkistus virheiden varalta.
    //
       if( FAILED( hr ) ){

       //
       // Verteksipuskurin luominen epäonnistui. Palauta saatu virhearvo.
       //
              return hr;
       }
    //
    // Jotta verteksipuskuriin voi kirjoittaa mitään
    // tietoa vertekseistä, se täytyy ensin lukita. 
    // Tällöin 3D-laite tietää, ettei siihen saa koskea
    // ja että verteksipuskurille suoritetaan toimenpiteitä. 
    //
        VOID* pVerteksit = 0;
        hr = g_pVerteksiPuskuri->Lock( 0,
                   sizeof( verteksit ),
                   ( BYTE** )&pVerteksit,
                   0 );
    //
    // Tarkistus virheiden varalta. 
    //
       if( FAILED( hr ) ){

       //
       // Verteksipuskuria ei voitu lukita. Tuhotaan se ja palautetaan
       // saatu virhe.
       //
              VapautaVerteksiPuskuri();
              return hr;
       }
    //
    // Kopioidaan tiedot vertekseistä verteksipuskuriin.
    //
       memcpy( pVerteksit, verteksit, sizeof( verteksit ) );

    //
    // Lopuksi pitää vielä vapauttaa verteksipuskuri 
    // lukosta. Jos tätä ei tee, koneesi todennäköisesti
    // hyytyy tai kaatuu täysin tähän vaiheeseen. 
    //
       g_pVerteksiPuskuri->Unlock();
    //
    // Palautetaan S_OK onnistumisen merkiksi.
    //
       return S_OK; 
}

//-------------------------------------------- 
// Nimi  : VapautaVerteksipuskuri() 
// Kuvaus: Vapauttaa liittymän verteksi-
//         puskuriin. 
//-------------------------------------------- 
void VapautaVerteksipuskuri( void void ) 
{

       HRESULT hr = S_OK;
    //
    // Tarkistetaan ensin onko verteksipuskuri luotu, ja
    // sen jälkeen vapautetaan se.
    //
    if( g_pVerteksiPuskuri != NULL ){
        g_pVerteksiPuskuri->Release();
        g_pVerteksiPuskuri = NULL;
    }
}

//-------------------------------------------- 
// Nimi  : Piirto() 
// Kuvaus: Kaikki ohjelman piirtäminen
//         tehdään tässä funktiossa. 
//-------------------------------------------- 
HRESULT Piirto( void ) 
{

       HRESULT hr = S_OK;
    //
    // Jos Direct3D-laitetta ei ole luotu, ei
    // voida mitään piirtääkään.
    //
      if( g_pD3DLaite == NULL ) 
        return FALSE;

    HRESULT hr = S_OK;

    //
    // Tyhjennetään ruutu mustaksi.
    //
    g_pD3DLaite->Clear( 0, 
                        NULL, 
                        D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 
                        D3DCOLOR_XRGB( 0, 0, 0 ), 
                        1.0f, 
                        0 ); 


    //
    // Aloitetaan piirto BeginScene():llä. Tarkistetaan 
    // ennen varsinaista piirtoa virheet hr-muuttujalla.
    //
    hr = g_pD3DLaite->BeginScene(); 
    if( hr == S_OK ){

        //
        // Tässä kohtaa ruudulle piirretään kolmioita.
        //

        //
        // Asetetaan matriisit.
        //
        AsetaMatriisit();

        //
        // Asetetaan verteksipuskurimme tietovirraksi (stream), josta
        // D3D-laite hankkii tiedot piirrettävien kolmioiden käyttämistä
        // koordinaattipisteistä.
        //
               g_pD3DLaite->SetStreamSource( 0,
                            g_pVerteksiPuskuri,
                            sizeof( VERTEKSIMME ) );
        //
        // Asetetaan FVF-lippumuuttujamme kertomaan D3D-laitteelle
        // kuinka verteksit tulee piirtää.
        //
        g_pD3DLaite->SetVertexShader( FVF_VERTEKSIMME );

        //
        // Piirretään yksi kolmio ruudulle.
        //
        g_pD3DLaite->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 1 ); 

        //
        // Lopetetaan piirto EndScene()-funktiolla. 
        //
        g_pD3DLaite->EndScene(); 

        //
        // Esitetään piirretty kuva ruudulla. 
        //
        g_pD3DLaite->Present( NULL, NULL, NULL, NULL ); 
    }

    //
    // Palautetaan BeginScene()-funktion palautusarvo. 
    // Se kertoo suoraan onnistuiko piirtäminen vai ei.
    //
    return hr;

}

Aivan aluksi täytyy sanoa, että matriisit eivät ole yksinkertainen ja helppo asia minkä voi käsitellä täydellisesti ohjelmointiartikkelissa. Oletankin että ainakin perusteet matriisien käytöstä on hallussa. Jos matriisit ovat aivan täysin tuntematon käsite, seuraavista linkeistä on hyötyä:

Mathematics of 3D-graphics
(englanniksi, http://pages.infinit.net/jstlouis/3dbhol... )

Matrix and quaternion FAQ
(englanniksi, http://skal.planet-d.net/demo/matrixfaq.... )

Lisäksi kannattaa kysellä vaikka matematiikan opettajalta, jos englanti on heikoissa kantimissa. Suomenkielisiä materiaaleja internetistä ei tunnu löytyvän

Direct3D käyttää homogeenisia 4x4 matriiseja. Kyseiset matriisit määräävät koordinaatiston. Esimerkiksi matriisissa 1

X-akseli = (M11, M12, M13)
Y-akseli = (M21, M22, M23)
Z-akseli = (M31, M32, M33)
Siirros XYZ = (M41, M42, M43)

//
// Sini- ja kosinifunktioiden esilaskenta (valmistelu).
// Tarvitaan tehdä vain kerran.
//
sx = sin(A) 
cx = cos(A)
sy = sin(B)
cy = cos(B)
sz = sin(C)
cz = cos(C)

//
// Jokaisen pyörityksen tekeminen verteksille.
//
x1 = x * cz + y * sz
y1 = y * cz - x * sz
z1 = z

x2 = x1 * cy + z1 * sy
y2 = z1
z2 = z1 * cy - x1 * sy

x3 = x2
y3 = y2 * cx + z1 * sx
z3 = z2 * cx - x1 * sx

//
// Verteksin siirros.
//
xr = x3 + D
yr = y3 + E
zr = z3 + F

Valmistelu:
-------------------------
6 trigonometrista funktiota
6 asettamista (Muuttuja = luku;)
-------------------------
Verteksiä kohden:
------------------------
12 asettamista
12 kertolaskua
9  summausta
------------------------

Valmistelu:                    Muutos
--------------------------     ------
6  trigonometrisiä funktioita  0
18 asettamista                 -12
12 kertolaskua                 +12
6  vähennystä                  +6
--------------------------     -------


Verteksiä kohden         Muutos
------------------------ ------
3  asettamista           -9
9  kertolaskua           -3
6  summausta             -3
------------------------ ------

Yksikkömatriisi on matriisi, jossa ei määritellä lainkaan pyörityksiä tai siirrosta (siirrosvektori on siis nollavektori, jossa x, y ja z ovat kaikki nollia).

X-akseli = ( 1, 0, 0 )
Y-akseli = ( 0, 1, 0 )
Z-akseli = ( 0, 0, 1 )
Siirros XYZ = ( 0, 0, 0)

Mittakaavamatriisi määrää nimensä mukaan x, y ja z -akseleille mittakaavan. Käytännössä matriisi siis pidentää tai lyhentää akseleiden pituutta.

X-akseli = ( Sx, 0, 0 )
Y-akseli = ( 0, Sy, 0 )
Z-akseli = ( 0, 0, Sz )
Siirros XYZ = ( 0, 0, 0)

Siirrosmatriisi on hyvin samankaltainen kuin yksikkömatriisi. Ainoana erona on siirros-osan nollasta eriävät x:n, y:n ja z:n arvot.

X-akseli = ( 1, 0, 0 )
Y-akseli = ( 0, 1, 0 )
Z-akseli = ( 0, 0, 1 )
Siirros XYZ = ( Tx, Ty, Tz)

Pyöritysmatriisit muokkaavat X, Y ja Z -akseleiden vektorien arvoja. Käytännössä pyöritykset toimivat siten, että kahta akselia pyöritetään trigonometrisilla funktiolla (sin, cos, jne) yhden valitun akselin ympäri. Haluttu akseli siis asetetaan yksikkövektoriksi, ja kahta muuta akselia muokataan. Kuvailen tässä 3 pyöritysmatriisia, joilla kaikki muut pyöritykset voidaan saada aikaan.

Pyöritys X-akselin ympäri:

Nyt asetamme X-akselia kuvaavan vektorin yksikkövektoriksi ja pyöritämme Y ja Z -akseleja kuvaavia vektoreita YZ-tasossa halutun määrän.

X-akseli = ( 1, 0, 0 )
Y-akseli = ( 0, cos(kulma), sin(kulma) )
Z-akseli = ( 0, -sin(kulma), cos(kulma) )
Siirros XYZ = ( 0, 0, 0)

X-akseli = ( cos(kulma), 0, -sin(kulma) )
Y-akseli = ( 0, 1, 0 )
Z-akseli = ( sin(kulma), 0, cos(kulma) )
Siirros XYZ = ( 0, 0, 0)

X-akseli = ( cos(kulma), sin(kulma), 0 )
Y-akseli = ( -sin(kulma), cos(kulma), 0 )
Z-akseli = ( 0, 0, 1 )
Siirros XYZ = ( 0, 0, 0)

Matriisien kertolaskua käytetään 3-ulotteisessa grafiikassa jatkuvasti. Se tarkoittaa käytännössä jonkin koordinaatiston muuntamista toiseen koordinaatistoon. Näin esimerkiksi kaksi erilaista pyöritysmatriisia, mittakaavan kasvatus sekä siirrosmatriisi saadaan yhdistettyä yhdeksi matriisiksi. Koska matriisit ovat taulukko-muodossa, niiden kertomiseen on sovittu tietty järjestys. Tämän vuoksi matriisien tulo ei ole kommutatiivinen (eli samanlainen kun kerrotaan kaksi erilaista matriisia keskenään eri järjestyksessä). Esimerkki (A, B, H ja K ovat matriiseja):

    A * B = H
    B * A = K

Direct3D:n matriisit #

Erilaiset matriisit määräävät kuinka verteksipuskureissa määritellyt kolmiot lopulta piirretään ruudulle. Direct3D käyttää kolmea 4x4 matriisia: World (maailma), View (näkymä) ja Projection (projektio), jotka ohjelmoija voi asettaa haluamikseen. Kun kolmioita piirretään ruudulle Direct3D kertoo matriisit keskenään, ja tuloksena tulevaa matriisia käytetään siirtämään verteksit omasta paikallisesta koordinaatistostaan näkymän (view) koordinaatistoon. Englanninkielisissä lähdemateriaaleissa eri koordinaatistoista käytetään nimikettä space (eli tila, esim view space = näkymän koordinaatisto).

World Matrix - Maailmamatriisi #

Maailma-matriisia käytetään pyörittelemään ja siirtelemään kolmioita suhteessa origoon. Se on ensimmäinen edellä mainituista matriiseista joka vaikuttaa piirrettävän kolmion paikkaan ruudulla.

Kuva 3. Maailma-matriisi

//--------------------------------------------
// Nimi  : AsetaMatriisit() 
// Kuvaus: Asettaa world (maailma), view
//         (kuvakulma) sekä projection
//         (projektio) matriisit.
//--------------------------------------------
void AsetaMatriisit( void ) 
{

    //
    // Asetetaan maailma-matriisi yksikkömatriisiksi.
    // Maailma-matriisi määrää piirrettävien kolmioiden
    // paikan.
    //
    D3DXMATRIX matWorld;
    D3DXMatrixIdentity( &matWorld );
    g_pD3DLaite->SetTransform( D3DTS_WORLD, &matWorld );

View Matrix - Näkymämatriisi #

Näkymä-matriisi määrittelee Direct3D:lle paikan ja suunnan mistä piirrettäviä kolmioita tarkastellaan. Parhaiten asian ymmärtää ajattelemalla näkymä-matriisin kameramieheksi ja näkymän kameraksi. Näkymä-matriisi kuljettelee näkymän haluttuun paikkaan, aivan kuten kameramies juoksentelisi kameran kanssa. Maailma-matriisin tavoin myös näkymä-matriisi määritellään suhteessa origoon. Jatkossa kamera-käsitettä käytetään aina kun puhutaan näkymästä.

Kuva 4. Maailma-matriisilla siirretty sylinteri, sekä näkymämatriisin asettama kamera. Vihreä leikattu pyramidi on nk. Viewing Frustrum (alue, jonka sisällä olevat kolmiot näkyvät ruudulla). Sen määrittävät yhdessä näkymä-matriisi sekä projektio-matriisi.

    // 
    // Asetetaan näkymä-matriisi. Näkymä-matriisi määrää
    // paikan josta piirrettävää 3-ulotteista kuvaa
    // katsotaan. Käytetään D3DX-apukirjaston
    // LookAt-funktiota apuna sitä asetettaessa.
    //
    D3DXMATRIX matView;
    D3DXMatrixLookAtLH( &matView,
                        &D3DXVECTOR3( 0.0f, 0.0f, 5.0f ),
                        &D3DXVECTOR3( 0.0f, 0.0f, -5.0f ),
                        &D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );
    g_pD3DLaite->SetTransform( D3DTS_VIEW, &matView );

Projection Matrix - Projektiomatriisi #

Projektio-matriisi määrittelee kuinka verteksit siirtyvät näkymän tilaan (view-space). Koska se siirtää verteksit yksikkökuutioon leviävät lähempänä olevat kolmiot suuremmiksi kuin kauempana olevat, jolloin piirrettyyn kuvaan saadaan perspektiivi.

Perspektiivin lisäksi projektio-matriisi asettaa myös near ja far-tasot (lähitaso, kaukotaso). Lähitaso sijaitsee kameran linssissä (käytännössä se on näyttösi kuvapinta) ja kaukotaso on taasen lähitasosta jonkin verran eteenpäin ruudun 'sisään'. Nämä tasot määrittävät kuinka läheltä ruutua kolmioita aletaan piirtämään, ja kuinka kauas niitä piirretään. Kolmiota ei piirretä, jos se on lähempänä kameraa kuin lähitaso tai kauempana kuin kaukotaso. Jos kolmio on osittain tasojen ulkopuolella, se leikkautuu (engl. clipping) ja siitä piirretään vain ne osat mitkä näkyvät.

Kuva 5. Sylinteri on osittain kaukotason ulkopuolella, joten se leikkautuu.

    //
    // Projektio-matriisi määrää kuinka verteksit asettuvat
    // 2-ulotteiselle ruudulle. Tämä matriisi aiheuttaa esimerkiksi
    // sen, että kauempana olevat objektit näyttävät pienemmiltä
    // kuin lähempänä olevat objektit.
    //
    // Nyt käytämme D3DX-kirjaston valmisfunktiota sen asettamiseen.
    // D3DX_PI / 4 asettaa näkymän leveyden 45 asteeseen.
    //
    D3DXMATRIX matProj;
    D3DXMatrixPerspectiveFovLH( &matProj,
                        D3DX_PI / 4,
                        1.0f,
                        1.0f,
                        100.0f );
    g_pD3DLaite->SetTransform( D3DTS_PROJECTION, &matProj );


} 

Miten tästä eteenpäin? #

Matriisien käytön oppii parhaiten (yllätys yllätys) käyttämällä niitä. Katso D3DX-kirjastosta erilaisia matriisien käsittelyfunktioita ja kokeile niitä AsetaMatriisit()-funktiossa. Tutki erilaisia matriisien pyörityksiä ja siirroksia ja katso miten ne vaikuttavat piirrettävään kolmioon. Tee kaksi erilaista matriisia, aseta molemmat vuorotellen maailma-matriisiksi ja piirrä aina maailma-matriisin asettamisen jälkeen kolmio. Sen jälkeen lisää koodi, jossa kerrot kaksi erilaista matriisia keskenään, pistät tuloksen maailma-matriisiksi ja piirrät kolmion. Vaihda kertomisjärjestystä, ja katso miten lopputulos eroaa edellisestä.
Tuloksena tämän koodin luoman ohjelman tulisi näyttää jotakuinkin tältä (yksityiskohdat kuten yläpalkin väri vaihtelevat tietokoneiden asetusten mukaan):

Kuva 6. Ohjelman piirtämä kolmio.

Loppusanat #

Nyt kun perusasiat Direct3D:n käyttökuntoon saamisesta on käyty lävitse, on aika raottaa hieman ovea sille mitä on vielä tekemättä. Kokonainen 3-ulotteinen pelimoottori (josta useimmat varmasti jo haaveilevat) vaatii vielä koodin tekstuurien, 3D-mallien, sekä muiden olennaisten tietojen lataamiselle erilaisista tiedostoista. Kyseiset asiat käydään läpi myöhemmin, mutta sitä ennen tutustutaan muiden DirectX:n osien perusteisiin, kuten DirectSound (äänet) sekä DirectInput (peliohjaimet) -rajapintojen käyttämiseen. Todelliseen pelimoottoriin on siis vielä matkaa, mutta siihen päästään kyllä.

Kiitokset Risto Karjalaiselle sekä Jussi Huhtiniemelle avusta artikkelin teossa.