spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Sprite Klasse

#include <TriBase.h>

class CSprite
{
public:
    // Konstruktoren
    CSprite ();
    CSprite (char acTexFileName[256], float fX, float fY);

    tbResult SetPos(float fX, float fY);
    tbResult SetTexFile(char acTexFileName[256]);
    tbResult Render(IDirect3DDevice9* D3DDevice);
    tbResult SetTexture(IDirect3DDevice9* D3DDevice);

    // Vertexformat
    struct SSVertex
    {
        tbVector3   vPosition;  // Position(pixelkoordinaten)
        float       fRHW;       // Kehrwert der w-Koordinate
        D3DCOLOR    Diffuse;
        tbVector2   vTex1;      // 2D Texturkoordinaten
    
        static const DWORD dwFVF;
    };

    

private:
    float   mfPosX;     // X und Y Koordinaten
    float   mfPosY;
    char    macTexFile[256];

    SSVertex aVer[4];

    PDIRECT3DTEXTURE9 D3DTexture; // Die Textur

    HRESULT hResult;
};

C-/C++-Quelltext

// Sprite Klasse

#include "Sprites.hpp"
#include <iostream>
using namespace std;

CSprite::CSprite(){}

CSprite::CSprite(char caTexFileName[256], float fX, float fY)
{
    macTexFile[256] = caTexFileName[256];

    mfPosX = fX;
    mfPosY = fY;

}

tbResult CSprite::SetPos(float fX, float fY)
{
    mfPosX = fX;
    mfPosY = fY;

    aVer[0].vPosition = tbVector3(mfPosX, mfPosY, 0.2f);
    aVer[1].vPosition = tbVector3(mfPosX, mfPosY + 20.0f, 0.2f);
    aVer[2].vPosition = tbVector3(mfPosX + 20.0f, mfPosY, 0.2f);
    aVer[3].vPosition = tbVector3(mfPosX + 20.0f, mfPosY + 20.0f, 0.2f);

    return TB_OK;
}

tbResult CSprite::SetTexFile(char acTexFileName[256])
{
    macTexFile[256] = acTexFileName[256];

    return TB_OK;
}

tbResult CSprite::Render(IDirect3DDevice9* D3DDevice)
{
    D3DDevice->SetTexture(0, D3DTexture);
    /*
    D3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
    D3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
    D3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

    D3DDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
    D3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
    */
    D3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);

    if(FAILED(hResult == D3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,
                                2,
                                aVer,
                                sizeof(SSVertex))))
    {
        // Fehler beim Zeichnen!
        tbWriteToLog("Zeichnen nicht erfolgreich!");
        MessageBox(NULL, "Fehler beim Zeichnen des Dreiecks!",
                   "Fehler", MB_OK | MB_ICONEXCLAMATION);
        TB_ERROR_DIRECTX("g_pD3DDevice->DrawPrimitiveUP", hResult, TB_STOP);
    }
    tbWriteToLog("Sprite wurde gezeichnet an Position %f %f %f W: %f", aVer[0].vPosition.x, aVer[0].vPosition.y, aVer[0].vPosition.z, aVer[0].fRHW);
    return TB_OK;
}

tbResult CSprite::SetTexture(IDirect3DDevice9* D3DDevice)
{
    if(FAILED(hResult = D3DXCreateTextureFromFileEx(D3DDevice,                  // Device
                                                    "tex1.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
                                                    D3DCOLOR_XRGB(255, 0, 255), // Color-Key
                                                    NULL,                       // Unwichtig
                                                    NULL,                       // Unwichtig
                                                    &D3DTexture)))              // Die Textur
    {
        // Fehler!
        tbWriteToLog("Textur konnte nicht geladen werden");
        TB_ERROR_DIRECTX("D3DXCreateTextureFromFileEx", hResult, TB_ERROR);

        return TB_ERROR;
    }

    D3DDevice->SetTexture(0, D3DTexture);

        for(int i = 0; i <= 3; i++)
    {
        aVer[i].fRHW = 1.0f;
        aVer[i].Diffuse = tbColor(1.0f, 0.0f, 0.0f);
    }

    tbWriteToLog("Sprite textur wird gesetzt");

    return TB_OK;
}

C-/C++-Quelltext

// Komplett eigenes Projekt für 2D Sprites
// Siehe dazu auch Kapitel 2.15.6 Seite 269
// Ziel: Einfaches erstellen mehrerer Sprites, mit rotation usw

#include <Windows.h>
#include <TriBase.h>
#include "..\\Beispielprogramme\\Allgemeines\\InitWindow.h"
#include "..\\Beispielprogramme\\Allgemeines\\Direct3DEnum.h"
#include "..\\Beispielprogramme\\Allgemeines\\InitDirect3D.h"
#include "Resource.h"
#include "Sprites.hpp"

//******************************************************************
// Vertexstruktur
/*
struct SVertex
{
    tbVector3   vPosition;  // Position(pixelkoordinaten)
    float       fRHW;       // Kehrwert der w-Koordinate
    D3DCOLOR    Diffuse;
    tbVector2   vTex1;      // 2D Texturkoordinaten

    static const DWORD dwFVF;
};
*/

const DWORD CSprite::SSVertex::dwFVF = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1;

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

CSprite             Sprite1("tex1.bmp", 100.0f, 100.0f);                // Das erste Sprite


//******************************************************************
// Render Funktion

tbResult Render(float fNumSecsPassed)
{
    HRESULT     hResult;
    tbMatrix    mWorld;

    g_pD3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);

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

    // Szene beginnen
    g_pD3DDevice->BeginScene();

    Sprite1.Render(g_pD3DDevice);

    // Szene beenden
    g_pD3DDevice->EndScene();

    // Bildpuffer sichtbar machen
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);

    return TB_OK;
}

//******************************************************************
// Move Funktion

tbResult Move(float fNumSecsPassed)
{
    return TB_OK;
}

//******************************************************************
// Exit Funktion der Szene

tbResult ExitScene()
{
    return TB_OK;
}

//******************************************************************
// Exit funktion der Anwendung

tbResult ExitApplication()
{
    // Szene herunterfahren
    ExitScene();

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

    // Engine herunterfahren
    tbExit();

    return TB_OK;
}

//******************************************************************
// Initialisierungsfunktion der Szene

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

    // Vertexformat setzen
    if(FAILED(hResult = g_pD3DDevice->SetFVF(CSprite::SSVertex::dwFVF)))
    {
        // Fehler beim Setzen des Vertexformats!
        TB_ERROR_DIRECTX("g_pD3DDevice->SetFVF", hResult, TB_ERROR);
    }


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

    // Die Sprite Textur setzen
    Sprite1.SetTexture(g_pD3DDevice);
    // Koordinaten festlegen
    Sprite1.SetPos(100.0f, 100.0f);

    return TB_OK;
}

//******************************************************************
// Initialisierungsfunktion der Anwendung

tbResult InitApplication()
{
    tbResult Result;

    // TriBase-Engine initialisieren
    tbInit();

    // Direct3D-Optionen abfragen
    Result = GetDirect3DParameters(&g_Direct3DParameters);
    if(Result == TB_ERROR)
    {
        // Es trat ein Fehler auf!
        MessageBox(NULL, "Fehler beim Abzählen der D3D-Parameter!", "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,
                  "2D Sprites",
                  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_ICONEXCLAMATION);
        ExitApplication();
        return TB_ERROR;
    }

    return TB_OK;
}

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