spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

/*  Schreiben Sie ein Programm, das ein einzelnes statisches Dreieck rendert, das
    mit einer Textur überzogen ist. Die Textur soll dabei ohne Verzerrungen auf 
    dem Dreieck abgebildet sein.
*/

#include <D3D9.H>
#include <TRIBASE.H>
#include "InitWindow.h"
#include "Direct3DEnum.h"
#include "InitDirect3D.h"
#include "Resource.h"

#define D3D_DEBUG_INFO

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

// Vertex-Struktur

struct SVertex
{
    tbVector3           vPosition;  // Positions des Vertex

    DWORD               dwColor;    // Farbe des Vertex

    tbVector2           vTexture;   // Texturkoordinaten (nach Farbe des Vertex!!!)

    static const DWORD  dwFVF;      // Vertexformat

};
const DWORD SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;

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

// Struktur für statische Dreiecke

struct STriangle
{
    tbVector3   vPosition;  // Position des Dreiecks

    // Keine Bewegung, Rotation, Rotationszustand!

    DWORD       dwColor;    // Farbe des Dreiecks

    float       fSize;      // Größe

    SVertex     aVertex[3]; // Die 3 Vertizes des Dreiecks

};

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

// Globale Variablen

const int           g_iNumTriangles = 1;            // Legt die Anzahl der zu erzeugenden Dreiecke fest

float               g_fTime = 0.0f;                 // globale Zählervariable, die für die Animation benutzt wird

SDirect3DParameters g_Direct3DParameters;           // Variable vom Struktur-Typ SDirect3DParameters, die alle Daten zur Initialisierung von Direct3D enhält

STriangle           g_aTriangle[g_iNumTriangles];   // Array vom Struktur-Typ SVertex in der ein Objekt(Dreieck) gespeichert wird

PDIRECT3DTEXTURE9   g_pTexture = NULL;              // Texturzeiger


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

// Initialisieren der Szene

tbResult InitScene()
{
    HRESULT     hResult;
    tbMatrix    mProjection;
    float       fAspect;
    tbColor     VertexColor;

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

    // Vertexformat sezten - 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 & Culling ausschalten, Dithering aktivieren

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

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

    // Transformationspipeline Teil 1: Die Projektionsmatrix

    // Das Bildseitenverhältnis berechnen

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

    // Die Projektionsmatrix erstellen

    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,               // Transformationstype

                                (D3DMATRIX*)(&mProjection));    // Zeiger auf eine Matrix


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

    // Initialisieren des/der Dreiecks(e)

    for (int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {
        // Dreieck(e) auf Startpunkt sezten

        g_aTriangle[iTriangle].vPosition = tbVector3(0.0f, 0.0f, 10.0f);
        
        // Keine Bewegung

        // Kein Rücksetzten der Rotation

        // Keine Rotationsgeschwindigkeit


        // Größe des(r) Dreiecks(e) festlegen

        g_aTriangle[iTriangle].aVertex[0].vPosition = tbVector3(-1.0f, -1.0f, 0.0f);
        g_aTriangle[iTriangle].aVertex[1].vPosition = tbVector3(0.0f, 1.0f, 0.0f);
        g_aTriangle[iTriangle].aVertex[2].vPosition = tbVector3(1.0f, -1.0f, 0.0f);

        // Einzelnen Vertizes des Dreiecks generieren

        for (int iVertex = 0; iVertex < 3; iVertex++)
        {
            // Vertex-Farben

            VertexColor.r = tbFloatRandom(0.0f, 1.0f);
            VertexColor.g = tbFloatRandom(0.0f, 1.0f);
            VertexColor.b = tbFloatRandom(0.0f, 1.0f);

            // Dem Dreieck die Vertex-Farben zuweisen

            g_aTriangle[iTriangle].aVertex[iVertex].dwColor = (DWORD)(VertexColor);
        }
                    // Texturkoordinaten erzeugen

            g_aTriangle[iTriangle].aVertex[0].vTexture.u = 0.5f;
            g_aTriangle[iTriangle].aVertex[0].vTexture.v = 0.0f;
            g_aTriangle[iTriangle].aVertex[1].vTexture.u = 1.0f;
            g_aTriangle[iTriangle].aVertex[1].vTexture.v = 1.0f;
            g_aTriangle[iTriangle].aVertex[2].vTexture.u = 0.0f;
            g_aTriangle[iTriangle].aVertex[2].vTexture.v = 1.0f;
    }

    // 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);

    return TB_OK;
}

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

// Render-Funktion

tbResult Render (float fNumSecsPassed)
{
    // *****************************************************

    HRESULT     hResult;
    
    // *****************************************************

    // Bildpuffer & Z-Stencil-Buffer lehren:

    if (FAILED(hResult = g_pD3DDevice->Clear(   0,
                                                NULL,
                                                D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                                                D3DCOLOR_XRGB(255,255,255),
                                                1.0f,
                                                0)))
    {
        // Fehler beim Leeren!

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

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

    // Beginn der Szene:

    if (FAILED(hResult = g_pD3DDevice->BeginScene()))
    {
        // Fehler beim Starten der Szene!

        TB_ERROR_DIRECTX("g_pD3DDevice->BeginScene", hResult, TB_STOP);
    }
    
    // z.B.: Maximaler anisotropischer Filter mit linearem MIP-Mapping

    // Setzen des des SamplerStates für maximalen Anisotropischen Filter

    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_LINEAR);

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

    // Jedes einzelne Dreieck zeichnen

    for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {   
        if (FAILED(hResult = g_pD3DDevice->DrawPrimitiveUP( 
                                        D3DPT_TRIANGLELIST,             // Dreiecksliste

                                        g_iNumTriangles,                // 1 Dreieck

                                        g_aTriangle[iTriangle].aVertex, // Vertizes

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

        {
            // Fehler beim Zeichnen!

            TB_ERROR_DIRECTX("g_pD3DDevice->DrawPrimitiveUP", hResult,  TB_STOP);
        }
    }
    // *****************************************************

    // Beenden der Szene

    g_pD3DDevice->EndScene();

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

    // Den Bildpuffer anzeigen

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


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

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

// Windows-Hauptfunktion

int WINAPI WinMain( HINSTANCE hInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine,
                    int nShowCmd)
{
    tbResult Result;

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

    // Tribase-Engine Initialisieren

    if (tbInit())
    {
        // Fehler

        return 1;
    }
    
    // *****************************************************

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

    Result = GetDirect3DParameters (&g_Direct3DParameters);
    if (Result == TB_ERROR)
    {
        // Fehler

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

        tbExit();
        return 0;
    }

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

    // Fenster initialisieren - Größe hängt vom zuvor gewählten Videomodus ab

    if (InitWindow( g_Direct3DParameters.VideoMode.Width,
                    g_Direct3DParameters.VideoMode.Height,
                    "Übungsbeispiel 2.5: Rotierendes Dreieck",
                    NULL))
    {
        // 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( NULL,
                    "Fehler beim Initialisieren von Direct3D!",
                    "Fehler",
                    MB_OK | MB_ICONEXCLAMATION);
        ExitWindow();
        tbExit();
        return 1;
    }

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

    // Initialisieren der Szene

    InitScene();

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

    // Nachrichtenschleife

    tbDoMessageLoop(Render, Move);

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

    // Textur deaktivieren und löschen

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

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

    // Direct3D & Fenster herunterfahren

    ExitDirect3D();
    ExitWindow();

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

    // Tribase-Engine herunterfahren

    tbExit();

    return 0;
}
// ***********************************************************************************

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