spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

// Dieses Programm zeigt, wie Text mit DirectX Graphics ausgegeben wird


// Headerdateien
#include <d3d9.h>
#include <d3dx9.h>

// Anwendungsfenster erzeugen
HWND CreateMainWindow(HINSTANCE hInstance);

// Callback Funktion zur Nachrichtenbehandlung
LRESULT CALLBACK MessageHandler(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);

// Funktion zur Initialisierung von Direct3D
BOOL InitDirect3D(HWND hWnd);

// Direct3D-Objekte wieder freigeben
void CleanUpDirect3D(void);

// Direct3D-Font erzeugen
void CreateD3DFont(void);

// Zeiger auf das Direct3D-Objekt (Interface)
LPDIRECT3D9       lpD3D       = NULL;

// Zeiger auf das Direct3D-Device
LPDIRECT3DDEVICE9 lpD3DDevice = NULL;

// Zeiger auf das Direct3D-Font-Objekt
LPD3DXFONT        lpD3DFont   = NULL;

// Das Fensterhandle
HWND hWnd = 0;

// Windows main-Funktion
int WINAPI WinMain(HINSTANCE hInstance,      // Handle der Programminstanz
                   HINSTANCE hPrevInstance,  // Handle der letzten Instanz
                   LPSTR lpCmdLine,          // Kommandozeile
                   int nCmdShow)             // Art wie das Fenster angezeigt werden soll
{
    // Fenster erzeugen und Handle speichern
    hWnd = CreateMainWindow(hInstance);

    // Wenn der Rueckgabewert 0 ist, ist ein Fehler aufgetreten
    if(0 == hWnd)
    {
        MessageBox(0, "Fenster konnte nicht erzeugt werden", "Fehler", MB_OK);
        return -1;
    }

    // Direct3D initialisieren
    if(!InitDirect3D(hWnd))
    {
        return -1;
    }

    // Schrift erzeugen
    CreateD3DFont();

    // Struktur, in der Informationen zur Nachricht gespeichert werden
    MSG msg;

    // Diese Schleife laeuft bis die Nachricht WM_QUIT empfangen wird
    while(GetMessage(&msg, NULL, 0, 0))
    {
        // Nachricht an die Callbackfunktion senden
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    // Freigeben der Objekte
    CleanUpDirect3D();

    // Rückgabewert an Windows
    return 0;
}

// Fenster erzeugen
HWND CreateMainWindow(HINSTANCE hInstance)
{
    WNDCLASSEX wndClass =
    {
        sizeof(WNDCLASSEX),                                 // Groesse angeben
        CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW,    // Standardstile
        MessageHandler,                                     // Callback-Funktion
        0,                                                  // Zusaetzliche Angaben
        0,                                                  // nicht benoetigt
        hInstance,                                          // Anwendungsinstanz
        LoadIcon(NULL, IDI_WINLOGO),                        // Windows-Logo
        LoadCursor(NULL, IDC_ARROW),                        // Normaler Cursor
        (HBRUSH)GetStockObject(WHITE_BRUSH),                // Weisser Pinsel
        NULL,                                               // kein Menue
        "WindowClass",                                      // Der Name der Klasse
        LoadIcon(NULL, IDI_WINLOGO)                         // Windows Logo
    };


    // Klasse registrieren
    RegisterClassEx(&wndClass);

    return CreateWindowEx(NULL,                   // Keine erweiterten Stile nutzen
                          "WindowClass",          // Klassenname
                          "D3DDrawText",          // Fenstertitel
                          WS_OVERLAPPEDWINDOW |   // Fenster
                          WS_VISIBLE,             // Eigenschaften
                          50, 50, 800, 600,       // Anfangsposition und Groesse
                          NULL,                   // Handle des Elternfensters
                          NULL,                   // Handle des Menues
                          hInstance,              // Anwendungsinstanz
                          NULL);                  // wird nicht benoetigt
}


// Diese Funktion wird von Windows aufgrufen, wenn
// eine Nachricht fuer Ihr Programm vorliegt
LRESULT CALLBACK MessageHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    // Farbe fuer die Fuellung des Backbuffer festlegen
    D3DCOLOR ClearColor = D3DCOLOR_XRGB(0, 0, 0xFF);

    // testen, um welche Nachticht es sich handelt
    switch(msg)
    {
        // Programm beenden, wenn das Fenster
        // geschlossen wird
        case WM_DESTROY:
                PostQuitMessage(0);
                return 0;
             break;

        case WM_KEYDOWN:
               switch(wParam)
               {
                 // Wenn ESC gedrückt, Anwendung beenden
                 case VK_ESCAPE:
                         DestroyWindow(hWnd);
                      break;
               }
             break;

       case WM_PAINT:

               D3DCOLOR ClearColor = D3DCOLOR_XRGB(0, 0, 0xFF);
               D3DCOLOR TextColor  = D3DCOLOR_XRGB(0xFF, 0, 0);

               // Rechteck anlegen, nur die linke, obere
               // Koordinate festlegen, die andere wird
               // berechnet

               // Puffer mit blau fuellen
               lpD3DDevice->Clear(0, 0,
                                  D3DCLEAR_TARGET,
                                  ClearColor,
                                  0, 0);

               RECT r = { 100, 100, 0, 0 };

               lpD3DDevice->BeginScene();

               // Groessee des Rechtecks berechnen
               lpD3DFont->DrawText(NULL,
                                   "Hallo Direct3D",
                                   -1,
                                   &r,
                                   DT_CALCRECT,
                                   TextColor);

               // Text ausgeben
               lpD3DFont->DrawText(NULL,
                                   "Hallo Direct3D",
                                   -1,
                                   &r,
                                   DT_CENTER,
                                   TextColor);

               lpD3DDevice->EndScene();

               // Szene anzeigen
               lpD3DDevice->Present(0, 0, 0, 0);

             break;

    }

    // Standardnachrichtenverarbeitung von Windows
    return DefWindowProc(hwnd, msg, wParam, lParam);
}


