spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include 
#include 
#include 
#include 
#include 
#include "Allgemeines.h"
#include "Direct3DEnum.h"
#include "InitDirect3D.h"
#include "InitWindow.h"
#include "Resource.h"


//Vertexstruktur
struct SVertex
{
    tbVector3 vPosition; //Position des Vertex
    DWORD dwColor;
    tbVector2 vTexture;     // Texturpos
    static const DWORD  dwFVF;      // Vertexformat
};

struct STriangle
{
    tbVector3 vPosition;    //Position
    tbVector3 vVelocity;    //Richtung + Geschwindigkeit
    tbVector3 vRotation;    //Rotationszustand
    tbVector3 vRotVelocity; //Rotationsbewegung
    float fSize;            //Grösse
    SVertex aVertex[3];
};

PDIRECT3DTEXTURE9 g_pTexture;


float g_fChangeColor = 0.0f;
float g_fChangeColor2 = 0.5f;
float g_fChangeColor3 = 0.7f;
float g_fChangesize = 0.1f;
float g_fWorldDist = 3.0f;
float g_fVorzeichen = 1.0;
const DWORD SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE |D3DFVF_TEX1;;

//Anzahl d. Dreiecke
int const g_iNumTriangles = 1024;
//ALle Dreiecke
STriangle g_aTriangleVertex[g_iNumTriangles];

// Globale Variablen
SDirect3DParameters g_Direct3DParameters;   // Direct3D-Parameter
float               g_fTime = 0.0f;         // Zeitzähler


// ******************************************************************
// Render-Funktion
tbResult Render(float fNumSecsPassed)
{
    HRESULT     hResult;
    tbMatrix    mScaling;       // Skalierungsmatrix
    tbMatrix    mRotationX;     // Rotationsmatrix für die x-Achse
    tbMatrix    mRotationY;     // Rotationsmatrix für die y-Achse
    tbMatrix    mRotationZ;     // Rotationsmatrix für die z-Achse
    tbMatrix    mTranslation;   // Translationsmatrix
    tbMatrix    mWorld;         // Vereinende Weltmatrix


    // Den Bildpuffer und den Z-Buffer leeren
    if(FAILED(hResult = g_pD3DDevice->Clear(0,
                                            NULL,
                                            D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                                            D3DCOLOR_XRGB(0, 0, 63),
                                            1.0f,
                                            0)))
    {
        // Fehler beim Leeren!
        TB_ERROR_DIRECTX("g_pD3DDevice->Clear", hResult, TB_STOP);
    }

    // Szene beginnen
    g_pD3DDevice->BeginScene();

    // Abhängig von der Zeit die Texturfilter setzen.
    // Alle drei Sekunden werden diese geändert.
    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 == 1)
    {
        // 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)");
    }

    // Jedes einzelne Dreieck zeichnen
    for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {
        // Skalierungsmatrix anhand der Größe des Dreiecks erstellen
        mScaling = tbMatrixScaling(tbVector3(g_aTriangleVertex[iTriangle].fSize));

        // Rotationsmatrizen für das Dreieck erzeugen
        mRotationX = tbMatrixRotationX(g_aTriangleVertex[iTriangle].vRotation.x);
        mRotationY = tbMatrixRotationY(g_aTriangleVertex[iTriangle].vRotation.y);
        mRotationZ = tbMatrixRotationZ(g_aTriangleVertex[iTriangle].vRotation.z);

        // Translationsmatrix
        mTranslation = tbMatrixTranslation(g_aTriangleVertex[iTriangle].vPosition);
        
        // Alle Matrizen kombinieren und als Weltmatrix einsetzen
        mWorld = mScaling * mRotationX * mRotationY * mRotationZ * mTranslation;
        g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mWorld));

        if(FAILED(hResult = g_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST,               // Dreiecksliste
                                                        1,                              // 1 Dreieck
                                                        g_aTriangleVertex[iTriangle].aVertex,   // Vertexdaten
                                                        sizeof(SVertex))))              // Vertexgröße
        {
            // Fehler beim Zeichnen!
            TB_ERROR_DIRECTX("g_pD3DDevice->DrawPrimitiveUP", hResult, TB_STOP);
        }
    }

    // Szene beenden
    g_pD3DDevice->EndScene();

    // Der große Moment: den Bildpuffer sichtbar machen
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);

    return TB_OK;
}

