spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

tbResult InitScene()
{
    HRESULT     hResult;
    tbMatrix    mProjection;
    float       fAspect;


    // Vertexformat setzen - Positions- und Farbangabe

    if(FAILED(hResult = g_pD3DDevice->SetFVF(SVertex::dwFVF)))
    {
        // Fehler beim Setzen des Vertexformats!

        TB_ERROR_DIRECTX("g_pD3DDevice->SetFVF", hResult, TB_ERROR);
    }

    // Beleuchtung und Culling ausschalten, Dithering aktivieren

    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);

    // Das Bildseitenverhältnis berechnen

    fAspect =   (float)(g_Direct3DParameters.VideoMode.Width)
              / (float)(g_Direct3DParameters.VideoMode.Height);

    // Die Projektionsmatrix erzeugen

    mProjection = tbMatrixProjection(TB_DEG_TO_RAD(90.0f),  // Sichtfeld: 90° (180°)

                                     fAspect,               // Bildseitenverhältnis

                                     0.5f,                  // Nahe Clipping-Ebene

                                     100.0f);               // Ferne Clipping-Ebene


    // Projektionsmatrix einsetzen

    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));

    // Initialisieren des Dreiecks


    g_aTriangleVertex[0].vPosition  = tbVector3( -1.0f,  -1.0f, 0.0f);
    g_aTriangleVertex[0].vTexture.u = tbFloatRandom(-1.0f, 2.0f);
    g_aTriangleVertex[0].vTexture.v = tbFloatRandom(-1.0f, 2.0f);

    g_aTriangleVertex[1].vPosition  = tbVector3( 0.0f,  1.0f, 0.0f);
    g_aTriangleVertex[1].vTexture.u = tbFloatRandom(-1.0f, 2.0f);
    g_aTriangleVertex[1].vTexture.v = tbFloatRandom(-1.0f, 2.0f);

    g_aTriangleVertex[2].vPosition  = tbVector3( 1.0f, -1.0f, 0.0f);
    g_aTriangleVertex[2].vTexture.u = tbFloatRandom(-1.0f, 2.0f);
    g_aTriangleVertex[2].vTexture.v = tbFloatRandom(-1.0f, 2.0f);

    TB_INFO("Bin vor CreateTextureFromFileEx-Funktion");
    if(FAILED(hResult = D3DXCreateTextureFromFileEx(g_pD3DDevice, 
                                                    "Texture.bmp", 
                                                    D3DX_DEFAULT,
                                                    D3DX_DEFAULT,
                                                    D3DX_DEFAULT,
                                                    0,
                                                    D3DFMT_UNKNOWN,
                                                    D3DPOOL_MANAGED,
                                                    D3DX_FILTER_NONE,
                                                    D3DX_DEFAULT,
                                                    0,
                                                    NULL,
                                                    NULL,
                                                    &g_pTexture)))
    {
        TB_ERROR_DIRECTX("D3DXCreateTextureFromFileEx", hResult, TB_ERROR);
    }

    g_pD3DDevice->SetTexture(0, g_pTexture);

    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);


    return TB_OK;
}

C-/C++-Quelltext

tbResult Render(float fNumSecsPassed)
{
    HRESULT     hResult;
    tbMatrix    mRotation;      // Rotationsmatrix

    tbMatrix    mTranslation;   // Translationsmatrix

    tbMatrix    mWorld;         // Vereinende Weltmatrix



    // Rotations- und Translationsmatrix des Dreiecks erzeugen

    mRotation = tbMatrixRotationY(TB_DEG_TO_RAD(g_fTime * 90.0f));
    mTranslation = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 2.0f));
    
    // Beide Matrizen kombinieren und als Weltmatrix einsetzen

    mWorld = mRotation * mTranslation;
    g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mWorld));

    // -------------------------------------------------------------


    // Den Bildpuffer und den Z-Buffer leeren

    if(FAILED(hResult = g_pD3DDevice->Clear(0,
                                            NULL,
                                            D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                                            D3DCOLOR_XRGB(0, 0, 63),
                                            1.0f,
                                            0)))
    {
        // Fehler beim Leeren!

        MessageBox(g_hWindow, "Fehler beim Leeren der Puffer!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        TB_ERROR_DIRECTX("g_pD3DDevice->Clear", hResult, TB_STOP);
    }

    // Szene beginnen

    g_pD3DDevice->BeginScene()  ;
    
    // Nun das Dreieck zeichnen

    if(FAILED(hResult = g_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP ,                     // Dreiecksliste

                                                      1,                    // 1 Dreieck

                                                      g_aTriangleVertex,    // Vertexdaten

                                                      sizeof(SVertex))))   // Vertexgröße

    {
        MessageBox(NULL, "Fehler", "Fehler", MB_ICONEXCLAMATION);
    }
    
    // Szene beenden

    g_pD3DDevice->EndScene();

    // Der große Moment: den Bildpuffer sichtbar machen

    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);

    return TB_OK;
}

C-/C++-Quelltext

struct SVertex
{
    tbVector3           vPosition;  // Position des Vertex

    DWORD               dwColor;    // Farbe des Vertex

    tbVector2           vTexture;
    static const DWORD  dwFVF;      // Vertexformat (statisch)

};

const DWORD SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;