// Direct3D initialisieren
BOOL InitDirect3D(HWND hWnd)
{
    // Direct3D-Objekt erzeugen
    lpD3D = Direct3DCreate9(D3D_SDK_VERSION);

    if(NULL == lpD3D)
    {
     // Fehler, D3D-Objekt wurde nicht erzeugt
     return FALSE;
    }

    // Parameter für den Modus festlegen
    D3DPRESENT_PARAMETERS PParams;
    ZeroMemory(&PParams, sizeof(PParams));

    PParams.SwapEffect     = D3DSWAPEFFECT_DISCARD;
    PParams.hDeviceWindow  = hWnd;
    PParams.Windowed       = TRUE;

    PParams.BackBufferWidth  = 800;
    PParams.BackBufferHeight = 600;
    PParams.BackBufferFormat = D3DFMT_A8R8G8B8;

    // Direct3D-Geraet anlegen
    if(FAILED(lpD3D->CreateDevice(
                                 D3DADAPTER_DEFAULT,
                                 D3DDEVTYPE_HAL,
                                 hWnd,
                                 D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                 &PParams,
                                 &lpD3DDevice)))
    {
        // Fehler, kann Geraet nicht anlegen
        return FALSE;
    }

   return TRUE;
}

void CreateD3DFont(void)
{
  // Struktur fuer die Beschreibung der Schriftart
  // anlegen und Elemente mit 0 initialisieren
  D3DXFONT_DESC FontDesc = { 0 };

  // das Element FaceName muss den Namen der
  // gewuenschten Schriftart enthalten
  strcpy(FontDesc.FaceName, "Arial");

  // nach erfolgreichem Aufruf zeigt lpD3DFont
  // auf ein Objekt vom Typ D3DXFont
  D3DXCreateFontIndirect(lpD3DDevice,
                         &FontDesc,
                         &lpD3DFont);
}


// Direct3D Objekte freigeben
void CleanUpDirect3D(void)
{
    // testen, ob die Objekt angelegt
    // wurden und ggf. freigeben

    if(NULL != lpD3DFont)
    {
        lpD3DFont->Release();
        lpD3DFont = NULL;
    }

    if(NULL != lpD3DDevice)
    {
        lpD3DDevice->Release();
        lpD3DDevice = NULL;
    }

    if(NULL != lpD3D)
    {
        lpD3D->Release();
        lpD3D = NULL;
    }
}