tbResult Move(float fNumSecsPassed)
{
    //Zeitzähler erhöhen
    g_fTime += fNumSecsPassed;

    //Wenn der Benutzer die Leertaste drückt dann anhalten
    if(GetAsyncKeyState(VK_SPACE)) fNumSecsPassed = 0.0f;

    //Jeder Dreieck bewegen
    float fDistance;
    for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {
        //Position und Rotation aktualisieren
        g_aTriangleVertex[iTriangle].vPosition += g_aTriangleVertex[iTriangle].vVelocity * fNumSecsPassed;
        g_aTriangleVertex[iTriangle].vRotation += g_aTriangleVertex[iTriangle].vRotVelocity * fNumSecsPassed;
        
        //Distanz zum Nullpunkt berechnen
        fDistance = tbVector3Length(g_aTriangleVertex[iTriangle].vPosition += g_aTriangleVertex[iTriangle].vPosition);

        //Wenn die Distanz groesser als 100 ist, soll es wieder umkehren
        if(fDistance > 100.0f) g_aTriangleVertex[iTriangle].vVelocity *= -1.0f;


    }

    return TB_OK;
}

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


    // Vertexformat setzen - 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 und Culling ausschalten, Dithering aktivieren
    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);
    // Das Bildseitenverhältnis berechnen
    fAspect =   (float)(g_Direct3DParameters.VideoMode.Width)
            / (float)(g_Direct3DParameters.VideoMode.Height);

    // Die Projektionsmatrix erzeugen
    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, (D3DMATRIX*)(&mProjection));

    // Initialisieren des Dreiecks
    for(int iTri = 0; iTri < g_iNumTriangles; iTri++)
    {
        //Alle Dreiecke starten an Punkt 0,0,50
        g_aTriangleVertex[iTri].vPosition = tbVector3(0.0f,0.0f,50.0f);

        //Die Bewegung ist zufällig
        g_aTriangleVertex[iTri].vVelocity = tbVector3Random() * tbFloatRandom(0.1f, 5.0f);

        //Rotations zurücksetzen
        g_aTriangleVertex[iTri].vRotation = tbVector3(0.0f, 0.0f, 0.0f);

        //Rotationsgeschwindigkeit ist zufällig auf allen 3 Achsen
        g_aTriangleVertex[iTri].vRotVelocity.x = tbFloatRandom(-1.0f, 1.0f);
        g_aTriangleVertex[iTri].vRotVelocity.y = tbFloatRandom(-1.0f, 1.0f);
        g_aTriangleVertex[iTri].vRotVelocity.z = tbFloatRandom(-1.0f, 1.0f);

        //Größe zufällig zwischen 1 und 5 festlegen
        g_aTriangleVertex[iTri].fSize = tbFloatRandom(1.0f, 5.0f);

        //Die einzelnen Verizes generieren
        for(int iVertex = 0; iVertex < 3; iVertex++)
        {
            //Position und Farbe
            g_aTriangleVertex[iTri].aVertex[iVertex].vPosition = tbVector3Random();
            g_aTriangleVertex[iTri].aVertex[iVertex].dwColor = tbColor(tbFloatRandom(0.0f, 1.0f),tbFloatRandom(0.0f, 1.0f),tbFloatRandom(0.0f, 1.0f));
            
            //Texturkoordinaten zufällig zwischen -1 und 2
            g_aTriangleVertex[iTri].aVertex[iVertex].vTexture.u = tbFloatRandom(-1.0f, 2.0f);
            g_aTriangleVertex[iTri].aVertex[iVertex].vTexture.v = tbFloatRandom(-1.0f, 2.0f);

        }

    }

    //Die 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
    {
        TB_ERROR_DIRECTX("D3DXCreateTextureFromFileEx", hResult, TB_ERROR);
    }

    //Textur einsetzen
    g_pD3DDevice->SetTexture(0, g_pTexture);
    return TB_OK;

}
// ******************************************************************

// Windows-Hauptfunktion

int WINAPI WinMain(HINSTANCE hInstance,
                HINSTANCE hPrevInstance,
                char* pcCmdLine,
                int iShowCmd)
{
    tbInit();
    
    //Direct 3D optionen Abfragen vom benutzer
    SDirect3DParameters Direct3DParameters;
    
    tbResult Result = GetDirect3DParameters(&Direct3DParameters);
    g_Direct3DParameters =Direct3DParameters;
    if(Result == TB_ERROR)
    {
        //Es trat ein Fehler auf
        MessageBox(NULL, "Fehler beim Abzählen!", "Fehler", MB_OK | MB_ICONEXCLAMATION);
        tbExit();

        return 0;
    }
    else if( Result == TB_CANCELED)
    {
        //Der Dialog wurde abgebrochen
        tbExit();
        return 0;
    }

    //Fenster Initialisieren
    //Die Größe hängt vom gewählten Videomodus ab
    if(InitWindow(  Direct3DParameters.VideoMode.Width,
        Direct3DParameters.VideoMode.Width,
        "Beispielprogramm: Das erste Dreieck",
        LoadIcon(hInstance,MAKEINTRESOURCE(IDI_ICON1))))
    {
        MessageBox(NULL, "Fehler beim erstellen des Fensters!",
            "Fehler", MB_OK | MB_ICONEXCLAMATION);

        tbExit();
        return 0;
    }

    //DirectX mit den abgefragten Einstellungen initialisieren
    if(InitDirect3D(&Direct3DParameters,
        g_hWindow))
    {
        //Fehler
        MessageBox(NULL, "Fehler beim initialisieren von DirectX!",
            "Fehler", MB_OK | MB_ICONEXCLAMATION);
        ExitWindow();
        tbExit();
        return 1;
    }

    InitScene();

    //Nachrichtenschleife
    tbDoMessageLoop(Render, Move);

    //Direct3D und Fenster herrunterfahren
    ExitDirect3D();
    ExitWindow();

    //Engine herrunterfahren
    tbExit();

    return 0;
}

C-/C++-Quelltext

1>main.obj : error LNK2019: Verweis auf nicht aufgelöstes externes Symbol "_D3DXCreateTextureFromFileExA@56" in Funktion ""enum tbResult __cdecl InitScene(void)" (?InitScene@@YA?AW4tbResult@@XZ)".
1>C:\Dokumente und Einstellungen\Sebastian\eigene dateien\visual studio 2010\Projects\TB_DX_ErstesDreieck\Debug\TB_DX_ErstesDreieck.exe : fatal error LNK1120: 1 nicht aufgelöste externe Verweise.