spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

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

// Strukturen oder Globale Variable


PDIRECT3DTEXTURE9 g_pTexture;
SVertex           g_aTriangle;
float             g_fTime = 0.0f;


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


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

const g_aTriangle SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;

// Struktur für ein Dreieck


struct STriangle
{
    tbVector3    vPosition;
    tbVector3    vVelocity;
    tbVector3    vRotation;
    tbVector3    vRotVelocity;
    float     fSize;
    SVertex   aVertex[3];
};

SDirect3DParameters g_Direct3DParameters;

// Render-Funktion


tbResult Render(float fNumSecsPassed)
{

    if((int)(g_fTime / 3.0f) % 3 == 0)
    {
        // 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);
        SetWindowText(g_hWindow, "Beispielprogramm Nr.4: Texturen (MIN: Linear, MAG: Linear, MIP: Linear)");
    }
    else if((int)(g_fTime / 3.0f) % 3 == 2)
    {
        // Keine Filter ("Playstation-Effekt"), auch kein MIP-Mapping

        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
        SetWindowText(g_hWindow, "Beispielprogramm Nr.4: Texturen (MIN: Point, MAG: Point, MIP: None)");
    }
    else
    {
        // Maximaler anisotropischer Filter ohne MIP-Mapping

        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);
        SetWindowText(g_hWindow, "Beispielprogramm Nr. 4: Texturen: (MIN: Anisotropic, MAG: Linear, MIP: None)");

    }

    return TB_OK;
}

// Move-Funktion


float fDistance;

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

    g_fTime += fNumSecsPassed;

    // Wenn der Benutzer die Leertaste drückt, wird das

    // Programm angehalten.

    if(GetAsyncKeyState(VK_SPACE)) fNumSecsPassed = 0.0f;

    // Jedes Dreieck bewegen


    float       fDistance;
    tbVector3                   tbVector3Lenght;
    
    for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {
        // Position und Rotation aktualisieren

        g_aTriangle[iTriangle].vPosition += g_aTriangle[iTriangle].vVelocity
                                                * fNumSecsPassed;
        g_aTriangle[iTriangle].vRotation += g_aTriangle[iTriangle].vRotVelocity
                                                * fNumSecsPassed;

        // Distance des Dreicks zum Beobachter (zum Nullpunkt) berechnen

        fDistance = tbVector3Lenght(g_aTriangle[iTriangle].vPosition);

        // Wenn die Distanz größer als 100 ist, soll das Dreieck umkehren

        if(fDistance > 100.0f) g_aTriangle[iTriangle].vVelocity *= -1.0f;
    }

    return TB_OK;
}

// Herunterfahren der Szene


// Herunterfahren der Anwendung

tbResult ExitApplication()
{
    // Szene herunterfahren


    // Direct3D und Fenster herunterfahren

    ExitDirect3D();
    ExitWindow();

    // Engine herunterfahren

    tbExit();

    return TB_OK;
}

// Initialisieren der Szene

tbResult InitScene()
{
    float fSpeed;

    // Initialisierung der Dreiecke


    for(int iTri = 0; iTri < g_iNumTriangles; iTri++)
    {
        // Alle Dreiecke starten am Punkt (0, 0, 50.0f).

        g_aTriangle[iTri].vPosition = tbVector3(0.0f, 0.0f, 50.0f);

        // Die Bewegung ist zufällig

        float fSpeed = tbFloatRandom(0.1f, 5.0f);
        g_aTriangle[iTri].vVelocity = tbVector3Random() * fSpeed;

        // Rotation zurückstellen

        g_aTriangle[iTri].vRotation = tbVector3(0.0f, 0.0f, 0.0f);

        // Rotationsgeschwindigkeit ist zufällig auf allen drei Achsen

        g_aTriangle[iTri]vRotVelocity.x = tbFloatRandom(-1.0f, 1.0f);
        g_aTriangle[iTri]vRotVelocity.y = tbFloatRandom(-1.0f, 1.0f);
        g_aTriangle[iTri]vRotVelocity.z = tbFloatRandom(-1.0f, 1.0f);

        // Grösse zufällig zwischen 1 und 5 festlegen

        g_aTriangle[iTri].fSize = tbFloatRandom(1.0f, 5.0f);

        // Nun die einzelnen Vertizes generieren

        for(int iVertex = 0; iVertex < 3; iVertex++)
        {
            // Position

            g_aTriangle[iTri].aVertex[iVertex].vPosition = tbVector3Random();

            // Farbe

            tbColor VertexColor(tbFloatRandom(0.0f, 1.0f),
                                tbFloatRandom(0.0f, 1.0f),
                                tbFloatRandom(0.0f, 1.0f));
            g_aTriangle[iTri].aVertex[iVertex].dwColor = (DWORD)(VertexColor);

            // Texturkoordinaten zufällig zwischen -1 únd 2 erzeugen

            g_aTriangle[iTri].aVertex[iVertex].vTexture.u = tbFloatRandom(-1.0f, 2.0f);
            g_aTriangle[iTri].aVertex[iVertex].vTexture.v = tbFloatRandom(-1.0f, 2.0f);
        }
    }

    // Die Textur Laden


    HRESULT hResult;

    if(FAILED(hResult = 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)))
    {
        // Fehler

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

    // Textur einsetzen

    g_pD3DDevice->SetTexture(0, g_pTexture);


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

C-/C++-Quelltext

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

// Includes

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

// Strukturen


struct SStruct
{
    ...;
    ...;
};

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

// Globale Variablen