DirectX (19.)

Prvnφ definicφ upozornφme p°ekladaΦ jakou verzi Direct3D chceme pou₧φt. Dßle pou₧ijeme dva hlaviΦkovΘ soubory pro jßdro D3D a pro rozÜφ°enou knihovnu D3DX. Abychom toto mohli ud∞lat, je d∙le₧itΘ mφt sprßvn∞ nainstalovanΘ DX SDK 8.0 a sprßvn∞ uvedenΘ  cesty v nastavenφ v²vojovΘho prost°edφ.

Dßle je nutnΘ p°ilinkovat dv∞ knihovny: d3d8.lib a D3dx8.lib. To provedeme v dialogu Settings... konkrΘtnφho projektu na kart∞ Linker (Input). Tento postup jsme ji₧ n∞kolikrßt provßd∞li, tak₧e nenφ nutnΘ vÜe podrobn∞ rozepisovat. Op∞t je nutnΘ mφt sprßvn∞ nastavenΘ cesty, tentokrßt pro knihovny.

19.2. Projekt D3DExample1

Vytvo°te si tedy prßzdnou Win32 aplikaci (projekt nazv∞te D3DExample1). Projekt mß obsahovat jen funkci WinMain(). V dneÜnφ lekci nebudeme vytvß°et slo₧it∞jÜφ strukturu projektu a budeme psßt Direct3D k≤d p°φmo do projektu D3DExample1. Pozd∞ji tento k≤d odd∞lφme do samostatnΘ knihovny podobn∞ jako tomu bylo v p°φpad∞ DirectDraw a vlastn∞ vÜech do te∩ probran²ch komponent DirectX.

Na zaΦßtek souboru D3DExample1.cpp vlo₧te v²Üe uveden² k≤d, abychom mohli pou₧φt funkce Direct3D. Nezapome≥te samoz°ejm∞ vlo₧it takΘ knihovnu p°es dialog Settings projektu. Nynφ u₧ mßte projekt p°ipraven² pro Direct3D a m∙₧ete volat libovolnΘ metody. PφÜeme ovÜem grafickou aplikaci, kterß se neobejde bez okna, tak₧e ze vÜeho nejd°φv je nutnΘ zaregistrovat t°φdu okna a potΘ okno vytvo°it. I tento postup jsme ji₧ n∞kolikrßt probφrali, ale pro ·plnost k≤d jeÜt∞ jednou zopakuji.

Vytvo°φme proto novΘ funkce (nezapome≥te vlo₧it prototypy) WinInit() a MainWndProc(). WinInit() zaregistruje t°φdu okna a okno podle tΘto t°φdy vytvo°φ. MainWndProc() je obslu₧nß funkce okna, zde tedy budeme obsluhovat zprßvy p°ichßzejφcφ naÜemu oknu:

HRESULT WinInit(HINSTANCE hInstance)
{
    DWORD dwRet;
    WNDCLASSEX wc;
    //
    // Register the Window Class
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.lpszClassName = "D3DExample1Class";
    wc.lpfnWndProc = MainWndProc;
    wc.style = CS_VREDRAW|CS_HREDRAW;
    wc.hInstance = hInstance;
    wc.hIcon = NULL;
    wc.hCursor = NULL;
    wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
    wc.lpszMenuName = NULL;
    wc.hIconSm = NULL;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    //
    // Register window class
    if(RegisterClassEx(&wc) == 0 ) {
        dwRet = GetLastError();
        return dwRet;
    }
    //
    // Create new main window
    g_hWnd = CreateWindow("D3DExample1Class", "D3DExample1Window",
                            0, 0, 0, 1024, 768, NULL, NULL, hInstance, NULL);
    if(!g_hWnd) {
        dwRet = GetLastError();
        return dwRet;
    }
    ShowWindow(g_hWnd, SW_SHOW);
    UpdateWindow(g_hWnd);
    dwRet = ERROR_SUCCESS;

    return dwRet;
}

LRESULT CALLBACK MainWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch(msg) {
    case WM_SETCURSOR:
        SetCursor(NULL);
        break;

    case WM_DESTROY:
        // Cleanup and close the app
        PostQuitMessage( 0 );
        return 0L;

    case WM_SYSCOMMAND:
        // Prevent moving/sizing and power loss in fullscreen mode
        switch( wParam )
        {
        case SC_MOVE:
        case SC_SIZE:
        case SC_MAXIMIZE:
        case SC_KEYMENU:
        case SC_MONITORPOWER:
            return 1;
        }
        break;
    }
    return DefWindowProc(hWnd, msg, wParam, lParam);
}

