spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "Include//TriBase.h"
#include "Resource.h"

#define Kartengrosse 100.0f
#define Geschwindigkeit 5.0f

// Struktur für einen Vertex der Ebeneoberfläche

struct SEbeneVertex
{
    tbVector3           vPosition;  // Position

    tbVector3           vNormal;
    tbVector2           vTexture;   // 2D-Texturkoordinaten


    static const DWORD  dwFVF;      // Vertexformat

};

const DWORD SEbeneVertex::dwFVF = D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_NORMAL;


tbResult InitEbene();
// ******************************************************************

// Globale Variablen

tbConfig                g_Config;                       // Konfigurationsstruktur

tbVector3               g_vCameraPos;                   // Kameraposition

float                   g_fCameraRot;                   // Rotation der Kamera

float                   g_fCameraUpDown;                // Schaut die Kamera hoch oder runter?

float                   g_fFOV = TB_DEG_TO_RAD(90.0f);  // Sichtfeld

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

PDIRECT3DTEXTURE9       g_pEbeneTexture;                // Ebenetextur

tbVertexBuffer*         g_pEbeneVB;                     // Ebene-Vertex-Buffer

tbIndexBuffer*          g_pEbeneIB;                     // Ebene-Index-Buffer


tbVector3   vCameraDir;


// ******************************************************************

// Die Move-Funktion

tbResult MoveProc(float fNumSecsPassed)
{


    // Den Zeitzähler aktualisieren

    g_fTime += fNumSecsPassed;

    // Tastatursteuerung...

    vCameraDir = tbVector3(sinf(g_fCameraRot) * cosf(g_fCameraUpDown),
                           sinf(g_fCameraUpDown),
                           cosf(g_fCameraRot) * cosf(g_fCameraUpDown));

    if(GetAsyncKeyState(VK_LEFT))       g_fCameraRot -= 0.5f * fNumSecsPassed;
    if(GetAsyncKeyState(VK_RIGHT))      g_fCameraRot += 0.5f * fNumSecsPassed;
    if(GetAsyncKeyState(VK_UP))         g_fCameraUpDown -= 0.5f * fNumSecsPassed;
    if(GetAsyncKeyState(VK_DOWN))       g_fCameraUpDown += 0.5f * fNumSecsPassed;
    if(GetAsyncKeyState(VK_F1))     g_vCameraPos += vCameraDir * 5.0f * fNumSecsPassed;
    if(GetAsyncKeyState(VK_F2)) g_vCameraPos -= vCameraDir * 5.0f * fNumSecsPassed;

    if(GetAsyncKeyState(VK_F3))
    {
        PDIRECT3DSURFACE9   pBackBuffer;    
        // Bildpuffer abfragen und in Datei speichern

        tbDirect3D::Instance().GetDevice()->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
        D3DXSaveSurfaceToFile("Screeny.bmp", D3DXIFF_BMP, pBackBuffer, NULL, NULL);
        pBackBuffer->Release();
    }


    // Die Tasten "Bild auf" und "Bild ab" verändern das Sichtfeld.

    // So kann man in das Bild "hineinzoomen", mit 15 Grad pro Sekunde.

    if(GetAsyncKeyState(VK_PRIOR)) g_fFOV -= TB_DEG_TO_RAD(15.0f) * fNumSecsPassed;
    if(GetAsyncKeyState(VK_NEXT)) g_fFOV += TB_DEG_TO_RAD(15.0f) * fNumSecsPassed;

    // Das Sichtfeld darf 180° und 0° nicht erreichen.

    if(g_fFOV >= TB_DEG_TO_RAD(180.0f)) g_fFOV = TB_DEG_TO_RAD(179.9f);
    else if(g_fFOV <= TB_DEG_TO_RAD(0.0f)) g_fFOV = TB_DEG_TO_RAD(0.1f);

    return TB_OK;
}

// ******************************************************************

// Die Render-Funktion

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

    D3DLIGHT9   Light;
    //int           iNumPasses;

    

    // Kameramatrix erstellen und einsetzen

    
        vCameraDir = tbVector3(sinf(g_fCameraRot) * cosf(g_fCameraUpDown),
                           sinf(g_fCameraUpDown),
                           cosf(g_fCameraRot) * cosf(g_fCameraUpDown));

    // Z-Buffer leeren und die Szene beginnen

    tbDirect3D& D3D = tbDirect3D::Instance();
    //D3D->Clear(0, NULL, D3DCLEAR_ZBUFFER, 0, 1.0f, 0);

    D3D->Clear(0, 
                           NULL, 
                           D3DCLEAR_TARGET, 
                           D3DCOLOR_XRGB(1,1,1), 
                           1.0f, 
                           0);
    D3D->Clear(0, NULL, D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(1,1,1), 1.0f, 0);

    D3D->BeginScene();

    // Projektionsmatrix erstellen und einsetzen

    mProjection = tbMatrixProjection(g_fFOV, D3D.GetAspect(), 0.1f, 1000.0f);
    D3D.SetTransform(D3DTS_PROJECTION, mProjection);


    mCamera = tbMatrixCamera(g_vCameraPos, g_vCameraPos + vCameraDir);
    D3D.SetTransform(D3DTS_VIEW, mCamera);


    D3D.SetRS(D3DRS_FOGENABLE,      TRUE);
    D3D.SetRS(D3DRS_FOGVERTEXMODE,  D3DFOG_LINEAR);
    D3D.SetRS(D3DRS_FOGTABLEMODE, D3DFOG_NONE);
    D3D.SetRS(D3DRS_FOGCOLOR, tbColor(1.0f, 1.0f, 1.0f));
    D3D.SetRSF(D3DRS_FOGSTART,      3.0f);
    D3D.SetRSF(D3DRS_FOGEND,        6.0f);
    if(D3D.SetRS(D3DRS_RANGEFOGENABLE, FALSE)!= TB_OK) TB_ERROR("NEBEL FUNTZT NICHT", TB_ERROR);
    D3D->SetRenderState(D3DRS_LIGHTING, FALSE);

    D3D.SetTransform(D3DTS_WORLD, tbMatrixIdentity());

    // Datenquellen und Vertexformat setzen

    D3D.SetTexture(0, g_pEbeneTexture);
    D3D->SetStreamSource(0, g_pEbeneVB->GetVB(), 0, sizeof(SEbeneVertex));
    D3D->SetIndices(g_pEbeneIB->GetIB());
    D3D.SetFVF(SEbeneVertex::dwFVF);
    

    D3D->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0,
                                  4, 0,
                                  2);

    // Szene beenden

    D3D->EndScene();

    return TB_OK;
}


