spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// Allgemeines.h



//{{NO_DEPENDENCIES}}

// Microsoft Visual C++ generated include file.

// Used by Allgemeines.rc

//

#define IDD_DIRECT3D_SETTINGS           901
#define IDC_D3DS_OK                     9001
#define IDC_D3DS_CANCEL                 9002
#define IDC_D3DS_ADAPTERS               9003
#define IDC_D3DS_DEVICE_TYPES           9004
#define IDC_D3DS_WINDOWED_MODE          9005
#define IDC_D3DS_FULLSCREEN_MODE        9006
#define IDC_D3DS_VIDEO_MODES            9007
#define IDC_D3DS_BACK_BUFFER_FORMATS    9008
#define IDC_D3DS_Z_STENCIL_BUFFER_FORMATS 9009
#define IDC_D3DS_MULTI_SAMPLING_TYPES   9010
#define IDC_D3DS_MULTI_SAMPLING_QUALITIES 9011
#define IDC_D3DS_HARDWARE_TNL           9012
#define IDC_D3DS_SOFTWARE_TNL           9014
#define IDC_D3DS_DESCRIPTION            9016
#define IDC_D3DS_SAVE                   9015
#define IDC_D3DS_LOAD                   9017


// Direct3DEnum.h



// Hilfsdatei DIRECT3DENUM.H

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

// Hier werden Funktionen zur Auflistung aller Direct3D-Adapter, deren

// Videomodi und sonstige Eigenschaften deklariert. Ein Dialogfenster

// präsentiert alle Möglichkeiten übersichtlich.


#ifdef _DIRECT3DENUM_CPP
#undef VAR
#define VAR
#else
#undef VAR
#define VAR extern
#endif

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

// Struktur für die Direct3D-Parameter

struct SDirect3DParameters
{
    int                 iAdapter;               // Adapter-ID

    D3DDEVTYPE          DeviceType;             // Gerätetyp

    BOOL                bWindowed;              // Fenstermodus?

    D3DDISPLAYMODE      VideoMode;              // Videomodus

    D3DFORMAT           BackBufferFormat;       // Bildpufferformat

    D3DFORMAT           ZStencilBufferFormat;   // Z-Stencil-Buffer-Format

    D3DMULTISAMPLE_TYPE MultiSamplingType;      // Multi-Sampling-Typ

    DWORD               dwMultiSamplingQuality; // Multi-Sampling-Qualität

    DWORD               dwFlags;                // Flags (Hardware oder Software?)

    D3DCAPS9            DeviceCaps;             // Fähigkeiten des Geräts

};

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

// Funktionen

tbResult GetDirect3DParameters(SDirect3DParameters* pOut); // Direct3D-Parameter erfragen (Auwahl per Dialogfenster)


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




Resource Files:



// Allgemeines.rc


keine Text


Source Files:


// Direct3DEnum.cpp



// Hilfsdatei DIRECT3DENUM.CPP

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

// Hier werden Funktionen zur Auflistung aller Direct3D-Adapter, deren

// Videomodi und sonstige Eigenschaften deklariert. Ein Dialogfenster

// präsentiert alle Möglichkeiten übersichtlich.


#define _DIRECT3DENUM_CPP
#include <Windows.h>
#include <TriBase.h>
#include <D3D9.h>
#include "Direct3DEnum.h"
#include "Allgemeines.h"


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

// Beschreibungstexte

#define ADAPTER_DESCRIPTION                 ("Adapter:\r\n\r\nWählen Sie aus der Liste den Adapter aus, mit dem das Programm arbeiten soll. Ein Adapter ist das gleiche wie eine Grafikkarte oder ein Grafikchip. Im Normalfall ist nur ein einziger Adapter auf Ihrem System installiert.")
#define DEVICE_TYPE_DESCRIPTION             ("Gerätetyp:\r\n\r\nDer Gerätetyp bestimmt, ob hardwarebeschleunigte Grafikausgabe zum Einsatz kommt (empfohlen). Eventuell gibt es noch weitere Möglichkeiten, die Sie nur dann in Erwägung ziehen sollten, wenn die Hardwarebeschleunigung nicht funktioniert.")
#define VIDEO_MODE_DESCRIPTION              ("Videomodus:\r\n\r\nDer Videomodus bestimmt die Auflösung des Monitors im Vollbildmodus oder die Größe des Fensters im Fenstermodus. Je höher die Auflösung, desto mehr Details sind erkennbar und desto langsamer läuft die Anwendung. 800 x 600 Pixel ist ein guter Wert.\r\nAchten Sie auch auf die eventuell angegebene Bildwiederholfrequenz! Je höher, desto flimmerfreier ist das Bild. Im Fenstermodus spielen Format und Bildwiederholfrequenz keine Rolle - sie werden vom aktuellen Videomodus übernommen.")
#define WINDOWED_FULLSCREEN_DESCRIPTION     ("Fenster-/Vollbildmodus:\r\n\r\nWählen Sie \"Fenstermodus\", damit das Programm in einem Fenster läuft. Sie können so einfacher zwischen Anwendungen wechseln. Der Vollbildmodus überlässt der Anwendung mehr Möglichkeiten und kann zu einem Geschwindigkeitsgewinn führen.")
#define BACK_BUFFER_FORMAT_DESCRIPTION      ("Bildpufferformat:\r\n\r\nDas Bildpufferformat bestimmt, in welchem Format die Bilddaten gespeichert werden. Je größer die Zahlen, desto vollständiger ist das Farbspektrum abgedeckt.")
#define Z_STENCIL_BUFFER_FORMAT_DESCRIPTION ("Z-Stencil-Buffer-Format:\r\n\r\nWählen Sie hier das gewünschte Z-Stencil-Buffer-Format aus. Ein \"S\" im Formatnamen besagt, dass in diesem Format Platz für einen Stencil-Buffer ist, der für zusätzliche Grafikeffekte verwendet werden kann.\r\nJe höher die Zahl hinter dem \"D\", desto genauer kann die Tiefe eines 3D-Objekts gespeichert werden, was zu besserer Grafik führt.\r\nDie Zahl hinter dem \"S\" steht für die Anzahl der Bits für den Stencil-Buffer.")
#define MULTI_SAMPLING_TYPE_DESCRIPTION     ("Multi-Sampling-Typ:\r\n\r\nDer Multi-Sampling-Typ bestimmt, in wie vielen Durchgängen jedes Bild geglättet wird. Je höher diese Anzahl ist, desto weniger Kanten erscheinen im fertigen Bild und desto langsamer läuft die Grafikausgabe.")
#define MULTI_SAMPLING_QUALITY_DESCRIPTION  ("Multi-Sampling-Qualität:\r\n\r\nManche Adapter unterstützen Multi-Sampling in verschiedenen Qualitätsstufen. Je höher die Qualität, desto langsamer ist das Multi-Sampling und desto besser ist natürlich das Ergebnis.")
#define TNL_DESCRIPTION                     ("Transformation und Beleuchtung:\r\n\r\nViele Grafikkarten können selbst einen Großteil der Rechenarbeit erledigen, die vor dem eigentlichen Zeichnen des Bildes anfällt - Transformation und Beleuchtung.\r\nBei \"Hardware\" übernimmt die Hardware alle Operationen. Wird eine nicht unterstützt, ist sie nicht verfügbar.\r\nWählen Sie \"Software\", um alles per Software erledigen zu lassen, was natürlich langsamer ist.")

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

// Globale Variablen

SDirect3DParameters*    g_pDirect3DParameters;  // Zeiger auf Optionsstruktur

SDirect3DParameters     g_TempParameters;       // Temporäre Optionsstruktur

PDIRECT3D9              g_pD3DTemp = NULL;      // Temporäre "IDirect3D9"-Schnittstelle


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

// Prototyp der Dialogfunktion

INT_PTR CALLBACK D3DEnumDialogProc(HWND hDlg, unsigned int uiMsg, WPARAM WParam, LPARAM LParam);


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

// Diese Funktion wandelt ein Direct3D-Format in einen Text um.

tbResult GetFormatString(D3DFORMAT Format,
                         char* pcOut)
{
    // Parameter prüfen

    if(pcOut == NULL) TB_ERROR_NULL_POINTER("pcOut", TB_ERROR);


    // Format suchen und Beschreibung kopieren

    switch(Format)
    {
    case D3DFMT_R8G8B8:         strcpy(pcOut, "R8G8B8"); break;
    case D3DFMT_A8R8G8B8:       strcpy(pcOut, "A8R8G8B8"); break;
    case D3DFMT_X8R8G8B8:       strcpy(pcOut, "X8R8G8B8"); break;
    case D3DFMT_R5G6B5:         strcpy(pcOut, "R5G6B5"); break;
    case D3DFMT_X1R5G5B5:       strcpy(pcOut, "X1R5G5B5"); break;
    case D3DFMT_A1R5G5B5:       strcpy(pcOut, "A1R5G5B5"); break;
    case D3DFMT_A4R4G4B4:       strcpy(pcOut, "A4R4G4B4"); break;
    case D3DFMT_A2B10G10R10:    strcpy(pcOut, "A2B10G10R10"); break;
    case D3DFMT_A16B16G16R16:   strcpy(pcOut, "A16B16G16R16"); break;
    case D3DFMT_G16R16:         strcpy(pcOut, "G16R16"); break;
    case D3DFMT_A8P8:           strcpy(pcOut, "A8P8"); break;
    case D3DFMT_P8:             strcpy(pcOut, "P8"); break;
    case D3DFMT_L8:             strcpy(pcOut, "L8"); break;
    case D3DFMT_A8L8:           strcpy(pcOut, "A8L8"); break;
    case D3DFMT_A4L4:           strcpy(pcOut, "A4L4"); break;
    
    case D3DFMT_V8U8:           strcpy(pcOut, "V8U8"); break;
    case D3DFMT_Q8W8V8U8:       strcpy(pcOut, "Q8W8V8U8"); break;
    case D3DFMT_V16U16:         strcpy(pcOut, "V16U16"); break;
    case D3DFMT_Q16W16V16U16:   strcpy(pcOut, "Q16W16V16U16"); break;
    
    case D3DFMT_L6V5U5:         strcpy(pcOut, "L6V5U5"); break;
    case D3DFMT_X8L8V8U8:       strcpy(pcOut, "X8L8V8U8"); break;
    case D3DFMT_A2W10V10U10:    strcpy(pcOut, "A2W10V10U10"); break;
    case D3DFMT_L16:            strcpy(pcOut, "L16"); break;

    case D3DFMT_UYVY:           strcpy(pcOut, "UYVY"); break;
    case D3DFMT_YUY2:           strcpy(pcOut, "YUY2"); break;
    case D3DFMT_DXT1:           strcpy(pcOut, "DXT1"); break;
    case D3DFMT_DXT2:           strcpy(pcOut, "DXT2"); break;
    case D3DFMT_DXT3:           strcpy(pcOut, "DXT3"); break;
    case D3DFMT_DXT4:           strcpy(pcOut, "DXT4"); break;
    case D3DFMT_DXT5:           strcpy(pcOut, "DXT5"); break;
    case D3DFMT_MULTI2_ARGB8:   strcpy(pcOut, "MULTI2_ARGB8"); break;
    
    case D3DFMT_D16_LOCKABLE:   strcpy(pcOut, "D16_LOCKABLE"); break;
    case D3DFMT_D32:            strcpy(pcOut, "D32"); break;
    case D3DFMT_D32F_LOCKABLE:  strcpy(pcOut, "D32F_LOCKABLE"); break;
    case D3DFMT_D24FS8:         strcpy(pcOut, "D24FS8"); break;
    case D3DFMT_D15S1:          strcpy(pcOut, "D15S1"); break;
    case D3DFMT_D24S8:          strcpy(pcOut, "D24S8"); break;
    case D3DFMT_D16:            strcpy(pcOut, "D16"); break;
    case D3DFMT_D24X8:          strcpy(pcOut, "D24X8"); break;
    case D3DFMT_D24X4S4:        strcpy(pcOut, "D24X4S4"); break;
    case D3DFMT_VERTEXDATA:     strcpy(pcOut, "VERTEXDATA"); break;
    case D3DFMT_INDEX16:        strcpy(pcOut, "INDEX16"); break;
    case D3DFMT_INDEX32:        strcpy(pcOut, "INDEX32"); break;

    case D3DFMT_UNKNOWN:        strcpy(pcOut, "UNKNOWN"); break;

    default: strcpy(pcOut, "Unbekanntes Format"); break;
    }

    return TB_OK;
}

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

