spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Kapitel 2

// Beispielprogramm 02

// ===================

// Auflisten aller Direct3D-Optionen und anschließende Erstellung

// einer Geräteschnittstelle (IDirect3DDevice9).

// Zu den Optionen gehören unter anderem:

// - Adapter und Gerätetyp

// - Videomodi

// - Multi-Sampling-Typen und -Qualitätsstufen

// - Hardware- oder Softwareverarbeitung?


#include <Windows.h>
#include <TriBase.h>
#include "..\\..\\Allgemeines\\InitWindow.h"
#include "..\\..\\Allgemeines\\Direct3DEnum.h"
#include "..\\..\\Allgemeines\\InitDirect3D.h"
#include "Resource.h"

void ExitApp();
// ******************************************************************

//Globale Variablen

SDirect3DParameters g_Direct3DParameters;
float  g_fTime=0.0f;
float g_fCameraAngle = 0.0f;
tbVector3 g_vCameraPosition;
float g_fFOV = TB_DEG_TO_RAD(90.0f);
const int g_iNumCubes = 2048;//Würfel besteht aus 8 Trianglen = 24 Vertize und aus 36 Indizen

PDIRECT3DTEXTURE9   g_pTexture = NULL;  
IDirect3DVertexBuffer9* g_pVertexBuffer = NULL;
IDirect3DIndexBuffer9* g_pIndexBuffer = NULL;

tbVector3 vLightDir(0.0f,0.0f,1.0f);




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

//Globale Struckturen

struct SVertex
{
    tbVector3 vPosition;
    tbVector3 vNormal;
    tbVector2 vTexture;
    static const DWORD  dwFVF;
};

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


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

// InitScene Funktion

tbResult InitScene()
{
    HRESULT hResult;

    if(FAILED(hResult = g_pD3DDevice->SetFVF(SVertex::dwFVF)))
    {
        TB_ERROR_DIRECTX("g_pD3DDevice->SetFVF",hResult,TB_ERROR);
    }

    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING,TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
    g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE,TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_FOGENABLE,TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_FOGVERTEXMODE,D3DFOG_EXP2);
    float fValue = 0.05f;
    g_pD3DDevice->SetRenderState(D3DRS_FOGDENSITY,*((DWORD*)(&fValue)));
    /*g_pD3DDevice->SetRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);*/

    

    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAXANISOTROPY,
                                  g_Direct3DParameters.DeviceCaps.MaxAnisotropy);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);


    //Texture laden

    
    if(FAILED(hResult = D3DXCreateTextureFromFileEx(g_pD3DDevice,       // Device

                                                    "Texture.bmp",      // Dateiname

                                                    D3DX_DEFAULT,       // Breite

                                                    D3DX_DEFAULT,       // Höhe

                                                    D3DX_DEFAULT,       // MIP-Maps

                                                    0,                  // Verwendungszweck

                                                    D3DFMT_UNKNOWN,     // Format

                                                    D3DPOOL_MANAGED,    // Speicherklasse

                                                    D3DX_FILTER_NONE,   // Filter

                                                    D3DX_DEFAULT,       // MIP-Map-Filter

                                                    0,                  // Color-Key

                                                    NULL,               // Unwichtig

                                                    NULL,               // Unwichtig

                                                    &g_pTexture)))      // Die Textur

    {
        // Fehler!

        TB_ERROR_DIRECTX("D3DXCreateTextureFromFileEx", hResult, TB_ERROR);
    }



    g_pD3DDevice->SetTexture(0,g_pTexture);


    // /Die Textur laden

    
    if(FAILED(hResult = g_pD3DDevice->CreateVertexBuffer(g_iNumCubes * 8 * sizeof(SVertex),0,SVertex::dwFVF,D3DPOOL_MANAGED,
                                     &g_pVertexBuffer,NULL)))
    {
        TB_ERROR_DIRECTX("g_pD3DDevice->CreateVertexBuffer()",hResult,TB_ERROR)
    }
    
    if(FAILED(hResult = g_pD3DDevice->CreateIndexBuffer(g_iNumCubes * 36 * 2,0,D3DFMT_INDEX16,
                                    D3DPOOL_MANAGED,&g_pIndexBuffer,NULL)))
    {
        TB_ERROR_DIRECTX("g_pD3DDevice->CreateIndexBuffer()",hResult,TB_ERROR)
    }

    SVertex* pSVertices;
    WORD* pwIndices;

    g_pVertexBuffer->Lock(0,0,(void**)(&pSVertices),D3DLOCK_NOSYSLOCK);
    g_pIndexBuffer->Lock(0,0,(void**)(&pwIndices),D3DLOCK_NOSYSLOCK);

    //Initialisieren der Wüerfel


    for(int iCube = 0;iCube < g_iNumCubes;iCube++)
    {
        tbVector3 vCube = tbVector3Random() * tbFloatRandom(20.0f,250.0f);
        
        int iStartWuerfelVertex = iCube * 8;
        int iStartWuerfelIndex = iCube * 36;

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

        int aiIndex[36] = {0,3,7  ,0,7,4,
                           2,1,5  ,2,5,6,
                           1,0,4  ,1,4,5,
                           3,2,6  ,3,6,7,
                           0,1,2  ,0,2,3,
                           6,5,4  ,6,4,7};

        int iStartNormal = 0;
        for(int iVert = iStartWuerfelVertex;iVert < iStartWuerfelVertex+8;iVert++)
        {
            pSVertices[iVert].vNormal = tbComputeTriangleNormal(pSVertices[aiIndex[iStartNormal]].vPosition,
                                                                pSVertices[aiIndex[iStartNormal+1]].vPosition,
                                                                pSVertices[aiIndex[iStartNormal+2]].vPosition);
            iStartNormal += 3;
            

            pSVertices[iVert].vTexture = tbVector2Random();
        }

        

        for(int iIndex = 0;iIndex < 36; iIndex++)
        {
            pwIndices[iStartWuerfelIndex + iIndex] = (WORD) (aiIndex[iIndex] + iStartWuerfelVertex);
        }
    
    

     }

    g_pVertexBuffer->Unlock();
    g_pIndexBuffer->Unlock();



    return TB_OK;
}


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