// ******************************************************************

// Aufräumen

tbResult CleanUp()
{

    tbDirect3D::Instance().Exit();
    tbTextureManager::Instance().Exit();

    // Die TriBase-Engine herunterfahren

    tbExit();

    return TB_OK;
}

// ******************************************************************

// Windows-Hauptfunktion

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,
                                   "Beispielprogramm Nr. 2: Modelle",
                                   NULL,
                                   LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1))))
    {
        // Fehler!

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

    // Den Texturmanager initialisieren

    if(tbTextureManager::Instance().Init())
    {
        MessageBox(tbDirect3D::Instance().GetWindow(), "Fehler beim Initialisieren des Texturmanagers!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        CleanUp();
        return 1;
    }


    InitEbene();
    // Kamera initialisieren

    g_vCameraPos = tbVector3(0.0f, 0.1f, 0.0f);
    g_fCameraRot = TB_DEG_TO_RAD(90.0f);
    g_fCameraUpDown = 0.0f;

    // Nachrichtenschleife betreten

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

    // Aufräumen

    CleanUp();

    return 0;
}

tbResult InitEbene()
{
        
    SEbeneVertex    Vertex;

    g_pEbeneVB = new tbVertexBuffer;
    if(g_pEbeneVB->Init(4 * sizeof(SEbeneVertex), sizeof(SEbeneVertex), SEbeneVertex::dwFVF,
                        D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DPOOL_DEFAULT))
    {
        // Fehler!

        return TB_ERROR;
    }

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

        return TB_ERROR;
    }

    WORD    wIndex;

    wIndex = 0;     g_pEbeneIB->AddIndex(&wIndex);
    wIndex = 1;     g_pEbeneIB->AddIndex(&wIndex);
    wIndex = 3;     g_pEbeneIB->AddIndex(&wIndex);

            // Zweites Dreieck

    wIndex = 1;     g_pEbeneIB->AddIndex(&wIndex);
    wIndex = 2;     g_pEbeneIB->AddIndex(&wIndex);
    wIndex = 3;     g_pEbeneIB->AddIndex(&wIndex);

    if(g_pEbeneIB->Update()) return TB_ERROR;

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


    // Die Textur der Ebenenoberfläche laden

    g_pEbeneTexture = tbTextureManager::Instance().GetTexture("Ebene.jpg", TRUE, D3DX_DEFAULT, D3DX_DEFAULT, 1, D3DFMT_UNKNOWN, 0, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255));
    if(g_pEbeneTexture == NULL) return TB_ERROR;

    Vertex.vPosition.x = -Kartengrosse/2.0f;
    Vertex.vPosition.y = 0.0f;
    Vertex.vPosition.z = Kartengrosse/2.0f;
    Vertex.vTexture = tbVector2(Vertex.vPosition.x, Vertex.vPosition.z);//TextureProc(Vertex.vPosition);

    Vertex.vNormal = tbVector3(0.0f, 1.0f, 0.0f);
    g_pEbeneVB->SetVertex(0, &Vertex);
    
    Vertex.vPosition.x = Kartengrosse/2.0f;
    Vertex.vPosition.y = 0.0f;
    Vertex.vPosition.z = Kartengrosse/2.0f;
    Vertex.vTexture = tbVector2(Vertex.vPosition.x, Vertex.vPosition.z);//TextureProc(Vertex.vPosition);

    Vertex.vNormal = tbVector3(0.0f, 1.0f, 0.0f);
    g_pEbeneVB->SetVertex(1, &Vertex);

    Vertex.vPosition.x = Kartengrosse/2.0f;
    Vertex.vPosition.y = 0.0f;
    Vertex.vPosition.z = -Kartengrosse/2.0f;
    Vertex.vTexture = tbVector2(Vertex.vPosition.x, Vertex.vPosition.z);//TextureProc(Vertex.vPosition);

    Vertex.vNormal = tbVector3(0.0f, 1.0f, 0.0f);
    g_pEbeneVB->SetVertex(2, &Vertex);


    Vertex.vPosition.x = -Kartengrosse/2.0f;
    Vertex.vPosition.y = 0.0f;
    Vertex.vPosition.z = -Kartengrosse/2.0f;
    Vertex.vTexture = tbVector2(Vertex.vPosition.x, Vertex.vPosition.z);//TextureProc(Vertex.vPosition);

    Vertex.vNormal = tbVector3(0.0f, 1.0f, 0.0f);
    g_pEbeneVB->SetVertex(3, &Vertex);


    if(g_pEbeneVB->Update()) return TB_ERROR;

    
    return TB_OK;
}