// Diese Funktion löscht die Daten einer ganzen Liste.

tbResult DeleteListData(HWND hDlg,
                        int iDialogItem)
{
    int     iNumElements;
    void*   pElementData;


    // Anzahl der Listenelemente abfragen

    iNumElements = (int)(SendDlgItemMessage(hDlg, iDialogItem, CB_GETCOUNT, 0, 0));
    if(iNumElements == CB_ERR) return TB_ERROR;

    // Alle Elemente durchgehen

    for(int iElement = 0; iElement < iNumElements; iElement++)
    {
        // Daten des Elements abfragen und freigeben

        pElementData = (void*)(SendDlgItemMessage(hDlg, iDialogItem, CB_GETITEMDATA, iElement, 0));
        if(pElementData != (void*)(CB_ERR)) TB_SAFE_MEMFREE(pElementData);
    }

    // Liste leeren

    SendDlgItemMessage(hDlg, iDialogItem, CB_RESETCONTENT, 0, 0);

    return TB_OK;
}

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

// Funktion zum Abzählen aller Adapter

tbResult EnumAdapters(HWND hDlg)
{
    int                     iNumAdapters;
    D3DADAPTER_IDENTIFIER9  AdapterInfo;

    
    // Liste löschen

    DeleteListData(hDlg, IDC_D3DS_ADAPTERS);

    // Anzahl der Adapter abfragen

    iNumAdapters = g_pD3DTemp->GetAdapterCount();

    // Jeden Adapter durchgehen

    for(int iAdapter = 0; iAdapter < iNumAdapters; iAdapter++)
    {
        // Informationen abfragen

        g_pD3DTemp->GetAdapterIdentifier(iAdapter, 0, &AdapterInfo);

        // Einen neuen Eintrag in der Adapterliste anlegen, mit

        // dem Namen des Adapters

        SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_ADDSTRING,
                           0, (LPARAM)(AdapterInfo.Description));
    }

    // Den ersten Adapter in der Liste auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Abzählen der Gerätetypen des gerade ausgewählten Adapters

tbResult EnumDeviceTypes(HWND hDlg)
{
    int         iSelectedAdapter;
    D3DDEVTYPE  aDeviceType[] = {D3DDEVTYPE_HAL, D3DDEVTYPE_SW, D3DDEVTYPE_REF};
    char*       apcDeviceType[] = {"Hardwarebeschleunigung", "Softwaretreiber", "Referenz-Rasterizer"};
    D3DCAPS9    Caps;
    int         iIndex;
    D3DDEVTYPE* pDeviceType;


    // Gewählten Adapter abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));

    // Gerätetypenliste leeren

    DeleteListData(hDlg, IDC_D3DS_DEVICE_TYPES);

    // Gerätetypen prüfen

    for(int iDeviceType = 0; iDeviceType < 3; iDeviceType++)
    {
        // Fähigkeiten abfragen. Falls das funktioniert, ist der Gerätetyp

        // verfügbar und er wird zur Liste hinzugefügt.

        if(SUCCEEDED(g_pD3DTemp->GetDeviceCaps(iSelectedAdapter, aDeviceType[iDeviceType], &Caps)))
        {
            iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_ADDSTRING,
                                              0, (LPARAM)(apcDeviceType[iDeviceType])));

            // Speicher für den Gerätetyp reservieren und ihn dem Listeneintrag zuweisen.

            // Nur anhand des Listenindexes lässt sich der Typ nicht bestimmen.

            pDeviceType = (D3DDEVTYPE*)(tbMemAlloc(sizeof(D3DDEVTYPE)));
            *pDeviceType = aDeviceType[iDeviceType];

            // Daten dem Listeneintrag zuweisen

            SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_SETITEMDATA,
                               iIndex, (LPARAM)(pDeviceType));

            if(!(Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT))
            {
                g_TempParameters.dwFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
                EnableWindow(GetDlgItem(hDlg, IDC_D3DS_HARDWARE_TNL), FALSE);
            }
        }
    }

    // Ersten Gerätetyp auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Abzählen der Videomodi des Adapters und des Gerätetyps

tbResult EnumVideoModes(HWND hDlg)
{
    int             iSelectedAdapter;
    int             iNumVideoModes;
    D3DFORMAT       aFormat[] = {D3DFMT_X8R8G8B8, D3DFMT_R8G8B8, D3DFMT_R5G6B5, D3DFMT_X1R5G5B5};
    D3DDISPLAYMODE* pVideoMode;
    char            acFormatString[256];
    char            acVideoModeString[256];
    int             iIndex;


    // Gewählten Adapter abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));

    // Liste der Videomodi leeren

    DeleteListData(hDlg, IDC_D3DS_VIDEO_MODES);

    // Anzahl der verfügbaren Videomodi erfragen.

    // Wir gehen dabei Format für Format durch.

    for(int iFormat = 0; iFormat < 4; iFormat++)
    {
        iNumVideoModes = g_pD3DTemp->GetAdapterModeCount(iSelectedAdapter, aFormat[iFormat]);
        
        // Jeden Videomodus durchgehen und Informationen über ihn abfragen

        for(int iVideoMode = 0; iVideoMode < iNumVideoModes; iVideoMode++)
        {
            // Speicher für diesen Videomodus reservieren

            pVideoMode = (D3DDISPLAYMODE*)(tbMemAlloc(sizeof(D3DDISPLAYMODE)));

            // Informationen abfragen

            g_pD3DTemp->EnumAdapterModes(iSelectedAdapter, aFormat[iFormat], iVideoMode, pVideoMode);

            // Textbeschreibung für diesen Videomodus generieren

            GetFormatString(pVideoMode->Format, acFormatString);
            if(pVideoMode->RefreshRate != 0) sprintf(acVideoModeString, "%d x %d (%s, %d Hz)", pVideoMode->Width, pVideoMode->Height, acFormatString, pVideoMode->RefreshRate);
            else sprintf(acVideoModeString, "%d x %d (%s)", pVideoMode->Width, pVideoMode->Height, acFormatString);
            
            // Einen neuen Listeneintrag anlegen

            iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_ADDSTRING,
                                              0, (LPARAM)(acVideoModeString)));

            // Daten dem Eintrag zuweisen

            SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_SETITEMDATA,
                               iIndex, (LPARAM)(pVideoMode));
        }
    }

    // Ersten Videomodus auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Diese Funktion listet alle kompatiblen Bildpufferformate auf

tbResult EnumBackBufferFormats(HWND hDlg)
{
    int             iSelectedAdapter;
    int             iSelectedDeviceType;
    D3DDEVTYPE*     pSelectedDeviceType;
    int             iSelectedVideoMode;
    D3DDISPLAYMODE* pSelectedVideoMode;
    BOOL            bWindowed;
    D3DDISPLAYMODE  CurrentVideoMode;
    BOOL            bHardwareFormatConversion;
    D3DFORMAT       aFormat[] = {D3DFMT_A2R10G10B10, D3DFMT_X8R8G8B8, D3DFMT_A8R8G8B8,
                                 D3DFMT_R5G6B5, D3DFMT_X1R5G5B5, D3DFMT_A1R5G5B5};
    char            acBackBufferString[256];
    int             iIndex;
    D3DFORMAT*      pFormat;


    // Gewählten Adapter, Gerätetyp, Videomodus und Fenster-/Vollbildmodus abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    iSelectedDeviceType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedDeviceType = (D3DDEVTYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iSelectedDeviceType, 0));
    iSelectedVideoMode = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pSelectedVideoMode = (D3DDISPLAYMODE*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iSelectedVideoMode, 0));
    bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;

    // Liste leeren

    DeleteListData(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS);

    // Aktuellen Videomodus abfragen

    g_pD3DTemp->GetAdapterDisplayMode(iSelectedAdapter, &CurrentVideoMode);

    // Jedes Format in der Liste durchgehen und prüfen, ob es verfügbar ist

    for(int iFormat = 0; iFormat < 6; iFormat++)
    {
        // Unterstützung abfragen

        if(SUCCEEDED(g_pD3DTemp->CheckDeviceFormat(iSelectedAdapter,
                                                   *pSelectedDeviceType,
                                                   bWindowed ? CurrentVideoMode.Format : pSelectedVideoMode->Format,
                                                   D3DUSAGE_RENDERTARGET,
                                                   D3DRTYPE_SURFACE,
                                                   aFormat[iFormat])))
        {
            // Prüfen, ob der Gerätetyp mit dieser Einstellung verfügbar ist

            if(SUCCEEDED(g_pD3DTemp->CheckDeviceType(iSelectedAdapter,
                                                     *pSelectedDeviceType,
                                                     bWindowed ? CurrentVideoMode.Format : pSelectedVideoMode->Format,
                                                     aFormat[iFormat],
                                                     bWindowed)))
            {
                // Wenn widersprüchliche Formate gewählt wurden, muss eine Formatkonvertierung

                // unterstützt sein.

                bHardwareFormatConversion = TRUE;
                if(bWindowed && aFormat[iFormat] != CurrentVideoMode.Format)
                {
                    if(FAILED(g_pD3DTemp->CheckDeviceFormatConversion(iSelectedAdapter,
                                                                      *pSelectedDeviceType,
                                                                      CurrentVideoMode.Format,
                                                                      aFormat[iFormat])))
                    {
                        // Hardwarekonvertierung ist nicht möglich!

                        bHardwareFormatConversion = FALSE;
                    }
                }

                if(bHardwareFormatConversion)
                {
                    // Formattext abfragen und Text generieren

                    GetFormatString(aFormat[iFormat], acBackBufferString);
                    if(bWindowed)
                    {
                        sprintf(acBackBufferString, "%s %s", acBackBufferString,
                                aFormat[iFormat] != CurrentVideoMode.Format ? "(Hardwarekonv.)" : "");
                    }

                    // Listeneintrag generieren

                    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_ADDSTRING,
                                                      0, (LPARAM)(acBackBufferString)));

                    // Dem Eintrag das Format zuweisen

                    pFormat = (D3DFORMAT*)(tbMemAlloc(sizeof(D3DFORMAT)));
                    *pFormat = aFormat[iFormat];
                    SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_SETITEMDATA,
                                       iIndex, (LPARAM)(pFormat));
                }
            }
        }
    }

    // Erstes Bildpufferformat auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Funktion zum Auflisten aller kompatiblen Z-Stencil-Buffer-Formate