// Render-Funktion

tbResult Render(float fNumSecsPassed)
{

    HRESULT     hResult;
    D3DLIGHT9     Light;
    D3DMATERIAL9 Material;
    
    tbMatrix mCamera = tbMatrixCamera(g_vCameraPosition,
                                      g_vCameraPosition+tbVector3(sinf(g_fCameraAngle),0.0f,cosf(g_fCameraAngle)),
                                      tbVector3(0.0f,1.0f,0.0f));
    g_pD3DDevice->SetTransform(D3DTS_VIEW,(D3DMATRIX*)(&mCamera));

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

    tbMatrix mProjection = tbMatrixProjection(g_fFOV,fAspect,0.1f,250.0f);
    g_pD3DDevice->SetTransform(D3DTS_PROJECTION,(D3DMATRIX*)(&mProjection));


    


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

        TB_ERROR_DIRECTX("g_pD3DDevice->Clear", hResult, TB_STOP);
    }

    // Szene beginnen

    g_pD3DDevice->BeginScene();

    // Das Punktlicht wird nun erstellt.

    ZeroMemory(&Light, sizeof(D3DLIGHT9));
    Light.Type          = D3DLIGHT_SPOT;                                // Punktlicht

    Light.Diffuse       = tbColor(1.0f, 0.0f, 10.0f);                   // Weiße Streufarbe

    Light.Ambient       = tbColor(0.1f, 0.1f, 0.1f);                    // Weiße Hintergrundfarbe

    Light.Specular      = tbColor(0.1f, 0.1f, 1.0f);                    // Weiße Glanzfarbe

    

    Light.Range     = 100.0f;                                       // 1000 Einheiten Reichweite

    Light.Theta        = TB_RAD_TO_DEG(60.0f);
    Light.Phi          = TB_RAD_TO_DEG(100.0f);
    Light.Position     = tbVector3(0.0f,0.0f,0.0f);
    Light.Direction    = vLightDir;
    Light.Falloff      = 1.1f;
    Light.Attenuation0  = 0.0f;                                         // Lichtabschwächung

    Light.Attenuation1  = 0.025f;                                       // ...

    Light.Attenuation2  = 0.0f;                                         // ...


    // Licht einsetzen und aktivieren

    

    // Globales schwaches weißes Hintergrundlicht einstellen

    g_pD3DDevice->SetRenderState(D3DRS_AMBIENT, tbColor(0.25f, 0.25f, 0.25f));
    g_pD3DDevice->SetStreamSource(0,g_pVertexBuffer,0,sizeof(SVertex));
    g_pD3DDevice->SetIndices(g_pIndexBuffer);

        Material.Diffuse    = tbColor(0.75f, 0.75f, 0.75f); // Hellgraue Streufarbe

        Material.Ambient    = tbColor(0.25f, 0.25f, 0.25f); // Dunkelgraue Hintergrundfarbe

        Material.Emissive   = tbColor(0.0f, 0.0f, 0.0f);    // Keine Eigenfarbe

        Material.Specular   = tbColor(0.25f, 0.25f, 0.25f); // 25% hellere Glanzfarbe als Streufarbe

        Material.Power      = 10.0f;        // Glanzfaktor variiert

        
        // Das Material einsetzen

        g_pD3DDevice->SetMaterial(&Material);
        g_pD3DDevice->SetLight(0, &Light);
        g_pD3DDevice->LightEnable(0, TRUE);
        
    

    hResult = g_pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
                                       0,
                                       0,
                                       g_iNumCubes * 8,
                                       0,
                                       g_iNumCubes * 12);
    if(FAILED(hResult))
    {
        TB_ERROR_DIRECTX("g_pD3DDevice->DrawIndexedPrimitive", hResult, TB_STOP);
    }




    // Szene beenden

    g_pD3DDevice->EndScene();

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

    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);
    return TB_OK;
}


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