Funkce nebudu blφ₧e rozebφrat, proto₧e se jednß o klasickΘ Windows API. Dßle jeÜt∞ trochu upravφme funkci WinMain() a aplikaci zkusφme zkompilovat:

int APIENTRY WinMain(HINSTANCE hInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine,
                    int nCmdShow)
{
    // Window initialization
    WinInit(hInstance);


    MSG msg;
    // Run message loop
    while( TRUE )
    {
        // Look for messages, if none are found then
        // update the state and display it
        if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
        {
            if( 0 == GetMessage(&msg, NULL, 0, 0 ) )
            {
                // WM_QUIT was posted, so exit
                return (int)msg.wParam;
            }

            // Translate and dispatch the message
            TranslateMessage( &msg );
            DispatchMessage( &msg );
        }
        else
        {
            UpdateFrame();
        }
}

return 0;
}

Zde je nutnΘ zavolat funkci, kterß vytvo°φ okno a spustit smyΦku zprßv.

Nynφ zaΦneme pou₧φvat Direct3D a zaΦneme s objektem Direct3D. Tento objekt vytvo°φ funkce Direct3DCreate8() a vrßtφ ukazatel na rozhranφ IDirect3D8. Pomocφ tohoto rozhranφ vytvo°φme tzv. D3D za°φzenφ (device).

Ud∞lejme tedy dva globßlnφ objekty:

Metodou Lock() uzamkneme buffer a m∙₧eme tak zapisovat p°φmo do bufferu. Metoda Lock() mß 4 parametry:

1. Offset v bytech odkud se majφ data zamknout. Pokud zadßte 0, je buffer uzamΦen od zaΦßtku.
2. Tento parametr urΦuje, jak velk² kus vertex bufferu bude uzamΦen. Pokud zadßte 0, je uzamΦen (zp°φstupn∞n) cel² buffer.
Pomocφ 3. parametru budeme p°istupovat k obsahu vertex bufferu.
4. Vlastnosti zamykßnφ, kterΘ si probereme v n∞kterΘ dalÜφ lekci.

V dalÜφm kroku p°ekopφrujeme obsah pole s vertexy do vertex bufferu. Mßme jen t°i vrcholy, tak₧e nenφ nutnΘ psßt cyklus. Nakonec buffer op∞t odemkneme. Stejn² buffer m∙₧ete uzamknout i n∞kolikrßt, ale pro ka₧dΘ volßnφ metody Lock() je nutnΘ volat i metodu Unlock().

Nakonec vytvo°φme funkci UpdateFrame(), ve kterΘ nßÜ troj·helnφk vykreslφme:

void UpdateFrame()
{
    if(g_lpD3DDevice) {
        //
        // Clear the back buffer to a blue color
        g_lpD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(100, 100, 100), 0, 0);
        //
        // Begin rendering
        if(SUCCEEDED(g_lpD3DDevice->BeginScene())) {
            //
            // Set current vertex buffer
            g_lpD3DDevice->SetStreamSource(0, g_lpD3DVB, sizeof(TLVERTEX));
            // and type of vertex data
            g_lpD3DDevice->SetVertexShader(TLVERTEXFORMAT);
            //
            // Draw triangle
            g_lpD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);
            g_lpD3DDevice->EndScene();
        }
        // Flip front/back buffers
        g_lpD3DDevice->Present(NULL, NULL, NULL, NULL);
    }
}