tbResult EnumZStencilBufferFormats(HWND hDlg)
{
    int             iSelectedAdapter;
    int             iSelectedDeviceType;
    D3DDEVTYPE*     pSelectedDeviceType;
    int             iSelectedVideoMode;
    D3DDISPLAYMODE* pSelectedVideoMode;
    BOOL            bWindowed;
    int             iSelectedBackBufferFormat;
    D3DFORMAT*      pSelectedBackBufferFormat;
    D3DDISPLAYMODE  CurrentVideoMode;
    D3DFORMAT       aFormat[] = {D3DFMT_D32,
                                 D3DFMT_D24X8, D3DFMT_D24S8, D3DFMT_D24X4S4,
                                 D3DFMT_D16, D3DFMT_D16_LOCKABLE,
                                 D3DFMT_D15S1};
    char            acZStencilBufferString[256];
    int             iIndex;
    D3DFORMAT*      pFormat;


    // Gewählten Adapter, Gerätetyp, Videomodus, Fenster-/Vollbildmodus und Bildpufferformat abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    iSelectedDeviceType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedDeviceType = (D3DDEVTYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iSelectedDeviceType, 0));
    iSelectedVideoMode = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pSelectedVideoMode = (D3DDISPLAYMODE*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iSelectedVideoMode, 0));
    bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;
    iSelectedBackBufferFormat = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pSelectedBackBufferFormat = (D3DFORMAT*)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETITEMDATA, iSelectedBackBufferFormat, 0));

    // Liste leeren

    DeleteListData(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS);

    // Aktuellen Videomodus abfragen

    g_pD3DTemp->GetAdapterDisplayMode(iSelectedAdapter, &CurrentVideoMode);

    // Jedes Format in der Liste durchgehen und prüfen, ob es verfügbar ist

    for(int iFormat = 0; iFormat < 7; iFormat++)
    {
        // Unterstützung abfragen

        if(SUCCEEDED(g_pD3DTemp->CheckDeviceFormat(iSelectedAdapter,
                                                   *pSelectedDeviceType,
                                                   bWindowed ? CurrentVideoMode.Format
                                                               : pSelectedVideoMode->Format,
                                                   D3DUSAGE_DEPTHSTENCIL,
                                                   D3DRTYPE_SURFACE,
                                                   aFormat[iFormat])))
        {
            // Passt das Format zum Bildpufferformat?

            if(SUCCEEDED(g_pD3DTemp->CheckDepthStencilMatch(iSelectedAdapter,
                                                            *pSelectedDeviceType,
                                                            bWindowed ? CurrentVideoMode.Format
                                                                        : pSelectedVideoMode->Format,
                                                            *pSelectedBackBufferFormat,
                                                            aFormat[iFormat])))
            {
                // Formattext abfragen und Text generieren

                GetFormatString(aFormat[iFormat], acZStencilBufferString);

                // Listeneintrag generieren

                iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_ADDSTRING,
                                                  0, (LPARAM)(acZStencilBufferString)));

                // Dem Eintrag das Format zuweisen

                pFormat = (D3DFORMAT*)(tbMemAlloc(sizeof(D3DFORMAT)));
                *pFormat = aFormat[iFormat];
                SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_SETITEMDATA,
                                   iIndex, (LPARAM)(pFormat));
            }
        }
    }

    // Erstes Z-Stencil-Buffer-Format auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Auflisten der Multi-Sampling-Typen

tbResult EnumMultiSamplingTypes(HWND hDlg)
{
    int                     iSelectedAdapter;
    int                     iSelectedDeviceType;
    D3DDEVTYPE*             pSelectedDeviceType;
    int                     iSelectedVideoMode;
    D3DDISPLAYMODE*         pSelectedVideoMode;
    BOOL                    bWindowed;
    int                     iSelectedBackBufferFormat;
    D3DFORMAT*              pSelectedBackBufferFormat;
    int                     iSelectedZStencilBufferFormat;
    D3DFORMAT*              pSelectedZStencilBufferFormat;
    D3DMULTISAMPLE_TYPE     aMultiSamplingType[] = {D3DMULTISAMPLE_NONE,
                                                    D3DMULTISAMPLE_NONMASKABLE,
                                                    D3DMULTISAMPLE_2_SAMPLES,
                                                    D3DMULTISAMPLE_3_SAMPLES,
                                                    D3DMULTISAMPLE_4_SAMPLES,
                                                    D3DMULTISAMPLE_5_SAMPLES,
                                                    D3DMULTISAMPLE_6_SAMPLES,
                                                    D3DMULTISAMPLE_7_SAMPLES,
                                                    D3DMULTISAMPLE_8_SAMPLES,
                                                    D3DMULTISAMPLE_9_SAMPLES,
                                                    D3DMULTISAMPLE_10_SAMPLES,
                                                    D3DMULTISAMPLE_11_SAMPLES,
                                                    D3DMULTISAMPLE_12_SAMPLES,
                                                    D3DMULTISAMPLE_13_SAMPLES,
                                                    D3DMULTISAMPLE_14_SAMPLES,
                                                    D3DMULTISAMPLE_15_SAMPLES,
                                                    D3DMULTISAMPLE_16_SAMPLES};
    char                    acMultiSamplingTypeString[256];
    int                     iIndex;
    D3DMULTISAMPLE_TYPE*    pMultiSamplingType;
    DWORD                   dwNumQualities;


    // Gewählte Optionen abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    iSelectedDeviceType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedDeviceType = (D3DDEVTYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iSelectedDeviceType, 0));
    iSelectedVideoMode = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pSelectedVideoMode = (D3DDISPLAYMODE*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iSelectedVideoMode, 0));
    bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;
    iSelectedBackBufferFormat = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pSelectedBackBufferFormat = (D3DFORMAT*)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETITEMDATA, iSelectedBackBufferFormat, 0));
    iSelectedZStencilBufferFormat = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pSelectedZStencilBufferFormat = (D3DFORMAT*)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_GETITEMDATA, iSelectedZStencilBufferFormat, 0));

    // Liste leeren

    DeleteListData(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES);

    // Alle Multi-Sampling-Typen durchgehen und testen

    for(int iMultiSamplingType = 0; iMultiSamplingType < 17; iMultiSamplingType++)
    {
        // Kompatibilität mit dem Bildpufferformat prüfen

        if(SUCCEEDED(g_pD3DTemp->CheckDeviceMultiSampleType(iSelectedAdapter, 
                                                            *pSelectedDeviceType,
                                                            *pSelectedBackBufferFormat,
                                                            bWindowed,
                                                            aMultiSamplingType[iMultiSamplingType],
                                                            &dwNumQualities)))
        {
            if(dwNumQualities > 0)
            {
                // Kompatibilität mit dem Z-Stencil-Buffer-Format prüfen

                if(SUCCEEDED(g_pD3DTemp->CheckDeviceMultiSampleType(iSelectedAdapter, 
                                                                    *pSelectedDeviceType,
                                                                    *pSelectedZStencilBufferFormat,
                                                                    bWindowed,
                                                                    aMultiSamplingType[iMultiSamplingType],
                                                                    &dwNumQualities)))
                {
                    if(dwNumQualities > 0)
                    {
                        // Der Multi-Sampling-Typ ist OK!

                        if(iMultiSamplingType == 0) strcpy(acMultiSamplingTypeString, "Kein Multi-Sampling");
                        else if(iMultiSamplingType == 1) strcpy(acMultiSamplingTypeString, "Non-Maskable");
                        else sprintf(acMultiSamplingTypeString, "%d Samples", iMultiSamplingType);

                        pMultiSamplingType = (D3DMULTISAMPLE_TYPE*)(tbMemAlloc(sizeof(D3DMULTISAMPLE_TYPE)));
                        *pMultiSamplingType = aMultiSamplingType[iMultiSamplingType];

                        // Listeneintrag erzeugen

                        iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_ADDSTRING,
                                                          0, (LPARAM)(acMultiSamplingTypeString)));
                
                        // Dem Eintrag den Multi-Sampling-Typ zuweisen

                        SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_SETITEMDATA,
                                           iIndex, (LPARAM)(pMultiSamplingType));
                    }
                }
            }
        }
    }

    // Ersten Multi-Sampling-Typ auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Auflisten aller Multi-Sampling-Qualitätsstufen

tbResult EnumMultiSamplingQualities(HWND hDlg)
{
    int                     iSelectedAdapter;
    int                     iSelectedDeviceType;
    D3DDEVTYPE*             pSelectedDeviceType;
    int                     iSelectedVideoMode;
    D3DDISPLAYMODE*         pSelectedVideoMode;
    BOOL                    bWindowed;
    int                     iSelectedBackBufferFormat;
    D3DFORMAT*              pSelectedBackBufferFormat;
    int                     iSelectedMultiSamplingType;
    D3DMULTISAMPLE_TYPE*    pSelectedMultiSamplingType;
    DWORD                   dwNumMultiSamplingQualities;
    char                    acMultiSamplingQualityString[256];


    // Gewählte Optionen abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    iSelectedDeviceType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedDeviceType = (D3DDEVTYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iSelectedDeviceType, 0));
    iSelectedVideoMode = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pSelectedVideoMode = (D3DDISPLAYMODE*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iSelectedVideoMode, 0));
    bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;
    iSelectedBackBufferFormat = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pSelectedBackBufferFormat = (D3DFORMAT*)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETITEMDATA, iSelectedBackBufferFormat, 0));
    iSelectedMultiSamplingType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedMultiSamplingType = (D3DMULTISAMPLE_TYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_GETITEMDATA, iSelectedMultiSamplingType, 0));

    // Liste leeren

    DeleteListData(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES);

    // Anzahl der Qualitätsstufen abfragen

    g_pD3DTemp->CheckDeviceMultiSampleType(iSelectedAdapter, 
                                           *pSelectedDeviceType,
                                           *pSelectedBackBufferFormat,
                                           bWindowed,
                                           *pSelectedMultiSamplingType,
                                           &dwNumMultiSamplingQualities);

    // Listeneinträge erzeugen

    for(int iQuality = 0; iQuality < (int)(dwNumMultiSamplingQualities); iQuality++)
    {
        sprintf(acMultiSamplingQualityString, "Qualitätsstufe %d (von max. %d)",
                iQuality + 1, dwNumMultiSamplingQualities);
        SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES, CB_ADDSTRING,
                           0, (LPARAM)(acMultiSamplingQualityString));
    }

    // Höchste Qualitätsstufe auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES, CB_SETCURSEL,
                       dwNumMultiSamplingQualities - 1, 0);

    return TB_OK;
}

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

// Diese Funktion durchsucht eine Dialogliste nach einem bestimmten Element.

tbResult FindListElement(HWND hDlg,
                         int iDialogItem,
                         void* pData,
                         int iSizeOfData,
                         int* piOut)
{
    int     iNumElements;
    void*   pElementData;


    // Parameter prüfen

    if(pData == NULL) TB_ERROR_NULL_POINTER("pData", TB_ERROR);


    // Anzahl der Listenelemente abfragen

    iNumElements = (int)(SendDlgItemMessage(hDlg, iDialogItem, CB_GETCOUNT, 0, 0));
    if(iNumElements == CB_ERR) return TB_ERROR;

    // Alle Elemente durchgehen

    for(int iElement = 0; iElement < iNumElements; iElement++)
    {
        // Daten des Elements abfragen und mit den angegebenen Daten vergleichen

        pElementData = (void*)(SendDlgItemMessage(hDlg, iDialogItem, CB_GETITEMDATA, iElement, 0));
        if(pElementData != (void*)(CB_ERR))
        {
            if(!memcmp(pData, pElementData, iSizeOfData))
            {
                // Gefunden!

                *piOut = iElement;
                return TB_OK;
            }
        }
    }

    return TB_ERROR;
}

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

// Diese Funktion aktiviert in einer Dialogliste ein bestimmtes Element.

tbResult SelectListElement(HWND hDlg,
                           int iDialogItem,
                           void* pData,
                           int iSizeOfData,
                           int* piOut)
{
    int iIndex;

    // Nach dem Element suchen

    if(FindListElement(hDlg, iDialogItem, pData, iSizeOfData, &iIndex)) return TB_ERROR;

    // Element gefunden! Auswählen.

    SendDlgItemMessage(hDlg, iDialogItem, CB_SETCURSEL, iIndex, 0);
    if(piOut != NULL) *piOut = iIndex;

    return TB_OK;
}

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

// Diese Funktion speichert die Einstellungen in eine Struktur.

tbResult GetParameters(HWND hDlg,
                       SDirect3DParameters* pOut)
{
    int     iIndex;
    void*   pTemp;


    // Parameter prüfen

    if(pOut == NULL) TB_ERROR_NULL_POINTER("pOut", TB_ERROR);


    // Alle Parameter abfragen und speichern, vorher noch die Struktur leeren

    ZeroMemory(pOut, sizeof(SDirect3DParameters));
    
    // Adapter

    pOut->iAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    
    // Gerätetyp

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));    
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->DeviceType = *((D3DDEVTYPE*)(pTemp));

    // Fenster-/Vollbildmodus

    pOut->bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;

    // Videomodus

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->VideoMode = *((D3DDISPLAYMODE*)(pTemp));

    // Bildpufferformat

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->BackBufferFormat = *((D3DFORMAT*)(pTemp));

    // Z-Stencil-Buffer-Format

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->ZStencilBufferFormat = *((D3DFORMAT*)(pTemp));

    // Multi-Sampling-Typ

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_GETCURSEL, 0, 0));
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->MultiSamplingType = *((D3DMULTISAMPLE_TYPE*)(pTemp));

    // Multi-Sampling-Qualität

    pOut->dwMultiSamplingQuality = (DWORD)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES, CB_GETCURSEL, 0, 0));

    // Transformation und Beleuchtung

    if(IsDlgButtonChecked(hDlg, IDC_D3DS_HARDWARE_TNL) == BST_CHECKED) pOut->dwFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
    else pOut->dwFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;

    // Fähigkeiten abfragen

    g_pD3DTemp->GetDeviceCaps(pOut->iAdapter, pOut->DeviceType, &pOut->DeviceCaps);

    return TB_OK;
}

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