// Move-Funktion

tbResult Move(float fTime)
{
    if(GetAsyncKeyState(VK_LEFT)) g_fCameraAngle += TB_DEG_TO_RAD(40.0f) * fTime;
    if(GetAsyncKeyState(VK_RIGHT)) g_fCameraAngle -= TB_DEG_TO_RAD(40.0f) * fTime;

    tbVector3 vCameraDirection = tbVector3(sinf(g_fCameraAngle),0.0f,cosf(g_fCameraAngle));

    if(GetAsyncKeyState(VK_UP)) g_vCameraPosition += vCameraDirection *10.0f* fTime;

    if(GetAsyncKeyState(VK_DOWN)) g_vCameraPosition -= vCameraDirection *10.0f* fTime;

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

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

    vLightDir = tbVector3TransformCoords(vLightDir,tbMatrixRotationY(TB_DEG_TO_RAD(20.0f *fTime)));



    return TB_OK;
}

void ExitApp()
{
    // Textur deaktivieren und löschen

    g_pD3DDevice->SetTexture(0, NULL);
    TB_SAFE_RELEASE(g_pTexture);

    // Vertex- und Index-Buffer deaktivieren und löschen

    g_pD3DDevice->SetStreamSource(0, NULL, 0, 0);
    g_pD3DDevice->SetIndices(NULL);
    TB_SAFE_RELEASE(g_pVertexBuffer);
    TB_SAFE_RELEASE(g_pIndexBuffer);


}

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

// Windows-Hauptfunktion

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   char* pcCmdLine,
                   int iShowCmd)
{
    
    tbResult            Result;


    // TriBase-Engine initialisieren

    tbInit();

    // Direct3D-Optionen abfragen (vom Benutzer gewählt)

    Result = GetDirect3DParameters(&g_Direct3DParameters);
    if(Result == TB_ERROR)
    {
        // Es trat ein Fehler auf!

        MessageBox(NULL, "Fehler beim Abzählen!", "Fehler",
                   MB_OK | MB_ICONEXCLAMATION);
        tbExit();
        return 1;
    }
    else if(Result == TB_CANCELED)
    {
        // Der Dialog wurde abgebrochen!

        tbExit();
        return 0;
    }

    // Fenster initialisieren. Die Größe hängt vom gewählten

    // Videomodus ab, der in der Parameterstruktur gespeichert ist.

    if(InitWindow(g_Direct3DParameters.VideoMode.Width,
                  g_Direct3DParameters.VideoMode.Height,
                  "Vertex/Index Buffer",
                  LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1))))
    {
        // Fehler beim Erstellen des Fensters!

        MessageBox(NULL, "Fehler beim Erstellen des Fensters!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        tbExit();
        return 1;
    }

    // Direct3D mit den abgefragten Einstellungen initialisieren

    if(InitDirect3D(&g_Direct3DParameters,
                    g_hWindow))
    {
        // Fehler!

        MessageBox(g_hWindow, "Fehler beim Initialisieren von Direct3D!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        ExitWindow();
        ExitApp();
        tbExit();
        return 1;
    }

    if(FAILED(InitScene()))
    {
        TB_ERROR("Fehler bei InitScene",TB_ERROR)
    }

    // Nachrichtenschleife

    tbDoMessageLoop(Render, Move);

    ExitApp();
    // Direct3D und Fenster herunterfahren

    ExitDirect3D();
    ExitWindow();

    // Engine herunterfahren

    tbExit();

    return 0;
}

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

C-/C++-Quelltext

// Kapitel 2

// Beispielprogramm 03

// ===================

// Hier wird das erste einfache Dreieck gezeichnet.


#include <Windows.h>
#include <TriBase.h>
#include "..\\..\\Allgemeines\\InitWindow.h"
#include "..\\..\\Allgemeines\\Direct3DEnum.h"
#include "..\\..\\Allgemeines\\InitDirect3D.h"
#include "Resource.h"

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

// Struktur für einen Vertex: Position und Farbe

struct SVertex
{
    tbVector3           vPosition;  // Position des Vertex

    DWORD               dwColor;    // Farbe des Vertex

    static const DWORD  dwFVF;      // Vertexformat (statisch)

};

const DWORD SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;

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

// Globale Variablen

SDirect3DParameters g_Direct3DParameters;   // Direct3D-Parameter

float               g_fTime = 0.0f;         // Zeitzähler

SVertex             g_aTriangleVertex[3];   // Die drei Vertizes des Dreiecks


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

// Render-Funktion

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_TRIANGLELIST,   // Dreiecksliste

                                                      1,                    // 1 Dreieck

                                                      g_aTriangleVertex,    // Vertexdaten

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

    {
        // Fehler beim Zeichnen!

        MessageBox(g_hWindow, "Fehler beim Zeichnen des Dreiecks!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        TB_ERROR_DIRECTX("g_pD3DDevice->DrawPrimitiveUP", hResult, TB_STOP);
    }

    // Szene beenden

    g_pD3DDevice->EndScene();

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

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

    return TB_OK;
}

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

// Move-Funktion

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

    g_fTime += fNumSecsPassed;

    return TB_OK;
}

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

