spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

// 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
    tbVector2   vTexture;   // Texturkoordinaten
};

// ******************************************************************
// Globale Variablen
const int numTriangle=1;
SDirect3DParameters g_Direct3DParameters;   // Direct3D-Parameter
float               g_fTime = 0.0f;         // Zeitzähler
SVertex             g_aTriangleVertex[numTriangle*3];   // Die drei Vertizes des Dreiecks
PDIRECT3DTEXTURE9 g_pTexture=NULL;
PDIRECT3DVERTEXBUFFER9 g_pVertexBuffer=NULL;

int GetVertexBufferSize(PDIRECT3DVERTEXBUFFER9 pVertexBuffer){
    D3DVERTEXBUFFER_DESC Desc;
    pVertexBuffer->GetDesc(&Desc);
    return Desc.Size;
}

// ******************************************************************
// Render-Funktion
tbResult Render(float fNumSecsPassed)
{
    HRESULT     hResult;
    tbMatrix    mRotationX,mRotationY,mRotationZ;       // Rotationsmatrix
    tbMatrix    mTranslation;   // Translationsmatrix
    tbMatrix    mWorld;         // Vereinende Weltmatrix
    

    // Rotations- und Translationsmatrix des Dreiecks erzeugen
    mRotationX = tbMatrixRotationX(TB_DEG_TO_RAD(g_fTime * 90.0f));
    mRotationY = tbMatrixRotationY(TB_DEG_TO_RAD(g_fTime * 90.0f));
    mRotationZ = tbMatrixRotationZ(TB_DEG_TO_RAD(g_fTime * 90.0f));

    mTranslation = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 2.0
    
    // Beide Matrizen kombinieren und als Weltmatrix einsetzen
    mWorld = mRotationX *mRotationY *mRotationZ * 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();
    
    //StreamSource setzen
    g_pD3DDevice->SetStreamSource(0, g_pVertexBuffer, 0, sizeof(SVertex));
    // Nun das Dreieck zeichnen
    if(FAILED(hResult = g_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, // Dreiecksliste
                                                      0,                // Startvertex
                                                      numTriangle   ))) //Anzahl Primitiven
    { 
        // 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()
{
    // Textur deaktivieren und löschen
    g_pD3DDevice->SetTexture(0, NULL);
    TB_SAFE_RELEASE(g_pTexture);
    
    //VertexBuffer deaktivieren und löschen
    g_pD3DDevice->SetStreamSource(0, NULL, 0, 0);
    TB_SAFE_RELEASE(g_pVertexBuffer);
    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(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)))
    {
        // 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);

    // Bilineare Filter mit linearem MIP-Mapping
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

    // Die Textur 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);
    }

    // Und nun die Textur einsetzen
    g_pD3DDevice->SetTexture(0, g_pTexture);


    // 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°
                                     fAspect,               // Bildseitenverhältnis
                                     0.1f,                  // Nahe Clipping-Ebene
                                     250.0f);               // Ferne Clipping-Ebene

    // Projektionsmatrix einsetzen
    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));
    
    //Vertex-Buffer generieren
    g_pD3DDevice->CreateVertexBuffer(numTriangle * 3 * sizeof(SVertex),//Größe des Buffers in Bytes
                                     0, //Usage: 0=statisch
                                     D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1, //FVF
                                     D3DPOOL_MANAGED, //Speicherklasse
                                     &g_pVertexBuffer,//Der Vertex-Buffer
                                     NULL);//unwichtig
    
    //Der Vertex-Buffer wird verändert - Ressource sperren
    g_pVertexBuffer->Lock(0,0,(void**) &g_aTriangleVertex,D3DLOCK_NOSYSLOCK);
    // 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    = (DWORD)(tbColor(1.0f, 0.0f, 0.0f));
    g_aTriangleVertex[1].dwColor    = (DWORD)(tbColor(0.0f, 1.0f, 0.0f));
    g_aTriangleVertex[2].dwColor    = (DWORD)(tbColor(0.0f, 0.0f, 1.0f));
    tbWriteToLog("%d",GetVertexBufferSize(g_pVertexBuffer));
    //Textur Koordinaten
    for (int i=0;i<numTriangle*3;i++){
        g_aTriangleVertex[i].vTexture.u=tbFloatRandom(-1.0f, 2.0f);
        g_aTriangleVertex[i].vTexture.v=tbFloatRandom(-1.0f, 2.0f);
    }
    g_pVertexBuffer->Unlock();

    

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


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