// Diese Funktion aktiviert die Einstellungen aus einer Struktur

// so weit wie möglich.

tbResult SetParameters(HWND hDlg,
                       SDirect3DParameters* pParameters)
{
    // Alle Parameter in der Liste suchen und/oder auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_SETCURSEL, pParameters->iAdapter, 0);
    EnumDeviceTypes(hDlg); SelectListElement(hDlg, IDC_D3DS_DEVICE_TYPES, &pParameters->DeviceType, sizeof(D3DDEVTYPE), NULL);
    CheckDlgButton(hDlg, IDC_D3DS_WINDOWED_MODE, pParameters->bWindowed ? BST_CHECKED : BST_UNCHECKED);
    CheckDlgButton(hDlg, IDC_D3DS_FULLSCREEN_MODE, !pParameters->bWindowed ? BST_CHECKED : BST_UNCHECKED);
    EnumVideoModes(hDlg); SelectListElement(hDlg, IDC_D3DS_VIDEO_MODES, &pParameters->VideoMode, sizeof(D3DDISPLAYMODE), NULL);
    EnumBackBufferFormats(hDlg); SelectListElement(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, &pParameters->BackBufferFormat, sizeof(D3DFORMAT), NULL);
    EnumZStencilBufferFormats(hDlg); SelectListElement(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, &pParameters->ZStencilBufferFormat, sizeof(D3DFORMAT), NULL);
    EnumMultiSamplingTypes(hDlg); SelectListElement(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, &pParameters->MultiSamplingType, sizeof(D3DMULTISAMPLE_TYPE), NULL);
    EnumMultiSamplingQualities(hDlg); if(pParameters->dwMultiSamplingQuality != -1) SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES, CB_SETCURSEL, pParameters->dwMultiSamplingQuality, 0);
    CheckDlgButton(hDlg, IDC_D3DS_HARDWARE_TNL, pParameters->dwFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING ? BST_CHECKED : BST_UNCHECKED);
    CheckDlgButton(hDlg, IDC_D3DS_SOFTWARE_TNL, pParameters->dwFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING ? BST_CHECKED : BST_UNCHECKED);

    return TB_OK;
}

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

// Dialogfunktion

INT_PTR CALLBACK D3DEnumDialogProc(HWND hDlg,
                                   unsigned int uiMsg,
                                   WPARAM WParam,
                                   LPARAM LParam)
{
    char    acFilename[256];
    FILE*   pFile;


    // Nachricht verarbeiten

    switch(uiMsg)
    {
    case WM_INITDIALOG:
        // Optionskästchen einstellen

        CheckDlgButton(hDlg, IDC_D3DS_FULLSCREEN_MODE, BST_CHECKED);
        CheckDlgButton(hDlg, IDC_D3DS_HARDWARE_TNL, BST_CHECKED);

        // Alles abzählen

        EnumAdapters(hDlg);
        EnumDeviceTypes(hDlg);
        EnumVideoModes(hDlg);
        EnumBackBufferFormats(hDlg);
        EnumZStencilBufferFormats(hDlg);
        EnumMultiSamplingTypes(hDlg);
        EnumMultiSamplingQualities(hDlg);
        break;

    case WM_CLOSE:
        // Code 2 zurückliefern; das bedeutet: Dialog abgebrochen

        EndDialog(hDlg, 2);
        break;

    case WM_DESTROY:
        // Aufräumen

        DeleteListData(hDlg, IDC_D3DS_ADAPTERS);
        DeleteListData(hDlg, IDC_D3DS_DEVICE_TYPES);
        DeleteListData(hDlg, IDC_D3DS_VIDEO_MODES);
        DeleteListData(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS);
        DeleteListData(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS);
        DeleteListData(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES);
        DeleteListData(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES);
        break;

    case WM_COMMAND:        
        switch(LOWORD(WParam))
        {
        case IDC_D3DS_ADAPTERS:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neuer Adapter gewählt! Gerätetypen neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumDeviceTypes(hDlg);
                EnumVideoModes(hDlg);
                EnumBackBufferFormats(hDlg);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, ADAPTER_DESCRIPTION);
            }
            break;

        case IDC_D3DS_DEVICE_TYPES:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neuer Gerätetyp gewählt! Videomodi neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumVideoModes(hDlg);
                EnumBackBufferFormats(hDlg);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, DEVICE_TYPE_DESCRIPTION);
            }
            break;

        case IDC_D3DS_WINDOWED_MODE:
        case IDC_D3DS_FULLSCREEN_MODE:
            if(HIWORD(WParam) == BN_CLICKED)
            {
                // Es wurde zwischen Fenster- und Vollbildmodus gewechselt!

                // Die Bildpufferformate müssen neu aufgelistet werden.

                GetParameters(hDlg, &g_TempParameters);
                EnumVideoModes(hDlg);
                EnumBackBufferFormats(hDlg);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }

            // Informationstext anzeigen

            SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, WINDOWED_FULLSCREEN_DESCRIPTION);
            break;

        case IDC_D3DS_VIDEO_MODES:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neuer Videomodus gewählt! Bildpufferformate neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumBackBufferFormats(hDlg);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, VIDEO_MODE_DESCRIPTION);
            }
            break;

        case IDC_D3DS_BACK_BUFFER_FORMATS:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neues Bildpufferformat gewählt! Z-Stencil-Buffer-Formate neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, BACK_BUFFER_FORMAT_DESCRIPTION);
            }
            break;

        case IDC_D3DS_Z_STENCIL_BUFFER_FORMATS:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neues Z-Stencil-Buffer-Format gewählt! Multi-Sampling-Typen neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, Z_STENCIL_BUFFER_FORMAT_DESCRIPTION);
            }
            break;

        case IDC_D3DS_MULTI_SAMPLING_TYPES:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neuer Multi-Sampling-Typ gewählt! Qualitätsstufen neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, MULTI_SAMPLING_TYPE_DESCRIPTION);
            }
            break;

        case IDC_D3DS_MULTI_SAMPLING_QUALITIES:
            if(HIWORD(WParam) != CBN_SELCHANGE)
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, MULTI_SAMPLING_QUALITY_DESCRIPTION);
            }
            break;

        case IDC_D3DS_HARDWARE_TNL:
        case IDC_D3DS_SOFTWARE_TNL:
            // Informationstext anzeigen

            SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, TNL_DESCRIPTION);
            break;

        case IDC_D3DS_SAVE:
            {
                strcpy(acFilename, "*.cfg");
                OPENFILENAME Filename = {sizeof(OPENFILENAME), hDlg, NULL, ".CFG-Dateien\0.cfg", NULL,
                                         0, 1, acFilename, 255, NULL, 0, NULL, ".CFG-Datei speichern",
                                         OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
                                         0, 1, ".cfg", 0, NULL, NULL};

                if(GetSaveFileName(&Filename))
                {
                    // Parameter abfragen und speichern

                    GetParameters(hDlg, &g_TempParameters);
                    pFile = fopen(acFilename, "wb");
                    fwrite(&g_TempParameters, sizeof(SDirect3DParameters), 1, pFile);
                    fclose(pFile);
                }
            }
            break;

        case IDC_D3DS_LOAD:
            {
                strcpy(acFilename, "*.cfg");
                OPENFILENAME Filename = {sizeof(OPENFILENAME), hDlg, NULL, ".CFG-Dateien\0.cfg\0Alle Dateien\0*.*", NULL,
                                         0, 1, acFilename, 255, NULL, 0, NULL, ".CFG-Datei laden",
                                         OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR,
                                         0, 1, ".cfg", 0, NULL, NULL};
                
                if(GetOpenFileName(&Filename))
                {
                    // Parameter einlesen und aktivieren

                    pFile = fopen(acFilename, "rb");
                    GetParameters(hDlg, &g_TempParameters);
                    fread(&g_TempParameters, sizeof(SDirect3DParameters), 1, pFile);
                    fclose(pFile);
                    SetParameters(hDlg, &g_TempParameters);
                }
            }
            break;

        case IDC_D3DS_OK:
            // Parameter abfragen und einen eventuellen Fehler vermeiden

            GetParameters(hDlg, g_pDirect3DParameters);
            if(g_pDirect3DParameters->DeviceType != D3DDEVTYPE_HAL &&
               !(g_pDirect3DParameters->dwFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING))
            {
                if(g_pDirect3DParameters->dwFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING) g_pDirect3DParameters->dwFlags ^= D3DCREATE_HARDWARE_VERTEXPROCESSING;
                g_pDirect3DParameters->dwFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
            }
            
            // Code 0 zurückliefern; das bedeutet: alles OK.

            EndDialog(hDlg, 0);
            break;

        case IDC_D3DS_CANCEL:
            // Code 2 zurückliefern; das bedeutet: Dialog abgebrochen

            EndDialog(hDlg, 2);
            break;
        }
        break;

    default:
        // Standardverarbeitung der Nachricht

        return FALSE;
        break;
    }

    // Nachricht wurde verarbeitet.

    return TRUE;
}

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

// Die Hauptfunktion: sie startet das Dialogfenster zur Auswahl aller

// Direct3D-Parameter (Adapter, Gerätetyp, Videomodus, ...) und speichert

// die Benutzerauswahl in einer Struktur vom Typ "SDirect3DParameters".

tbResult GetDirect3DParameters(SDirect3DParameters* pOut)
{
    int iResult;

    // Parameter prüfen

    if(pOut == NULL) TB_ERROR_NULL_POINTER("pOut", TB_ERROR);


    // Direct3D-Schnittstelle erzeugen. Sie wird vom Dialog zur

    // Auflistung benötigt.

    g_pD3DTemp = Direct3DCreate9(D3D_SDK_VERSION);
    if(g_pD3DTemp == NULL) return TB_ERROR;

    // Den globalen Zeiger auf die Struktur setzen, damit sie später

    // gefüllt werden kann

    g_pDirect3DParameters = pOut;

    // Dialogfenster aufrufen

    iResult = (int)(DialogBox(GetModuleHandle(NULL),
                              MAKEINTRESOURCE(IDD_DIRECT3D_SETTINGS),
                              NULL,
                              D3DEnumDialogProc));

    // Schnittstelle wieder freigeben

    TB_SAFE_RELEASE(g_pD3DTemp);

    // Rückgabewert des Dialogfensters auswerten

    if(iResult == 0) return TB_OK;                  // Alles OK!

    else if(iResult == 1) return TB_ERROR;          // Fehler!

    else /*if(iResult == 2)*/ return TB_CANCELED;   // Dialog abgebrochen

}

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




Und jetzt kommen die Fehler:


