spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

#include <Windows.h>
#include <TriBase.h>
#include <D3DX9.h>
#include <D3D9.h>
#include "D:\TriBase\Beispiele\Allgemeines\InitWindow.h"
#include "D:\TriBase\Beispiele\Allgemeines\Direct3DEnum.h"
#include "D:\TriBase\Beispiele\Allgemeines\InitDirect3D.h"
#include "Resource.h"

// ******************************************************************
// Struktur für einen Vertex: Position, Farbe und Texturkoordinaten
struct SVertex
{
    tbVector3   vPosition;  // Position des Vertex
    DWORD       dwColor;    // Farbe des Vertex
    tbVector2   vTexture;   // Texturkoordinaten
};

float fTime = 1.0f;
SDirect3DParameters g_Direct3DParameters;
SVertex g_aTriAngleVertex[3];
PDIRECT3DINDEXBUFFER9  g_pIndexBuffer = NULL;
PDIRECT3DTEXTURE9  g_pTexture = NULL;
PDIRECT3DVERTEXBUFFER9 g_pVertexBuffer = NULL;


tbResult InitScene()
{

    int* pusIndices;
    SVertex* pVertices;
    tbMatrix mProjection;
    float fAspect;


    //RenderStates
    g_pD3DDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
    g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

    //Samplerstates
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
    g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

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

    fAspect = (float) (g_Direct3DParameters.VideoMode.Width)
            / (float) (g_Direct3DParameters.VideoMode.Height);
    mProjection = tbMatrixProjection(TB_DEG_TO_RAD(90.0f), fAspect, 100.0f, 0.1f);
    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*) (&mProjection));

    //Textur setzen
    D3DXCreateTextureFromFileEx(g_pD3DDevice,
                                             "Texture.bmp",
                                              D3DX_DEFAULT,
                                              D3DX_DEFAULT,
                                              D3DX_DEFAULT,
                                              0,
                                              D3DFMT_UNKNOWN,
                                              D3DPOOL_MANAGED,
                                              D3DX_FILTER_NONE,
                                              D3DX_DEFAULT,
                                              0,
                                              NULL,
                                              NULL,
                                              &g_pTexture);
    
    g_pD3DDevice->SetTexture(0, g_pTexture);

    //Positionsangaben für die Vertices des Würfels generieren
    g_aTriAngleVertex[0].vPosition = tbVector3(-1.0f, 1.0f, -1.0f);
    g_aTriAngleVertex[1].vPosition = tbVector3(-1.0f, 1.0f, 1.0f);
    g_aTriAngleVertex[2].vPosition = tbVector3(1.0f, 1.0f, 1.0f);
    g_aTriAngleVertex[3].vPosition = tbVector3(1.0f, 1.0f, -1.0f);
    g_aTriAngleVertex[4].vPosition = tbVector3(-1.0f, -1.0f, -1.0f);
    g_aTriAngleVertex[5].vPosition = tbVector3(-1.0f, -1.0f, 1.0f);
    g_aTriAngleVertex[6].vPosition = tbVector3(1.0f, -1.0f, 1.0f);
    g_aTriAngleVertex[7].vPosition = tbVector3(1.0f, -1.0f, -1.0f);

    //Farbangaben für den Würfel
    g_aTriAngleVertex[0].dwColor = (DWORD) (tbColor(1.0f, 0.0f, 0.0f));
    g_aTriAngleVertex[1].dwColor = (DWORD) (tbColor(1.0f, 0.0f, 0.0f));
    g_aTriAngleVertex[2].dwColor = (DWORD) (tbColor(1.0f, 0.0f, 0.0f));
    g_aTriAngleVertex[3].dwColor = (DWORD) (tbColor(1.0f, 0.0f, 0.0f));
    g_aTriAngleVertex[4].dwColor = (DWORD) (tbColor(1.0f, 0.0f, 0.0f));
    g_aTriAngleVertex[5].dwColor = (DWORD) (tbColor(1.0f, 0.0f, 0.0f));
    g_aTriAngleVertex[6].dwColor = (DWORD) (tbColor(1.0f, 0.0f, 0.0f));
    g_aTriAngleVertex[0].dwColor = (DWORD) (tbColor(1.0f, 0.0f, 0.0f));

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


    g_aTriAngleVertex[0].vTexture = tbVector2(0.0f, 1.0f);


    //Index und Vertex Buffer erstellen
    g_pD3DDevice->CreateVertexBuffer(8*sizeof(SVertex), 0, D3DFVF_XYZ | D3DFVF_DIFFUSE |D3DFVF_TEX1, D3DPOOL_MANAGED, &g_pVertexBuffer, NULL);
    g_pD3DDevice->CreateIndexBuffer(36*2, 0, D3DFMT_INDEX16, D3DPOOL_MANAGED, &g_pIndexBuffer, NULL);



    //Index und Vertex Buffer sperren
    g_pVertexBuffer->Lock(0, 0, (void**) (&pVertices), D3DLOCK_NOSYSLOCK);
    g_pIndexBuffer->Lock(0, 0, (void**) (&pusIndices), D3DLOCK_NOSYSLOCK);

    //Daten in den Vertex Buffer hineinkopieren
    memcpy(pVertices, g_aTriAngleVertex, sizeof(g_aTriAngleVertex));
    //Daten in den Index Buffer hineinkopieren
    memcpy(pusIndices, aiIndex, sizeof(aiIndex));

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



    return TB_OK;
}

tbResult Move(float fNumSecsPassed)
{
    fTime += 0.015f;
    return TB_OK;
}

tbResult ExitScene()
{
    g_pD3DDevice->SetTexture(0, NULL);
    TB_SAFE_RELEASE(g_pTexture);
    TB_SAFE_RELEASE(g_pIndexBuffer);
    TB_SAFE_RELEASE(g_pVertexBuffer);
    g_pD3DDevice->SetStreamSource(0, NULL, 0, NULL);
    g_pD3DDevice->SetIndices(NULL);
    return TB_OK;
}

tbResult ExitApplication()
{
    ExitScene();
    ExitDirect3D();
    ExitWindow();
    tbExit();
    return TB_OK;
}

tbResult Render(float fNumSecsPassed)
{
    tbMatrix mTranslation;
    tbMatrix mWorld;


    mTranslation = tbMatrixTranslation(tbVector3(0, 0, 2));
    mWorld = mTranslation;
    g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*) (&mWorld));

    g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(50, 100, 0), 1.0f, 0);


    g_pD3DDevice->BeginScene();

    //Den Vertex Buffer einsetzen
    g_pD3DDevice->SetStreamSource(0, g_pVertexBuffer, 0, sizeof(SVertex));

    //Den Index Buffer einsetzen
    g_pD3DDevice->SetIndices(g_pIndexBuffer);
    

    //Zeichnen des Bereichs
    g_pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 1);

    g_pD3DDevice->EndScene();


    //Den Bildpuffer sichtbar machen
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);

    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. 4: Texturen",
                  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;
}

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