spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#pragma comment(lib, "Tribase.lib")
#include <TriBase.h>

struct BasicVertex
{
    tbVector3 vPosition;
    DWORD color;
    static const DWORD dwFVF;
};

const DWORD BasicVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;

// Globale Variablen

tbConfig                g_Config;                   // Konfigurationsstruktur

PDIRECT3DTEXTURE9       g_pWaterTexture = NULL;     // Wassertextur

tbVertexBuffer*         g_VB = NULL;                // Sky-Box-Vertex-Buffer

tbIndexBuffer*          g_IB = NULL;                // Sky-Box-Index-Buffer

float                   g_fTime = 0.0f;             // Globaler Zeitzähler


tbResult MoveProc(float fNumSecsPassed)
{
    // Den Zeitzähler aktualisieren

    g_fTime += fNumSecsPassed;

    return TB_OK;
}

tbResult RenderProc(float fNumSecsPassed)
{
    tbMatrix    mProjection;
    tbMatrix    mCamera;
    tbMatrix    mWorld;
    tbVector3   vCamera;


    // Die Szene beginnen

    tbDirect3D& D3D = tbDirect3D::Instance();
    D3D->BeginScene();

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


    // Projektionsmatrix erstellen und einsetzen

    mProjection = tbMatrixProjection(TB_DEG_TO_RAD(90.0f), D3D.GetAspect(), 0.1f, 100.0f);
    D3D.SetTransform(D3DTS_PROJECTION, mProjection);

    // Kameramatrix erstellen und einsetzen. Die Kamera kreist langsam.

    vCamera = tbVector3(0.0, 0.0, -5.0);
    mCamera = tbMatrixCamera(vCamera, tbVector3(0.0f, 0.0f, 0.0f));
    D3D.SetTransform(D3DTS_VIEW, mCamera);

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


    // Z-Buffer deaktivieren, Dithering aktivieren

    D3D.SetRS(D3DRS_ZENABLE, TRUE);
    D3D.SetRS(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
    D3D.SetRS(D3DRS_LIGHTING, FALSE);
    D3D.SetRS(D3DRS_CULLMODE, D3DCULL_CW);

    // Weltmatrix erstellen, die die Sky-Box zur Kamera hin schiebt

    mWorld = tbMatrixTranslation(tbVector3(0.5, 0, 0));
    mWorld = tbMatrixRotationY(TB_DEG_TO_RAD(45)) * mWorld;
    D3D.SetTransform(D3DTS_WORLD, mWorld);

    // Vertex- und Index-Buffer aktivieren und das Vertexformat setzen

    D3D->SetStreamSource(0, g_VB->GetVB(), 0, sizeof(BasicVertex));
    D3D->SetIndices(g_IB->GetIB());
    D3D.SetFVF(BasicVertex::dwFVF);

    D3D->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12);

    mWorld = tbMatrixTranslation(tbVector3(-0.5, 0, -0.5));
    mWorld = tbMatrixRotationX(TB_DEG_TO_RAD(45)) * mWorld;
    D3D.SetTransform(D3DTS_WORLD, mWorld);

    D3D->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12);

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

    D3D->EndScene();

    return TB_OK;
}

tbResult InitCube()
{
    BasicVertex aVertex[8];

    // Vertex- und Index-Buffer erstellen. 8 Vertizes, 36 Indizes.

    g_VB = new tbVertexBuffer;
    if(g_VB->Init(8 * sizeof(BasicVertex), sizeof(BasicVertex), BasicVertex::dwFVF,
                         D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DPOOL_DEFAULT))
    {
        // Fehler!

        return TB_ERROR;
    }

    // Nun der Index-Buffer (16 Bits pro Index)

    g_IB = new tbIndexBuffer;
    if(g_IB->Init(36 * sizeof(WORD), sizeof(WORD), D3DFMT_INDEX16))
    {
        // Fehler!

        return TB_ERROR;
    }

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


    // Die Vertizes erstellen

    aVertex[0].vPosition = tbVector3(-1.0f,  1.0f,  1.0f);
    aVertex[1].vPosition = tbVector3( 1.0f,  1.0f,  1.0f);
    aVertex[2].vPosition = tbVector3( 1.0f,  1.0f, -1.0f);
    aVertex[3].vPosition = tbVector3(-1.0f,  1.0f, -1.0f);
    aVertex[4].vPosition = tbVector3(-1.0f, -1.0f,  1.0f);
    aVertex[5].vPosition = tbVector3( 1.0f, -1.0f,  1.0f);
    aVertex[6].vPosition = tbVector3( 1.0f, -1.0f, -1.0f);
    aVertex[7].vPosition = tbVector3(-1.0f, -1.0f, -1.0f);

    aVertex[0].color = 10000;
    aVertex[1].color = 15000;
    aVertex[2].color = 20000;
    aVertex[3].color = 25000;
    aVertex[4].color = 30000;
    aVertex[5].color = 35000;
    aVertex[6].color = 40000;
    aVertex[7].color = 45000;


    // Alle Vertizes eintragen und den Vertex-Buffer aktualisieren

    g_VB->AddVertices(8, aVertex);
    if(g_VB->Update()) return TB_ERROR;

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


    // Den Index-Buffer ausfüllen

    WORD awIndex[36] = {7, 3, 0,   4, 7, 0,     // Vorderseite

                        5, 1, 2,   6, 5, 2,     // Hinterseite

                        4, 0, 1,   5, 4, 1,     // Linke Seite

                        6, 2, 3,   7, 6, 3,     // Rechte Seite

                        2, 1, 0,   3, 2, 0,     // Oberseite

                        4, 5, 6,   7, 4, 6};    // Unterseite

    g_IB->AddIndices(36, awIndex);
    if(g_IB->Update()) return TB_ERROR;

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


    return TB_OK;
}

tbResult CleanUp()
{
    // Alles löschen

    tbDirect3D::Instance().Exit();

    // Die TriBase-Engine herunterfahren

    tbExit();

    return TB_OK;
}

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   char* pcCommandLine,
                   int iShowCommand)
{
    // TriBase-Engine initialisieren

    tbInit();

    // Konfiguration abfragen

    tbResult r;
    if(r = tbDoConfigDialog(&g_Config))
    {
        if(r == TB_CANCELED) return 0;
        else
        {
            // Fehler!

            MessageBox(NULL, "Fehler im Konfigurationsdialog!", "Fehler",
                       MB_OK | MB_ICONEXCLAMATION);
            return 1;
        }
    }

    // Direct3D initialisieren

    if(tbDirect3D::Instance().Init(&g_Config,
                                   "Cube",
                                   NULL,
                                   NULL))
    {
        // Fehler!

        MessageBox(NULL, "Fehler bei der Direct3D-Initialisierung!", "Fehler",
                   MB_OK | MB_ICONEXCLAMATION);
        CleanUp();
        return 1;
    }


    // Die Sky-Box initialisieren

    if(InitCube())
    {
        MessageBox(tbDirect3D::Instance().GetWindow(), "Fehler beim Initialisieren der Sky-Box!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        CleanUp();
        return 1;
    }

    if(tbDoMessageLoop(MoveProc, RenderProc))
    {
        MessageBox(tbDirect3D::Instance().GetWindow(), "Fehler beim Zeichnen!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        CleanUp();
        return 1;
    }

    // Aufräumen

    CleanUp();

    return 0;
}