1>------ Build started: Project: Dialog Fenster, Configuration: Debug Win32 ------
1>Linking...
1>Direct3DEnum.obj : error LNK2019: unresolved external symbol "__declspec(dllimport) enum tbResult __cdecl tbWriteToLog(char *,...)" (__imp_?tbWriteToLog@@YA?AW4tbResult@@PADZZ) referenced in function "enum tbResult __cdecl GetFormatString(enum _D3DFORMAT,char *)" (?GetFormatString@@YA?AW4tbResult@@W4_D3DFORMAT@@PAD@Z)
1>Direct3DEnum.obj : error LNK2019: unresolved external symbol "__declspec(dllimport) char * __cdecl tbRemoveDir(char *)" (__imp_?tbRemoveDir@@YAPADPAD@Z) referenced in function "enum tbResult __cdecl GetFormatString(enum _D3DFORMAT,char *)" (?GetFormatString@@YA?AW4tbResult@@W4_D3DFORMAT@@PAD@Z)
1>Direct3DEnum.obj : error LNK2019: unresolved external symbol "__declspec(dllimport) enum tbResult __cdecl tbMemFree(void *)" (__imp_?tbMemFree@@YA?AW4tbResult@@PAX@Z) referenced in function "enum tbResult __cdecl DeleteListData(struct HWND__ *,int)" (?DeleteListData@@YA?AW4tbResult@@PAUHWND__@@H@Z)
1>Direct3DEnum.obj : error LNK2019: unresolved external symbol "__declspec(dllimport) void * __cdecl tbMemAlloc(int)" (__imp_?tbMemAlloc@@YAPAXH@Z) referenced in function "enum tbResult __cdecl EnumDeviceTypes(struct HWND__ *)" (?EnumDeviceTypes@@YA?AW4tbResult@@PAUHWND__@@@Z)
1>MSVCRTD.lib(crtexew.obj) : error LNK2019: unresolved external symbol _WinMain@16 referenced in function ___tmainCRTStartup
1>C:\Programme\Microsoft Visual Studio 9.0\Alle Projekte\Dialog Fenster\Debug\Dialog Fenster.exe : fatal error LNK1120: 5 unresolved externals
1>Build log was saved at "file://c:\Programme\Microsoft Visual Studio 9.0\Alle Projekte\Dialog Fenster\Dialog Fenster\Debug\BuildLog.htm"
1>Dialog Fenster - 6 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

C-/C++-Quelltext

1>------ Build started: Project: Dialog Fenster, Configuration: Debug Win32 ------
1>Linking...
1>MSVCRTD.lib(crtexew.obj) : error LNK2019: unresolved external symbol _WinMain@16 referenced in function ___tmainCRTStartup
1>C:\Programme\Microsoft Visual Studio 9.0\Alle Projekte\Dialog Fenster\Debug\Dialog Fenster.exe : fatal error LNK1120: 1 unresolved externals
1>Build log was saved at "file://c:\Programme\Microsoft Visual Studio 9.0\Alle Projekte\Dialog Fenster\Dialog Fenster\Debug\BuildLog.htm"
1>Dialog Fenster - 2 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

C-/C++-Quelltext

// Hilfsdatei DIRECT3DENUM.CPP

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

// Hier werden Funktionen zur Auflistung aller Direct3D-Adapter, deren

// Videomodi und sonstige Eigenschaften deklariert. Ein Dialogfenster

// präsentiert alle Möglichkeiten übersichtlich.


#define _DIRECT3DENUM_CPP
#include <Windows.h>
#include <TriBase.h>
#include <D3D9.h>
#include "Direct3DEnum.h"
#include "Allgemeines.h"

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE HPrevInstance,
                    char* pcCommandLine, int iShowCommand)
{
    MSG Message; // Nachricht


    
        




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

// Beschreibungstexte

#define ADAPTER_DESCRIPTION                 ("Adapter:\r\n\r\nWählen Sie aus der Liste den Adapter aus, mit dem das Programm arbeiten soll. Ein Adapter ist das gleiche wie eine Grafikkarte oder ein Grafikchip. Im Normalfall ist nur ein einziger Adapter auf Ihrem System installiert.")
#define DEVICE_TYPE_DESCRIPTION             ("Gerätetyp:\r\n\r\nDer Gerätetyp bestimmt, ob hardwarebeschleunigte Grafikausgabe zum Einsatz kommt (empfohlen). Eventuell gibt es noch weitere Möglichkeiten, die Sie nur dann in Erwägung ziehen sollten, wenn die Hardwarebeschleunigung nicht funktioniert.")
#define VIDEO_MODE_DESCRIPTION              ("Videomodus:\r\n\r\nDer Videomodus bestimmt die Auflösung des Monitors im Vollbildmodus oder die Größe des Fensters im Fenstermodus. Je höher die Auflösung, desto mehr Details sind erkennbar und desto langsamer läuft die Anwendung. 800 x 600 Pixel ist ein guter Wert.\r\nAchten Sie auch auf die eventuell angegebene Bildwiederholfrequenz! Je höher, desto flimmerfreier ist das Bild. Im Fenstermodus spielen Format und Bildwiederholfrequenz keine Rolle - sie werden vom aktuellen Videomodus übernommen.")
#define WINDOWED_FULLSCREEN_DESCRIPTION     ("Fenster-/Vollbildmodus:\r\n\r\nWählen Sie \"Fenstermodus\", damit das Programm in einem Fenster läuft. Sie können so einfacher zwischen Anwendungen wechseln. Der Vollbildmodus überlässt der Anwendung mehr Möglichkeiten und kann zu einem Geschwindigkeitsgewinn führen.")
#define BACK_BUFFER_FORMAT_DESCRIPTION      ("Bildpufferformat:\r\n\r\nDas Bildpufferformat bestimmt, in welchem Format die Bilddaten gespeichert werden. Je größer die Zahlen, desto vollständiger ist das Farbspektrum abgedeckt.")
#define Z_STENCIL_BUFFER_FORMAT_DESCRIPTION ("Z-Stencil-Buffer-Format:\r\n\r\nWählen Sie hier das gewünschte Z-Stencil-Buffer-Format aus. Ein \"S\" im Formatnamen besagt, dass in diesem Format Platz für einen Stencil-Buffer ist, der für zusätzliche Grafikeffekte verwendet werden kann.\r\nJe höher die Zahl hinter dem \"D\", desto genauer kann die Tiefe eines 3D-Objekts gespeichert werden, was zu besserer Grafik führt.\r\nDie Zahl hinter dem \"S\" steht für die Anzahl der Bits für den Stencil-Buffer.")
#define MULTI_SAMPLING_TYPE_DESCRIPTION     ("Multi-Sampling-Typ:\r\n\r\nDer Multi-Sampling-Typ bestimmt, in wie vielen Durchgängen jedes Bild geglättet wird. Je höher diese Anzahl ist, desto weniger Kanten erscheinen im fertigen Bild und desto langsamer läuft die Grafikausgabe.")
#define MULTI_SAMPLING_QUALITY_DESCRIPTION  ("Multi-Sampling-Qualität:\r\n\r\nManche Adapter unterstützen Multi-Sampling in verschiedenen Qualitätsstufen. Je höher die Qualität, desto langsamer ist das Multi-Sampling und desto besser ist natürlich das Ergebnis.")
#define TNL_DESCRIPTION                     ("Transformation und Beleuchtung:\r\n\r\nViele Grafikkarten können selbst einen Großteil der Rechenarbeit erledigen, die vor dem eigentlichen Zeichnen des Bildes anfällt - Transformation und Beleuchtung.\r\nBei \"Hardware\" übernimmt die Hardware alle Operationen. Wird eine nicht unterstützt, ist sie nicht verfügbar.\r\nWählen Sie \"Software\", um alles per Software erledigen zu lassen, was natürlich langsamer ist.")

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

// Globale Variablen

SDirect3DParameters*    g_pDirect3DParameters;  // Zeiger auf Optionsstruktur

SDirect3DParameters     g_TempParameters;       // Temporäre Optionsstruktur

PDIRECT3D9              g_pD3DTemp = NULL;      // Temporäre "IDirect3D9"-Schnittstelle


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

// Prototyp der Dialogfunktion

INT_PTR CALLBACK D3DEnumDialogProc(HWND hDlg, unsigned int uiMsg, WPARAM WParam, LPARAM LParam);


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

// Diese Funktion wandelt ein Direct3D-Format in einen Text um.

tbResult GetFormatString(D3DFORMAT Format,
                         char* pcOut)
{
    // Parameter prüfen

    if(pcOut == NULL) TB_ERROR_NULL_POINTER("pcOut", TB_ERROR);


    // Format suchen und Beschreibung kopieren

    switch(Format)
    {
    case D3DFMT_R8G8B8:         strcpy(pcOut, "R8G8B8"); break;
    case D3DFMT_A8R8G8B8:       strcpy(pcOut, "A8R8G8B8"); break;
    case D3DFMT_X8R8G8B8:       strcpy(pcOut, "X8R8G8B8"); break;
    case D3DFMT_R5G6B5:         strcpy(pcOut, "R5G6B5"); break;
    case D3DFMT_X1R5G5B5:       strcpy(pcOut, "X1R5G5B5"); break;
    case D3DFMT_A1R5G5B5:       strcpy(pcOut, "A1R5G5B5"); break;
    case D3DFMT_A4R4G4B4:       strcpy(pcOut, "A4R4G4B4"); break;
    case D3DFMT_A2B10G10R10:    strcpy(pcOut, "A2B10G10R10"); break;
    case D3DFMT_A16B16G16R16:   strcpy(pcOut, "A16B16G16R16"); break;
    case D3DFMT_G16R16:         strcpy(pcOut, "G16R16"); break;
    case D3DFMT_A8P8:           strcpy(pcOut, "A8P8"); break;
    case D3DFMT_P8:             strcpy(pcOut, "P8"); break;
    case D3DFMT_L8:             strcpy(pcOut, "L8"); break;
    case D3DFMT_A8L8:           strcpy(pcOut, "A8L8"); break;
    case D3DFMT_A4L4:           strcpy(pcOut, "A4L4"); break;
    
    case D3DFMT_V8U8:           strcpy(pcOut, "V8U8"); break;
    case D3DFMT_Q8W8V8U8:       strcpy(pcOut, "Q8W8V8U8"); break;
    case D3DFMT_V16U16:         strcpy(pcOut, "V16U16"); break;
    case D3DFMT_Q16W16V16U16:   strcpy(pcOut, "Q16W16V16U16"); break;
    
    case D3DFMT_L6V5U5:         strcpy(pcOut, "L6V5U5"); break;
    case D3DFMT_X8L8V8U8:       strcpy(pcOut, "X8L8V8U8"); break;
    case D3DFMT_A2W10V10U10:    strcpy(pcOut, "A2W10V10U10"); break;
    case D3DFMT_L16:            strcpy(pcOut, "L16"); break;

    case D3DFMT_UYVY:           strcpy(pcOut, "UYVY"); break;
    case D3DFMT_YUY2:           strcpy(pcOut, "YUY2"); break;
    case D3DFMT_DXT1:           strcpy(pcOut, "DXT1"); break;
    case D3DFMT_DXT2:           strcpy(pcOut, "DXT2"); break;
    case D3DFMT_DXT3:           strcpy(pcOut, "DXT3"); break;
    case D3DFMT_DXT4:           strcpy(pcOut, "DXT4"); break;
    case D3DFMT_DXT5:           strcpy(pcOut, "DXT5"); break;
    case D3DFMT_MULTI2_ARGB8:   strcpy(pcOut, "MULTI2_ARGB8"); break;
    
    case D3DFMT_D16_LOCKABLE:   strcpy(pcOut, "D16_LOCKABLE"); break;
    case D3DFMT_D32:            strcpy(pcOut, "D32"); break;
    case D3DFMT_D32F_LOCKABLE:  strcpy(pcOut, "D32F_LOCKABLE"); break;
    case D3DFMT_D24FS8:         strcpy(pcOut, "D24FS8"); break;
    case D3DFMT_D15S1:          strcpy(pcOut, "D15S1"); break;
    case D3DFMT_D24S8:          strcpy(pcOut, "D24S8"); break;
    case D3DFMT_D16:            strcpy(pcOut, "D16"); break;
    case D3DFMT_D24X8:          strcpy(pcOut, "D24X8"); break;
    case D3DFMT_D24X4S4:        strcpy(pcOut, "D24X4S4"); break;
    case D3DFMT_VERTEXDATA:     strcpy(pcOut, "VERTEXDATA"); break;
    case D3DFMT_INDEX16:        strcpy(pcOut, "INDEX16"); break;
    case D3DFMT_INDEX32:        strcpy(pcOut, "INDEX32"); break;

    case D3DFMT_UNKNOWN:        strcpy(pcOut, "UNKNOWN"); break;

    default: strcpy(pcOut, "Unbekanntes Format"); break;
    }

    return TB_OK;
}

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

// Diese Funktion löscht die Daten einer ganzen Liste.

tbResult DeleteListData(HWND hDlg,
                        int iDialogItem)
{
    int     iNumElements;
    void*   pElementData;


    // Anzahl der Listenelemente abfragen

    iNumElements = (int)(SendDlgItemMessage(hDlg, iDialogItem, CB_GETCOUNT, 0, 0));
    if(iNumElements == CB_ERR) return TB_ERROR;

    // Alle Elemente durchgehen

    for(int iElement = 0; iElement < iNumElements; iElement++)
    {
        // Daten des Elements abfragen und freigeben

        pElementData = (void*)(SendDlgItemMessage(hDlg, iDialogItem, CB_GETITEMDATA, iElement, 0));
        if(pElementData != (void*)(CB_ERR)) TB_SAFE_MEMFREE(pElementData);
    }

    // Liste leeren

    SendDlgItemMessage(hDlg, iDialogItem, CB_RESETCONTENT, 0, 0);

    return TB_OK;
}

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

// Funktion zum Abzählen aller Adapter

tbResult EnumAdapters(HWND hDlg)
{
    int                     iNumAdapters;
    D3DADAPTER_IDENTIFIER9  AdapterInfo;

    
    // Liste löschen

    DeleteListData(hDlg, IDC_D3DS_ADAPTERS);

    // Anzahl der Adapter abfragen

    iNumAdapters = g_pD3DTemp->GetAdapterCount();

    // Jeden Adapter durchgehen

    for(int iAdapter = 0; iAdapter < iNumAdapters; iAdapter++)
    {
        // Informationen abfragen

        g_pD3DTemp->GetAdapterIdentifier(iAdapter, 0, &AdapterInfo);

        // Einen neuen Eintrag in der Adapterliste anlegen, mit

        // dem Namen des Adapters

        SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_ADDSTRING,
                           0, (LPARAM)(AdapterInfo.Description));
    }

    // Den ersten Adapter in der Liste auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Abzählen der Gerätetypen des gerade ausgewählten Adapters

tbResult EnumDeviceTypes(HWND hDlg)
{
    int         iSelectedAdapter;
    D3DDEVTYPE  aDeviceType[] = {D3DDEVTYPE_HAL, D3DDEVTYPE_SW, D3DDEVTYPE_REF};
    char*       apcDeviceType[] = {"Hardwarebeschleunigung", "Softwaretreiber", "Referenz-Rasterizer"};
    D3DCAPS9    Caps;
    int         iIndex;
    D3DDEVTYPE* pDeviceType;


    // Gewählten Adapter abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));

    // Gerätetypenliste leeren

    DeleteListData(hDlg, IDC_D3DS_DEVICE_TYPES);

    // Gerätetypen prüfen

    for(int iDeviceType = 0; iDeviceType < 3; iDeviceType++)
    {
        // Fähigkeiten abfragen. Falls das funktioniert, ist der Gerätetyp

        // verfügbar und er wird zur Liste hinzugefügt.

        if(SUCCEEDED(g_pD3DTemp->GetDeviceCaps(iSelectedAdapter, aDeviceType[iDeviceType], &Caps)))
        {
            iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_ADDSTRING,
                                              0, (LPARAM)(apcDeviceType[iDeviceType])));

            // Speicher für den Gerätetyp reservieren und ihn dem Listeneintrag zuweisen.

            // Nur anhand des Listenindexes lässt sich der Typ nicht bestimmen.

            pDeviceType = (D3DDEVTYPE*)(tbMemAlloc(sizeof(D3DDEVTYPE)));
            *pDeviceType = aDeviceType[iDeviceType];

            // Daten dem Listeneintrag zuweisen

            SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_SETITEMDATA,
                               iIndex, (LPARAM)(pDeviceType));

            if(!(Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT))
            {
                g_TempParameters.dwFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
                EnableWindow(GetDlgItem(hDlg, IDC_D3DS_HARDWARE_TNL), FALSE);
            }
        }
    }

    // Ersten Gerätetyp auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Abzählen der Videomodi des Adapters und des Gerätetyps

