spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Kapitel 2

// Beispielprogramm 03

// ===================

// Hier wird das erste einfache Dreieck gezeichnet.


#include <Windows.h>
#include <TriBase.h>
#include "InitWindow.h"
#include "Direct3DEnum.h"
#include "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

    static const DWORD  dwFVF;      // Vertexformat (statisch)

};

const DWORD SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;

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

// Globale Variablen

SDirect3DParameters g_Direct3DParameters;   // Direct3D-Parameter

float               g_fTime = 0.0f;         // Zeitzähler

SVertex             g_aTriangleVertex[3];   // Die drei Vertizes des Dreiecks


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

// Render-Funktion

tbResult Render(float fNumSecsPassed)
{
    HRESULT     hResult;
    tbMatrix    mRotation;      // Rotationsmatrix

    tbMatrix    mTranslation;   // Translationsmatrix

    tbMatrix    mWorld;         // Vereinende Weltmatrix



    // Rotations- und Translationsmatrix des Dreiecks erzeugen

    mRotation = tbMatrixRotationY(TB_DEG_TO_RAD(g_fTime * 90.0f));
    mTranslation = tbMatrixTranslation(tbVector3(0.0f, -0.5f, 2.0f));
    
    // Beide Matrizen kombinieren und als Weltmatrix einsetzen

    mWorld = mRotation * mTranslation;
    g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mWorld));

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


    float fRed = sinf(g_fTime); 
    fRed *= 0,00392156;  // 1 / 255 

    BYTE Red = static_cast<BYTE>(fRed); 

    float fGreen = sinf(g_fTime); 
    fGreen *= 0,00392156;  // 1 / 255 

    BYTE Green = static_cast<BYTE>(fGreen); 

    float fBlue = sinf(g_fTime); 
    fBlue *= 0,00392156;  // 1 / 255 

    BYTE Blue = static_cast<BYTE>(fBlue); 

    // Den Bildpuffer und den Z-Buffer leeren

    if(FAILED(hResult = g_pD3DDevice->Clear(0,
                                            NULL,
                                            D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                                            D3DCOLOR_XRGB(fRed, fGreen, fBlue),
                                            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();

    // Nun das Dreieck zeichnen

    if(FAILED(hResult = g_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,  // Dreiecksliste

                                                      2,                    // 1 Dreieck

                                                      g_aTriangleVertex,    // Vertexdaten

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

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

    float a;
    a = sinf(g_fTime/2);
    if (a<0) a *= -1;
    float b;
    b = cosf(g_fTime);
    if (b<0) b *= -1;

    g_aTriangleVertex[1].vPosition  = tbVector3(    a,     0.0f,     0.0f);
    g_aTriangleVertex[0].vPosition  = tbVector3( 0.0f,     0.0f,     0.0f);
    g_aTriangleVertex[2].vPosition  = tbVector3( 0.0f,        a,     0.0f);
    g_aTriangleVertex[3].vPosition  = tbVector3(    a,        a,     0.0f);

    g_aTriangleVertex[0].dwColor    = tbColor(sinf(g_fTime), cosf(g_fTime),-sinf(g_fTime)); 
    g_aTriangleVertex[1].dwColor    = tbColor(cosf(g_fTime), sinf(g_fTime), tanf(g_fTime)); 
    g_aTriangleVertex[2].dwColor    = tbColor(-sinf(g_fTime),-sinf(g_fTime), sinf(g_fTime));
    g_aTriangleVertex[3].dwColor    = tbColor(-sinf(g_fTime),-tanf(g_fTime), cosf(g_fTime));
    
    // Szene beenden

    g_pD3DDevice->EndScene();

    // Der große Moment: den Bildpuffer sichtbar machen

    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);

    return TB_OK;
}