spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

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

Quellcode

------ Neues Erstellen gestartet: Projekt: dgf, Konfiguration: Debug Win32 ------
Die Zwischen- und Ausgabedateien für das Projekt "dgf" mit der Konfiguration "Debug|Win32" werden gelöscht.
dgf - aktuell.
========== Alles neu erstellen: 1 erfolgreich, Fehler bei 0, 0 übersprungen ==========