tbResult EnumVideoModes(HWND hDlg)
{
    int             iSelectedAdapter;
    int             iNumVideoModes;
    D3DFORMAT       aFormat[] = {D3DFMT_X8R8G8B8, D3DFMT_R8G8B8, D3DFMT_R5G6B5, D3DFMT_X1R5G5B5};
    D3DDISPLAYMODE* pVideoMode;
    char            acFormatString[256];
    char            acVideoModeString[256];
    int             iIndex;


    // Gewählten Adapter abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));

    // Liste der Videomodi leeren

    DeleteListData(hDlg, IDC_D3DS_VIDEO_MODES);

    // Anzahl der verfügbaren Videomodi erfragen.

    // Wir gehen dabei Format für Format durch.

    for(int iFormat = 0; iFormat < 4; iFormat++)
    {
        iNumVideoModes = g_pD3DTemp->GetAdapterModeCount(iSelectedAdapter, aFormat[iFormat]);
        
        // Jeden Videomodus durchgehen und Informationen über ihn abfragen

        for(int iVideoMode = 0; iVideoMode < iNumVideoModes; iVideoMode++)
        {
            // Speicher für diesen Videomodus reservieren

            pVideoMode = (D3DDISPLAYMODE*)(tbMemAlloc(sizeof(D3DDISPLAYMODE)));

            // Informationen abfragen

            g_pD3DTemp->EnumAdapterModes(iSelectedAdapter, aFormat[iFormat], iVideoMode, pVideoMode);

            // Textbeschreibung für diesen Videomodus generieren

            GetFormatString(pVideoMode->Format, acFormatString);
            if(pVideoMode->RefreshRate != 0) sprintf(acVideoModeString, "%d x %d (%s, %d Hz)", pVideoMode->Width, pVideoMode->Height, acFormatString, pVideoMode->RefreshRate);
            else sprintf(acVideoModeString, "%d x %d (%s)", pVideoMode->Width, pVideoMode->Height, acFormatString);
            
            // Einen neuen Listeneintrag anlegen

            iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_ADDSTRING,
                                              0, (LPARAM)(acVideoModeString)));

            // Daten dem Eintrag zuweisen

            SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_SETITEMDATA,
                               iIndex, (LPARAM)(pVideoMode));
        }
    }

    // Ersten Videomodus auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Diese Funktion listet alle kompatiblen Bildpufferformate auf

tbResult EnumBackBufferFormats(HWND hDlg)
{
    int             iSelectedAdapter;
    int             iSelectedDeviceType;
    D3DDEVTYPE*     pSelectedDeviceType;
    int             iSelectedVideoMode;
    D3DDISPLAYMODE* pSelectedVideoMode;
    BOOL            bWindowed;
    D3DDISPLAYMODE  CurrentVideoMode;
    BOOL            bHardwareFormatConversion;
    D3DFORMAT       aFormat[] = {D3DFMT_A2R10G10B10, D3DFMT_X8R8G8B8, D3DFMT_A8R8G8B8,
                                 D3DFMT_R5G6B5, D3DFMT_X1R5G5B5, D3DFMT_A1R5G5B5};
    char            acBackBufferString[256];
    int             iIndex;
    D3DFORMAT*      pFormat;


    // Gewählten Adapter, Gerätetyp, Videomodus und Fenster-/Vollbildmodus abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    iSelectedDeviceType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedDeviceType = (D3DDEVTYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iSelectedDeviceType, 0));
    iSelectedVideoMode = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pSelectedVideoMode = (D3DDISPLAYMODE*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iSelectedVideoMode, 0));
    bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;

    // Liste leeren

    DeleteListData(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS);

    // Aktuellen Videomodus abfragen

    g_pD3DTemp->GetAdapterDisplayMode(iSelectedAdapter, &CurrentVideoMode);

    // Jedes Format in der Liste durchgehen und prüfen, ob es verfügbar ist

    for(int iFormat = 0; iFormat < 6; iFormat++)
    {
        // Unterstützung abfragen

        if(SUCCEEDED(g_pD3DTemp->CheckDeviceFormat(iSelectedAdapter,
                                                   *pSelectedDeviceType,
                                                   bWindowed ? CurrentVideoMode.Format : pSelectedVideoMode->Format,
                                                   D3DUSAGE_RENDERTARGET,
                                                   D3DRTYPE_SURFACE,
                                                   aFormat[iFormat])))
        {
            // Prüfen, ob der Gerätetyp mit dieser Einstellung verfügbar ist

            if(SUCCEEDED(g_pD3DTemp->CheckDeviceType(iSelectedAdapter,
                                                     *pSelectedDeviceType,
                                                     bWindowed ? CurrentVideoMode.Format : pSelectedVideoMode->Format,
                                                     aFormat[iFormat],
                                                     bWindowed)))
            {
                // Wenn widersprüchliche Formate gewählt wurden, muss eine Formatkonvertierung

                // unterstützt sein.

                bHardwareFormatConversion = TRUE;
                if(bWindowed && aFormat[iFormat] != CurrentVideoMode.Format)
                {
                    if(FAILED(g_pD3DTemp->CheckDeviceFormatConversion(iSelectedAdapter,
                                                                      *pSelectedDeviceType,
                                                                      CurrentVideoMode.Format,
                                                                      aFormat[iFormat])))
                    {
                        // Hardwarekonvertierung ist nicht möglich!

                        bHardwareFormatConversion = FALSE;
                    }
                }

                if(bHardwareFormatConversion)
                {
                    // Formattext abfragen und Text generieren

                    GetFormatString(aFormat[iFormat], acBackBufferString);
                    if(bWindowed)
                    {
                        sprintf(acBackBufferString, "%s %s", acBackBufferString,
                                aFormat[iFormat] != CurrentVideoMode.Format ? "(Hardwarekonv.)" : "");
                    }

                    // Listeneintrag generieren

                    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_ADDSTRING,
                                                      0, (LPARAM)(acBackBufferString)));

                    // Dem Eintrag das Format zuweisen

                    pFormat = (D3DFORMAT*)(tbMemAlloc(sizeof(D3DFORMAT)));
                    *pFormat = aFormat[iFormat];
                    SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_SETITEMDATA,
                                       iIndex, (LPARAM)(pFormat));
                }
            }
        }
    }

    // Erstes Bildpufferformat auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Funktion zum Auflisten aller kompatiblen Z-Stencil-Buffer-Formate

tbResult EnumZStencilBufferFormats(HWND hDlg)
{
    int             iSelectedAdapter;
    int             iSelectedDeviceType;
    D3DDEVTYPE*     pSelectedDeviceType;
    int             iSelectedVideoMode;
    D3DDISPLAYMODE* pSelectedVideoMode;
    BOOL            bWindowed;
    int             iSelectedBackBufferFormat;
    D3DFORMAT*      pSelectedBackBufferFormat;
    D3DDISPLAYMODE  CurrentVideoMode;
    D3DFORMAT       aFormat[] = {D3DFMT_D32,
                                 D3DFMT_D24X8, D3DFMT_D24S8, D3DFMT_D24X4S4,
                                 D3DFMT_D16, D3DFMT_D16_LOCKABLE,
                                 D3DFMT_D15S1};
    char            acZStencilBufferString[256];
    int             iIndex;
    D3DFORMAT*      pFormat;


    // Gewählten Adapter, Gerätetyp, Videomodus, Fenster-/Vollbildmodus und Bildpufferformat abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    iSelectedDeviceType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedDeviceType = (D3DDEVTYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iSelectedDeviceType, 0));
    iSelectedVideoMode = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pSelectedVideoMode = (D3DDISPLAYMODE*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iSelectedVideoMode, 0));
    bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;
    iSelectedBackBufferFormat = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pSelectedBackBufferFormat = (D3DFORMAT*)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETITEMDATA, iSelectedBackBufferFormat, 0));

    // Liste leeren

    DeleteListData(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS);

    // Aktuellen Videomodus abfragen

    g_pD3DTemp->GetAdapterDisplayMode(iSelectedAdapter, &CurrentVideoMode);

    // Jedes Format in der Liste durchgehen und prüfen, ob es verfügbar ist

    for(int iFormat = 0; iFormat < 7; iFormat++)
    {
        // Unterstützung abfragen

        if(SUCCEEDED(g_pD3DTemp->CheckDeviceFormat(iSelectedAdapter,
                                                   *pSelectedDeviceType,
                                                   bWindowed ? CurrentVideoMode.Format
                                                               : pSelectedVideoMode->Format,
                                                   D3DUSAGE_DEPTHSTENCIL,
                                                   D3DRTYPE_SURFACE,
                                                   aFormat[iFormat])))
        {
            // Passt das Format zum Bildpufferformat?

            if(SUCCEEDED(g_pD3DTemp->CheckDepthStencilMatch(iSelectedAdapter,
                                                            *pSelectedDeviceType,
                                                            bWindowed ? CurrentVideoMode.Format
                                                                        : pSelectedVideoMode->Format,
                                                            *pSelectedBackBufferFormat,
                                                            aFormat[iFormat])))
            {
                // Formattext abfragen und Text generieren

                GetFormatString(aFormat[iFormat], acZStencilBufferString);

                // Listeneintrag generieren

                iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_ADDSTRING,
                                                  0, (LPARAM)(acZStencilBufferString)));

                // Dem Eintrag das Format zuweisen

                pFormat = (D3DFORMAT*)(tbMemAlloc(sizeof(D3DFORMAT)));
                *pFormat = aFormat[iFormat];
                SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_SETITEMDATA,
                                   iIndex, (LPARAM)(pFormat));
            }
        }
    }

    // Erstes Z-Stencil-Buffer-Format auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Auflisten der Multi-Sampling-Typen

