spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include <d3dx9.h>
#include <D3D9.h>
#include <TriBase.h>

#define TRIANGLE_FVF ( D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)

struct SVertex
{
    tbVector3           vPosition;  // Position des Vertex

    D3DCOLOR            Color;      // Farbe des Vertex

    tbVector2           vTexture;   //Texturkoordinaten

};


float               g_fTime = 0.0f;         // Zeitzähler

PDIRECT3DTEXTURE9   g_pTexture;             // Die Textur

    tbDirect3D& D3D = tbDirect3D::Instance();

SVertex             g_aVertex[3];

tbConfig g_Config;


// Move-Funktion

tbResult Move(float fTime)
{
    
    // Zeitzähler erhöhen

    g_fTime += fTime;
    return TB_OK;
}


// Render-Funktion

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

    tbMatrix    mWorld;         // Weltmatrix

    tbMatrix    mTranslation;   // Translationsmatrix


    // Puffer leeren und Szene beginnen

    
    D3D->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, tbColor(0.0f, 0.0f, 0.0f), 1.0f, 0);
    D3D->BeginScene();
    
    // ------------------------------------------------------------------

    
    // 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;
    D3D->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mWorld));

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


    // Als Dreiecksfolge zeichnen

    D3D->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 1, g_aVertex, sizeof(SVertex));

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

    // Szene beenden

    D3D->EndScene();
    
    D3D->Present (NULL, NULL, NULL, NULL);
    return TB_OK;
}


tbResult InitGame(char *WindowTitle)
{
    tbResult r;
    
    // Die TriBase-Engine initialisieren und den Konfigurationsdialog aufrufen

    if(tbInit()) return TB_ERROR;
    r = tbDoConfigDialog(&g_Config);
    if(r == TB_CANCELED) return TB_CANCELED;
    else if(r) TB_ERROR("Engine konnte nicht initialisiert werden!", r);

    if (tbDirect3D::Instance().Init(&g_Config, WindowTitle, NULL, NULL))
    {
        TB_ERROR("Direct3D konnte nicht initialisiert werden.", TB_ERROR);
    }
    
    // Texturmanager erstellen

    if(tbTextureManager::Instance().Init())
    {
        // Fehler!

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

    // Die Textur laden

    
    g_pTexture = tbTextureManager::Instance().GetTexture("Texture.jpg");
    if(g_pTexture == NULL) TB_ERROR("Fehler beim Laden von Texture.jpg!", TB_ERROR);
    
    // Die drei Vertizes des Dreiecks erstellen

    // 1.

    g_aVertex[0].vPosition = tbVector3(0.0f, 1.0f, 0.0f);
    g_aVertex[0].Color = tbColor(1.0f, 1.0f, 1.0f);
    g_aVertex[0].vTexture = tbVector2(0.5f, 0.0f);
    
    // 2.

    g_aVertex[1].vPosition = tbVector3(1.0f, -1.0f, 0.0f);
    g_aVertex[1].Color = g_aVertex[0].Color;
    g_aVertex[1].vTexture = tbVector2(1.0f, 1.0f);

    // 3.

    g_aVertex[2].vPosition = tbVector3(-1.0f, -1.0f, 0.0f);
    g_aVertex[2].Color = g_aVertex[0].Color;
    g_aVertex[2].vTexture = tbVector2(0.0f, 1.0f);

    // Vertexformat setzen

    D3D.SetFVF(TRIANGLE_FVF);
    
    // Textur einsetzen

    D3D->SetTexture(0, g_pTexture);

    D3D->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
    D3D->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    D3D->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

    // Beleuchtung und Culling ausschalten, Dithering aktivieren

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

    // Das Bildseitenverhältnis berechnen

    float fAspect =   (float)(D3D.GetScreenSize().x)/ (float)(D3D.GetScreenSize().y);

    // Die Projektionsmatrix erzeugen

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

                                     fAspect,               // Bildseitenverhältnis

                                     0.1f,                  // Nahe Clipping-Ebene

                                     100.0f);               // Ferne Clipping-Ebene


    // Projektionsmatrix einsetzen

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

    return TB_OK;

}



tbResult RunGame(void)
{

    if(tbDoMessageLoop(&Move, &Render))
    {
        TB_ERROR("Fehler in der Nachrichtenschleife.", TB_ERROR);
    }   

    return TB_OK;

}


tbResult ExitGame(void)
{
    tbTextureManager::Instance().Exit();

    tbDirect3D::Instance().Exit();

    if(tbExit())
    {
        TB_ERROR("Fehler beim beenden der TriBase Engine.", TB_ERROR);
    }   

    return TB_OK;

}



int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, char* pcCpmmandLine, int iShowCommand)
{
    InitGame("Test");

    RunGame();

    ExitGame();

    return 0;

}