// Herunterfahren der Szene

tbResult ExitScene()
{
    return TB_OK;
}

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

// Herunterfahren der Anwendung

tbResult ExitApplication()
{
    // Szene herunterfahren

    ExitScene();

    // Direct3D und Fenster herunterfahren

    ExitDirect3D();
    ExitWindow();

    // Engine herunterfahren

    tbExit();

    return TB_OK;
}

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

// Initialisieren der Szene

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.1f,                  // 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( 0.0f,  1.0f, 0.0f);
    g_aTriangleVertex[1].vPosition  = tbVector3( 1.0f, -1.0f, 0.0f);
    g_aTriangleVertex[2].vPosition  = tbVector3(-1.0f, -1.0f, 0.0f);
    g_aTriangleVertex[0].dwColor    = tbColor(1.0f, 0.0f, 0.0f);
    g_aTriangleVertex[1].dwColor    = tbColor(0.0f, 1.0f, 0.0f);
    g_aTriangleVertex[2].dwColor    = tbColor(0.0f, 0.0f, 1.0f);

    return TB_OK;
}

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

// Initialisierungsfunktion

tbResult InitApplication()
{
    tbResult Result;

    // TriBase-Engine initialisieren

    tbInit();

    // Direct3D-Optionen abfragen (vom Benutzer gewählt)

    Result = GetDirect3DParameters(&g_Direct3DParameters);
    if(Result == TB_ERROR)
    {
        // Es trat ein Fehler auf!

        MessageBox(NULL, "Fehler beim Abzählen!", "Fehler",
                   MB_OK | MB_ICONEXCLAMATION);
        return TB_ERROR;
    }
    else if(Result == TB_CANCELED)
    {
        // Der Dialog wurde abgebrochen!

        return TB_CANCELED;
    }

    // Fenster initialisieren. Die Größe hängt vom gewählten

    // Videomodus ab, der in der Parameterstruktur gespeichert ist.

    if(InitWindow(g_Direct3DParameters.VideoMode.Width,
                  g_Direct3DParameters.VideoMode.Height,
                  "Beispielprogramm Nr. 3: Das erste Dreieck",
                  LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1))))
    {
        // Fehler beim Erstellen des Fensters!

        MessageBox(NULL, "Fehler beim Erstellen des Fensters!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        return TB_ERROR;
    }

    // Direct3D mit den abgefragten Einstellungen initialisieren

    if(InitDirect3D(&g_Direct3DParameters,
                    g_hWindow))
    {
        // Fehler!

        MessageBox(g_hWindow, "Fehler beim Initialisieren von Direct3D!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        ExitApplication();
        return TB_ERROR;
    }

    // Szene initialisieren

    if(InitScene())
    {
        // Fehler!

        MessageBox(g_hWindow, "Fehler beim Initialisieren der Szene!",
                   "Fehler", MB_OK | MB_ICONINFORMATION);
        ExitApplication();
        return TB_ERROR;
    }

    // Alles OK!

    return TB_OK;
}

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

// Windows-Hauptfunktion

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   char* pcCmdLine,
                   int iShowCmd)
{
    tbResult Result;

    // Initialisierung

    Result = InitApplication();
    if(Result == TB_CANCELED) return 0;
    else if(Result)
    {
        MessageBox(NULL, "Fehler beim Initialisieren der Anwendung!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        return 1;
    }

    // Nachrichtenschleife

    tbDoMessageLoop(Render, Move);

    // Herunterfahren

    ExitApplication();

    return 0;
}

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