tbResult EnumMultiSamplingTypes(HWND hDlg)
{
    int                     iSelectedAdapter;
    int                     iSelectedDeviceType;
    D3DDEVTYPE*             pSelectedDeviceType;
    int                     iSelectedVideoMode;
    D3DDISPLAYMODE*         pSelectedVideoMode;
    BOOL                    bWindowed;
    int                     iSelectedBackBufferFormat;
    D3DFORMAT*              pSelectedBackBufferFormat;
    int                     iSelectedZStencilBufferFormat;
    D3DFORMAT*              pSelectedZStencilBufferFormat;
    D3DMULTISAMPLE_TYPE     aMultiSamplingType[] = {D3DMULTISAMPLE_NONE,
                                                    D3DMULTISAMPLE_NONMASKABLE,
                                                    D3DMULTISAMPLE_2_SAMPLES,
                                                    D3DMULTISAMPLE_3_SAMPLES,
                                                    D3DMULTISAMPLE_4_SAMPLES,
                                                    D3DMULTISAMPLE_5_SAMPLES,
                                                    D3DMULTISAMPLE_6_SAMPLES,
                                                    D3DMULTISAMPLE_7_SAMPLES,
                                                    D3DMULTISAMPLE_8_SAMPLES,
                                                    D3DMULTISAMPLE_9_SAMPLES,
                                                    D3DMULTISAMPLE_10_SAMPLES,
                                                    D3DMULTISAMPLE_11_SAMPLES,
                                                    D3DMULTISAMPLE_12_SAMPLES,
                                                    D3DMULTISAMPLE_13_SAMPLES,
                                                    D3DMULTISAMPLE_14_SAMPLES,
                                                    D3DMULTISAMPLE_15_SAMPLES,
                                                    D3DMULTISAMPLE_16_SAMPLES};
    char                    acMultiSamplingTypeString[256];
    int                     iIndex;
    D3DMULTISAMPLE_TYPE*    pMultiSamplingType;
    DWORD                   dwNumQualities;


    // Gewählte Optionen abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    iSelectedDeviceType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedDeviceType = (D3DDEVTYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iSelectedDeviceType, 0));
    iSelectedVideoMode = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pSelectedVideoMode = (D3DDISPLAYMODE*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iSelectedVideoMode, 0));
    bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;
    iSelectedBackBufferFormat = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pSelectedBackBufferFormat = (D3DFORMAT*)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETITEMDATA, iSelectedBackBufferFormat, 0));
    iSelectedZStencilBufferFormat = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pSelectedZStencilBufferFormat = (D3DFORMAT*)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_GETITEMDATA, iSelectedZStencilBufferFormat, 0));

    // Liste leeren

    DeleteListData(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES);

    // Alle Multi-Sampling-Typen durchgehen und testen

    for(int iMultiSamplingType = 0; iMultiSamplingType < 17; iMultiSamplingType++)
    {
        // Kompatibilität mit dem Bildpufferformat prüfen

        if(SUCCEEDED(g_pD3DTemp->CheckDeviceMultiSampleType(iSelectedAdapter, 
                                                            *pSelectedDeviceType,
                                                            *pSelectedBackBufferFormat,
                                                            bWindowed,
                                                            aMultiSamplingType[iMultiSamplingType],
                                                            &dwNumQualities)))
        {
            if(dwNumQualities > 0)
            {
                // Kompatibilität mit dem Z-Stencil-Buffer-Format prüfen

                if(SUCCEEDED(g_pD3DTemp->CheckDeviceMultiSampleType(iSelectedAdapter, 
                                                                    *pSelectedDeviceType,
                                                                    *pSelectedZStencilBufferFormat,
                                                                    bWindowed,
                                                                    aMultiSamplingType[iMultiSamplingType],
                                                                    &dwNumQualities)))
                {
                    if(dwNumQualities > 0)
                    {
                        // Der Multi-Sampling-Typ ist OK!

                        if(iMultiSamplingType == 0) strcpy(acMultiSamplingTypeString, "Kein Multi-Sampling");
                        else if(iMultiSamplingType == 1) strcpy(acMultiSamplingTypeString, "Non-Maskable");
                        else sprintf(acMultiSamplingTypeString, "%d Samples", iMultiSamplingType);

                        pMultiSamplingType = (D3DMULTISAMPLE_TYPE*)(tbMemAlloc(sizeof(D3DMULTISAMPLE_TYPE)));
                        *pMultiSamplingType = aMultiSamplingType[iMultiSamplingType];

                        // Listeneintrag erzeugen

                        iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_ADDSTRING,
                                                          0, (LPARAM)(acMultiSamplingTypeString)));
                
                        // Dem Eintrag den Multi-Sampling-Typ zuweisen

                        SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_SETITEMDATA,
                                           iIndex, (LPARAM)(pMultiSamplingType));
                    }
                }
            }
        }
    }

    // Ersten Multi-Sampling-Typ auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_SETCURSEL, 0, 0);

    return TB_OK;
}

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

// Auflisten aller Multi-Sampling-Qualitätsstufen

tbResult EnumMultiSamplingQualities(HWND hDlg)
{
    int                     iSelectedAdapter;
    int                     iSelectedDeviceType;
    D3DDEVTYPE*             pSelectedDeviceType;
    int                     iSelectedVideoMode;
    D3DDISPLAYMODE*         pSelectedVideoMode;
    BOOL                    bWindowed;
    int                     iSelectedBackBufferFormat;
    D3DFORMAT*              pSelectedBackBufferFormat;
    int                     iSelectedMultiSamplingType;
    D3DMULTISAMPLE_TYPE*    pSelectedMultiSamplingType;
    DWORD                   dwNumMultiSamplingQualities;
    char                    acMultiSamplingQualityString[256];


    // Gewählte Optionen abfragen

    iSelectedAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    iSelectedDeviceType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedDeviceType = (D3DDEVTYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iSelectedDeviceType, 0));
    iSelectedVideoMode = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pSelectedVideoMode = (D3DDISPLAYMODE*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iSelectedVideoMode, 0));
    bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;
    iSelectedBackBufferFormat = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pSelectedBackBufferFormat = (D3DFORMAT*)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETITEMDATA, iSelectedBackBufferFormat, 0));
    iSelectedMultiSamplingType = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_GETCURSEL, 0, 0));
    pSelectedMultiSamplingType = (D3DMULTISAMPLE_TYPE*)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_GETITEMDATA, iSelectedMultiSamplingType, 0));

    // Liste leeren

    DeleteListData(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES);

    // Anzahl der Qualitätsstufen abfragen

    g_pD3DTemp->CheckDeviceMultiSampleType(iSelectedAdapter, 
                                           *pSelectedDeviceType,
                                           *pSelectedBackBufferFormat,
                                           bWindowed,
                                           *pSelectedMultiSamplingType,
                                           &dwNumMultiSamplingQualities);

    // Listeneinträge erzeugen

    for(int iQuality = 0; iQuality < (int)(dwNumMultiSamplingQualities); iQuality++)
    {
        sprintf(acMultiSamplingQualityString, "Qualitätsstufe %d (von max. %d)",
                iQuality + 1, dwNumMultiSamplingQualities);
        SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES, CB_ADDSTRING,
                           0, (LPARAM)(acMultiSamplingQualityString));
    }

    // Höchste Qualitätsstufe auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES, CB_SETCURSEL,
                       dwNumMultiSamplingQualities - 1, 0);

    return TB_OK;
}

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

// Diese Funktion durchsucht eine Dialogliste nach einem bestimmten Element.

tbResult FindListElement(HWND hDlg,
                         int iDialogItem,
                         void* pData,
                         int iSizeOfData,
                         int* piOut)
{
    int     iNumElements;
    void*   pElementData;


    // Parameter prüfen

    if(pData == NULL) TB_ERROR_NULL_POINTER("pData", TB_ERROR);


    // Anzahl der Listenelemente abfragen

    iNumElements = (int)(SendDlgItemMessage(hDlg, iDialogItem, CB_GETCOUNT, 0, 0));
    if(iNumElements == CB_ERR) return TB_ERROR;

    // Alle Elemente durchgehen

    for(int iElement = 0; iElement < iNumElements; iElement++)
    {
        // Daten des Elements abfragen und mit den angegebenen Daten vergleichen

        pElementData = (void*)(SendDlgItemMessage(hDlg, iDialogItem, CB_GETITEMDATA, iElement, 0));
        if(pElementData != (void*)(CB_ERR))
        {
            if(!memcmp(pData, pElementData, iSizeOfData))
            {
                // Gefunden!

                *piOut = iElement;
                return TB_OK;
            }
        }
    }

    return TB_ERROR;
}

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

// Diese Funktion aktiviert in einer Dialogliste ein bestimmtes Element.

tbResult SelectListElement(HWND hDlg,
                           int iDialogItem,
                           void* pData,
                           int iSizeOfData,
                           int* piOut)
{
    int iIndex;

    // Nach dem Element suchen

    if(FindListElement(hDlg, iDialogItem, pData, iSizeOfData, &iIndex)) return TB_ERROR;

    // Element gefunden! Auswählen.

    SendDlgItemMessage(hDlg, iDialogItem, CB_SETCURSEL, iIndex, 0);
    if(piOut != NULL) *piOut = iIndex;

    return TB_OK;
}

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

// Diese Funktion speichert die Einstellungen in eine Struktur.

tbResult GetParameters(HWND hDlg,
                       SDirect3DParameters* pOut)
{
    int     iIndex;
    void*   pTemp;


    // Parameter prüfen

    if(pOut == NULL) TB_ERROR_NULL_POINTER("pOut", TB_ERROR);


    // Alle Parameter abfragen und speichern, vorher noch die Struktur leeren

    ZeroMemory(pOut, sizeof(SDirect3DParameters));
    
    // Adapter

    pOut->iAdapter = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_GETCURSEL, 0, 0));
    
    // Gerätetyp

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETCURSEL, 0, 0));    
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_DEVICE_TYPES, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->DeviceType = *((D3DDEVTYPE*)(pTemp));

    // Fenster-/Vollbildmodus

    pOut->bWindowed = IsDlgButtonChecked(hDlg, IDC_D3DS_WINDOWED_MODE) == BST_CHECKED;

    // Videomodus

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETCURSEL, 0, 0));
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_VIDEO_MODES, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->VideoMode = *((D3DDISPLAYMODE*)(pTemp));

    // Bildpufferformat

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->BackBufferFormat = *((D3DFORMAT*)(pTemp));

    // Z-Stencil-Buffer-Format

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_GETCURSEL, 0, 0));
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->ZStencilBufferFormat = *((D3DFORMAT*)(pTemp));

    // Multi-Sampling-Typ

    iIndex = (int)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_GETCURSEL, 0, 0));
    pTemp = ((void*)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, CB_GETITEMDATA, iIndex, 0)));
    if(pTemp != (void*)(CB_ERR)) pOut->MultiSamplingType = *((D3DMULTISAMPLE_TYPE*)(pTemp));

    // Multi-Sampling-Qualität

    pOut->dwMultiSamplingQuality = (DWORD)(SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES, CB_GETCURSEL, 0, 0));

    // Transformation und Beleuchtung

    if(IsDlgButtonChecked(hDlg, IDC_D3DS_HARDWARE_TNL) == BST_CHECKED) pOut->dwFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
    else pOut->dwFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;

    // Fähigkeiten abfragen

    g_pD3DTemp->GetDeviceCaps(pOut->iAdapter, pOut->DeviceType, &pOut->DeviceCaps);

    return TB_OK;
}

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