Zkontrolujeme platnost ukazatele na za°φzenφ a vyΦistφme zadnφ buffer (a nastavφme mu takovou podivnou Üedivou barvu). Metodou Clear() m∙₧eme vyΦistit i Z-buffer, ale ten zatφm nepou₧φvßme. Dßle je nutnΘ volat metody BeginScene(), abychom mohli zaΦφt vykreslovat vrcholy. Metodou SetStreamSource() nastavφme vstupnφ vertex buffer, ze kterΘho se budou Φφst vertexovß data (pozor, tato metoda je Φasov∞ velmi nßroΦnß a proto je dobrΘ ji volat co nejmΘn∞). DalÜφm p°φkazem nastavφme vertex shader, v naÜem p°φpad∞ ne programovateln². Toto je pot°eba ud∞lat v₧dy (i kdy₧ nepou₧φvßte programovateln² vertex shader), aby se v∞d∞lo, co se s vrcholy bude d∞lat (zda jsou transformovanΘ, osv∞tlenΘ atd.) No a nakonec zavolßme metodu DrawPrimitive(), kterß vykreslφ po₧adovan² troj·helnφk. Prvnφ parametr udßvß typ vykreslovan²ch dat:
- D3DPT_POINTLIST - ve vertex bufferu je ulo₧eno pole bod∙ a jako polygon se bere bod.
- D3DPT_LINELIST -  ve vertex bufferu je ulo₧eno pole Φar a jako polygon se bere spojnice dvou bod∙. Spojujφ se dva sousednφ vertexy (1. vrchol s 2., 3. se 4. atd.).
- D3DPT_LINESTRIP  - vrcholy se spojujφ vÜechny popo°ad∞ tj. 1. vrchol s 2., 2. vrchol s 3., 3. vrchol se 4. atd.
- D3DPT_TRIANGLELIST - z vertex bufferu se vezmou 3 vrcholy a vyrenderuje se troj·helnφk, potΘ se vezmou dalÜφ t°i vrcholy a renderuje se dalÜφ troj·helnφk nezßvisle na tom prvnφm.
- D3DPT_TRIANGLESTRIP - nejprve se vyrenderuje prvnφ troj·helnφk, potΘ se vezme 4. vrchol a vyrenderuje se dalÜφ troj·helnφk, kter² je tvo°en 2.,3. a 4. vrcholem. Vznikne pßs troj·helnφk∙.
- D3DPT_TRIANGLEFAN - je to podobnΘ jako u pas∙, akorßt vÜechny troj·helnφky sdφlejφ jeden vrchol a vznikne takov² v∞jφ°. Podrobn∞ji si tyto typy renderovan²ch polygon∙ probereme v p°φÜtφ lekci.

Druh² parametr je po°adφ vertexu, kter² se bude vykreslovat jako prvnφ. A nakonec t°etφ udßvß poΦet polygon∙, kterΘ se majφ vykreslit. Zde je t°eba dßt pozor na to, jak² typ polygonu vykreslujeme. Mßme-li ve vertexu bufferu 3 vrcholy, tak mu₧eme vytvo°it 1 troj·helnφk pomocφ D3DPT_TRIANGLELIST nebo 3 body pomocφ  D3DPT_POINTLIST! V prvΘm p°φpad∞ bude poΦet polygon∙ rovno jednΘ a ve druhΘ t°em!!! Nezapome≥te ukonΦit scΘnu metodou EndScene().

Na ·pln² zßv∞r je t°eba prohodit zadnφ a p°ednφ buffer metodou Present().

Pro ·plnost jsem jeÜt∞ p°idal metodu Clean(), kterß uvolnφ vÜechny objekty Direct3D p°i ukonΦenφ aplikace Φi v p°φpad∞ n∞jakΘ chyby:

void Clean() {

    if(g_lpD3DDevice) {
        g_lpD3DDevice->Release();
    }
    if(g_lpD3DObject) {
        g_lpD3DObject->Release();
    }
    if(g_lpD3DVB) {
        g_lpD3DVB->Release();
    }
}

19.4. Zßv∞r

V dneÜnφ lekci jsme vytvo°ili jednoduch² p°φklad zalo₧en² na Direct3D, i kdy₧ to pravΘ 3D samoz°ejm∞ nebylo, proto₧e jsme vykreslovali pouze transformovanΘ vrcholy. TakΘ jsme se nauΦili pou₧φvat vertex buffery, ve kter²ch jsou ulo₧eny vrcholy objekt∙.

V p°φÜtφ lekci si povφme n∞co tzv. index bufferech. V t∞chto bufferech je ulo₧eno po°adφ vrchol∙, kterΘ tvo°φ jednotlivΘ polygony. Nap°φklad si p°edstavte, ₧e chcete nakreslit Φtverec, kterß mß 4 vrcholy. Kdybychom ovÜem m∞li k dispozici jen vertex buffer, museli bychom pou₧φt vrchol∙ 6, proto₧e Φtverec mß dva troj·helnφky. Dφky index buffer∙m ovÜem staΦφ skuteΦn∞ 4 vrcholy a n∞kterΘ se vyu₧ijφ vφcekrßt.

T∞Üφm se p°φÜt∞ nashledanou.

Ji°φ Formßnek