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;
float*      g_pfButtons = NULL;
BOOL*       g_pbButtons = NULL;
BOOL*       g_pbOldButtons = NULL;
float*      g_pfOldButtons = NULL;

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

//tbEffect*             g_pEbenenEffekt;

tbVector3   vCameraDir;
tbGUI*          m_pGUI;
tbFont*                 m_pFont2;
tbGUISkin               m_GUISkin;      // Skin für die Benutzeroberfläche



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

// Die Move-Funktion

tbResult MoveProc(float fNumSecsPassed)
{

    
    // Den Zeitzähler aktualisieren

    g_fTime += fNumSecsPassed;
    //m_pGUI->Move(fNumSecsPassed, g_pbButtons, g_pfButtons);

    // 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;


    // 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->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;
}

tbResult MsgProc(int iID,
                         tbGUIMessage* pMsg,
                         tbGUI* pGUI)
{


    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;
    }

    tbDirectInput& DI = tbDirectInput::Instance();
    /*if(DI.Init(NULL,
               DISCL_FOREGROUND |
               (m_Config.Direct3D.bWindowed ? DISCL_NONEXCLUSIVE : DISCL_EXCLUSIVE)))
    {
        // Fehler!
        TB_ERROR("DirectInput konnte nicht initialisiert werden!", TB_ERROR);
    }*/
    if(DI.Init(NULL,
               DISCL_FOREGROUND |
               (DISCL_NONEXCLUSIVE)))
    {
        // Fehler!

        TB_ERROR("DirectInput konnte nicht initialisiert werden!", TB_ERROR);
    }

    // Speicher für die analogen Knöpfe reservieren

    g_pfButtons = new float[DI.GetNumButtons()];
    g_pbButtons = new BOOL[DI.GetNumButtons()];
    g_pbOldButtons = new BOOL[DI.GetNumButtons()];
    g_pfOldButtons = new float[DI.GetNumButtons()];
    ZeroMemory(g_pfButtons, DI.GetNumButtons() * sizeof(float));
    ZeroMemory(g_pbButtons, DI.GetNumButtons() * sizeof(BOOL));
    ZeroMemory(g_pbOldButtons, DI.GetNumButtons() * sizeof(BOOL));
    ZeroMemory(g_pfOldButtons, DI.GetNumButtons() * sizeof(float));

    m_pFont2 = new tbFont(); if(m_pFont2->Init("Font1.tga", "Font1.tbf")) TB_ERROR("Fehler beim Laden einer Schriftart!", TB_ERROR);

    m_GUISkin.pSkinTexture          = tbTextureManager::Instance().GetTexture("GUI.bmp", TRUE, D3DX_DEFAULT_NONPOW2, D3DX_DEFAULT_NONPOW2, 1, D3DFMT_UNKNOWN, 0, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255));
    m_GUISkin.pEffect               = new tbEffect; m_GUISkin.pEffect->Init("GUI.fx"); m_GUISkin.pEffect->GetEffect()->SetTexture("Texture", m_GUISkin.pSkinTexture);
    m_GUISkin.pFont                 = m_pFont2;
    m_GUISkin.vCursorSize           = tbVector2(32.0f, 32.0f);
    m_GUISkin.CursorColor1          = tbColor(1.0f, 1.0f, 1.0f);
    m_GUISkin.CursorColor2          = tbColor(1.0f, 1.0f, 1.0f);
    m_GUISkin.vCursorHotSpot        = tbVector2(1.0f, 1.0f);
    m_GUISkin.fCursorSpeed          = 300.0f;
    m_GUISkin.EnabledColor          = tbColor(0.8f, 0.8f, 0.8f, 1.0f);
    m_GUISkin.DisabledColor         = tbColor(0.5f, 0.5f, 0.5f, 0.5f);
    m_GUISkin.HighlightColor        = tbColor(1.0f, 1.0f, 1.0f, 1.0f);
    m_GUISkin.vTextSize             = tbVector2(0.9f);
    m_GUISkin.EnabledTextColor      = tbColor(1.0f, 1.0f, 1.0f, 0.75f);
    m_GUISkin.DisabledTextColor     = tbColor(0.3f, 0.3f, 0.3f, 0.25f);
    m_GUISkin.HighlightTextColor    = tbColor(1.0f, 1.0f, 1.0f, 1.0f);

    if(m_GUISkin.pSkinTexture == NULL)  TB_ERROR("Fehler beim Laden der Skin-Textur für die Benutzeroberfläche!", TB_ERROR);
    if(m_GUISkin.pEffect == NULL)       TB_ERROR("Fehler beim Laden des Effekts für die Benutzeroberfläche!", TB_ERROR);

    // Benutzeroberfläche erstellen

    m_pGUI = new tbGUI;
    if(m_pGUI->Init(&m_GUISkin, MsgProc,
                    tbVector2(1024.0f, 768.0f), tbVector2(256.0f, 0.0f)))//tbVector2(256.0f, 0.0f)

    {
        // Fehler!

        TB_ERROR("Fehler bei der Erstellung der Benutzeroberfläche!", TB_ERROR);
    }   

    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;
}