// Diese Funktion aktiviert die Einstellungen aus einer Struktur

// so weit wie möglich.

tbResult SetParameters(HWND hDlg,
                       SDirect3DParameters* pParameters)
{
    // Alle Parameter in der Liste suchen und/oder auswählen

    SendDlgItemMessage(hDlg, IDC_D3DS_ADAPTERS, CB_SETCURSEL, pParameters->iAdapter, 0);
    EnumDeviceTypes(hDlg); SelectListElement(hDlg, IDC_D3DS_DEVICE_TYPES, &pParameters->DeviceType, sizeof(D3DDEVTYPE), NULL);
    CheckDlgButton(hDlg, IDC_D3DS_WINDOWED_MODE, pParameters->bWindowed ? BST_CHECKED : BST_UNCHECKED);
    CheckDlgButton(hDlg, IDC_D3DS_FULLSCREEN_MODE, !pParameters->bWindowed ? BST_CHECKED : BST_UNCHECKED);
    EnumVideoModes(hDlg); SelectListElement(hDlg, IDC_D3DS_VIDEO_MODES, &pParameters->VideoMode, sizeof(D3DDISPLAYMODE), NULL);
    EnumBackBufferFormats(hDlg); SelectListElement(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS, &pParameters->BackBufferFormat, sizeof(D3DFORMAT), NULL);
    EnumZStencilBufferFormats(hDlg); SelectListElement(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS, &pParameters->ZStencilBufferFormat, sizeof(D3DFORMAT), NULL);
    EnumMultiSamplingTypes(hDlg); SelectListElement(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES, &pParameters->MultiSamplingType, sizeof(D3DMULTISAMPLE_TYPE), NULL);
    EnumMultiSamplingQualities(hDlg); if(pParameters->dwMultiSamplingQuality != -1) SendDlgItemMessage(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES, CB_SETCURSEL, pParameters->dwMultiSamplingQuality, 0);
    CheckDlgButton(hDlg, IDC_D3DS_HARDWARE_TNL, pParameters->dwFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING ? BST_CHECKED : BST_UNCHECKED);
    CheckDlgButton(hDlg, IDC_D3DS_SOFTWARE_TNL, pParameters->dwFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING ? BST_CHECKED : BST_UNCHECKED);

    return TB_OK;
}

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

// Dialogfunktion

INT_PTR CALLBACK D3DEnumDialogProc(HWND hDlg,
                                   unsigned int uiMsg,
                                   WPARAM WParam,
                                   LPARAM LParam)
{
    char    acFilename[256];
    FILE*   pFile;


    // Nachricht verarbeiten

    switch(uiMsg)
    {
    case WM_INITDIALOG:
        // Optionskästchen einstellen

        CheckDlgButton(hDlg, IDC_D3DS_FULLSCREEN_MODE, BST_CHECKED);
        CheckDlgButton(hDlg, IDC_D3DS_HARDWARE_TNL, BST_CHECKED);

        // Alles abzählen

        EnumAdapters(hDlg);
        EnumDeviceTypes(hDlg);
        EnumVideoModes(hDlg);
        EnumBackBufferFormats(hDlg);
        EnumZStencilBufferFormats(hDlg);
        EnumMultiSamplingTypes(hDlg);
        EnumMultiSamplingQualities(hDlg);
        break;

    case WM_CLOSE:
        // Code 2 zurückliefern; das bedeutet: Dialog abgebrochen

        EndDialog(hDlg, 2);
        break;

    case WM_DESTROY:
        // Aufräumen

        DeleteListData(hDlg, IDC_D3DS_ADAPTERS);
        DeleteListData(hDlg, IDC_D3DS_DEVICE_TYPES);
        DeleteListData(hDlg, IDC_D3DS_VIDEO_MODES);
        DeleteListData(hDlg, IDC_D3DS_BACK_BUFFER_FORMATS);
        DeleteListData(hDlg, IDC_D3DS_Z_STENCIL_BUFFER_FORMATS);
        DeleteListData(hDlg, IDC_D3DS_MULTI_SAMPLING_TYPES);
        DeleteListData(hDlg, IDC_D3DS_MULTI_SAMPLING_QUALITIES);
        break;

    case WM_COMMAND:        
        switch(LOWORD(WParam))
        {
        case IDC_D3DS_ADAPTERS:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neuer Adapter gewählt! Gerätetypen neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumDeviceTypes(hDlg);
                EnumVideoModes(hDlg);
                EnumBackBufferFormats(hDlg);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, ADAPTER_DESCRIPTION);
            }
            break;

        case IDC_D3DS_DEVICE_TYPES:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neuer Gerätetyp gewählt! Videomodi neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumVideoModes(hDlg);
                EnumBackBufferFormats(hDlg);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, DEVICE_TYPE_DESCRIPTION);
            }
            break;

        case IDC_D3DS_WINDOWED_MODE:
        case IDC_D3DS_FULLSCREEN_MODE:
            if(HIWORD(WParam) == BN_CLICKED)
            {
                // Es wurde zwischen Fenster- und Vollbildmodus gewechselt!

                // Die Bildpufferformate müssen neu aufgelistet werden.

                GetParameters(hDlg, &g_TempParameters);
                EnumVideoModes(hDlg);
                EnumBackBufferFormats(hDlg);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }

            // Informationstext anzeigen

            SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, WINDOWED_FULLSCREEN_DESCRIPTION);
            break;

        case IDC_D3DS_VIDEO_MODES:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neuer Videomodus gewählt! Bildpufferformate neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumBackBufferFormats(hDlg);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, VIDEO_MODE_DESCRIPTION);
            }
            break;

        case IDC_D3DS_BACK_BUFFER_FORMATS:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neues Bildpufferformat gewählt! Z-Stencil-Buffer-Formate neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumZStencilBufferFormats(hDlg);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, BACK_BUFFER_FORMAT_DESCRIPTION);
            }
            break;

        case IDC_D3DS_Z_STENCIL_BUFFER_FORMATS:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neues Z-Stencil-Buffer-Format gewählt! Multi-Sampling-Typen neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumMultiSamplingTypes(hDlg);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, Z_STENCIL_BUFFER_FORMAT_DESCRIPTION);
            }
            break;

        case IDC_D3DS_MULTI_SAMPLING_TYPES:
            if(HIWORD(WParam) == CBN_SELCHANGE)
            {
                // Es wurde ein neuer Multi-Sampling-Typ gewählt! Qualitätsstufen neu auflisten.

                GetParameters(hDlg, &g_TempParameters);
                EnumMultiSamplingQualities(hDlg);
                SetParameters(hDlg, &g_TempParameters);
            }
            else
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, MULTI_SAMPLING_TYPE_DESCRIPTION);
            }
            break;

        case IDC_D3DS_MULTI_SAMPLING_QUALITIES:
            if(HIWORD(WParam) != CBN_SELCHANGE)
            {
                // Informationstext anzeigen

                SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, MULTI_SAMPLING_QUALITY_DESCRIPTION);
            }
            break;

        case IDC_D3DS_HARDWARE_TNL:
        case IDC_D3DS_SOFTWARE_TNL:
            // Informationstext anzeigen

            SetDlgItemText(hDlg, IDC_D3DS_DESCRIPTION, TNL_DESCRIPTION);
            break;

        case IDC_D3DS_SAVE:
            {
                strcpy(acFilename, "*.cfg");
                OPENFILENAME Filename = {sizeof(OPENFILENAME), hDlg, NULL, ".CFG-Dateien\0.cfg", NULL,
                                         0, 1, acFilename, 255, NULL, 0, NULL, ".CFG-Datei speichern",
                                         OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
                                         0, 1, ".cfg", 0, NULL, NULL};

                if(GetSaveFileName(&Filename))
                {
                    // Parameter abfragen und speichern

                    GetParameters(hDlg, &g_TempParameters);
                    pFile = fopen(acFilename, "wb");
                    fwrite(&g_TempParameters, sizeof(SDirect3DParameters), 1, pFile);
                    fclose(pFile);
                }
            }
            break;

        case IDC_D3DS_LOAD:
            {
                strcpy(acFilename, "*.cfg");
                OPENFILENAME Filename = {sizeof(OPENFILENAME), hDlg, NULL, ".CFG-Dateien\0.cfg\0Alle Dateien\0*.*", NULL,
                                         0, 1, acFilename, 255, NULL, 0, NULL, ".CFG-Datei laden",
                                         OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR,
                                         0, 1, ".cfg", 0, NULL, NULL};
                
                if(GetOpenFileName(&Filename))
                {
                    // Parameter einlesen und aktivieren

                    pFile = fopen(acFilename, "rb");
                    GetParameters(hDlg, &g_TempParameters);
                    fread(&g_TempParameters, sizeof(SDirect3DParameters), 1, pFile);
                    fclose(pFile);
                    SetParameters(hDlg, &g_TempParameters);
                }
            }
            break;

        case IDC_D3DS_OK:
            // Parameter abfragen und einen eventuellen Fehler vermeiden

            GetParameters(hDlg, g_pDirect3DParameters);
            if(g_pDirect3DParameters->DeviceType != D3DDEVTYPE_HAL &&
               !(g_pDirect3DParameters->dwFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING))
            {
                if(g_pDirect3DParameters->dwFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING) g_pDirect3DParameters->dwFlags ^= D3DCREATE_HARDWARE_VERTEXPROCESSING;
                g_pDirect3DParameters->dwFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
            }
            
            // Code 0 zurückliefern; das bedeutet: alles OK.

            EndDialog(hDlg, 0);
            break;

        case IDC_D3DS_CANCEL:
            // Code 2 zurückliefern; das bedeutet: Dialog abgebrochen

            EndDialog(hDlg, 2);
            break;
        }
        break;

    default:
        // Standardverarbeitung der Nachricht

        return FALSE;
        break;
    }

    // Nachricht wurde verarbeitet.

    return TRUE;
}

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

// Die Hauptfunktion: sie startet das Dialogfenster zur Auswahl aller

// Direct3D-Parameter (Adapter, Gerätetyp, Videomodus, ...) und speichert

// die Benutzerauswahl in einer Struktur vom Typ "SDirect3DParameters".

tbResult GetDirect3DParameters(SDirect3DParameters* pOut)
{
    int iResult;

    // Parameter prüfen

    if(pOut == NULL) TB_ERROR_NULL_POINTER("pOut", TB_ERROR);


    // Direct3D-Schnittstelle erzeugen. Sie wird vom Dialog zur

    // Auflistung benötigt.

    g_pD3DTemp = Direct3DCreate9(D3D_SDK_VERSION);
    if(g_pD3DTemp == NULL) return TB_ERROR;

    // Den globalen Zeiger auf die Struktur setzen, damit sie später

    // gefüllt werden kann

    g_pDirect3DParameters = pOut;

    // Dialogfenster aufrufen

    iResult = (int)(DialogBox(GetModuleHandle(NULL),
                              MAKEINTRESOURCE(IDD_DIRECT3D_SETTINGS),
                              NULL,
                              D3DEnumDialogProc));

    // Schnittstelle wieder freigeben

    TB_SAFE_RELEASE(g_pD3DTemp);

    // Rückgabewert des Dialogfensters auswerten

    if(iResult == 0) return TB_OK;                  // Alles OK!

    else if(iResult == 1) return TB_ERROR;          // Fehler!

    else /*if(iResult == 2)*/ return TB_CANCELED;   // Dialog abgebrochen

}

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



// Nachrichtenschleife

    ZeroMemory(&Message, sizeof(MSG));
    while(Message.message != WM_QUIT)
    {
        // Eventuelle Nachrichten verarbeiten

        while(PeekMessage(&Message, NULL, 0, 0, PM_REMOVE))
        {
            Translate(&Message);
            Dispatch(&Message);
        }
    }
    return FALSE;
}