4. Code::Blocks und DirectX...

Code::Blocks und DirectX...

  • A

    So, habs jetzt irgendwie zusammengebracht, dass Code::Blocks mit dem 2003er Toolkit läuft. DirectX ist auch alles gelinkt / included. Trotzdem kommen solche Fehler (Code ist von nem Buch):

    -------------- Build: default in DirectX ---------------

main.cpp
main.cpp(28) : error C2059: syntax error : 'constant'
main.cpp(162) : error C2065: 'lpD3DFont' : undeclared identifier
main.cpp(162) : error C2227: left of '->DrawTextA' must point to class/struct/union
        type is ''unknown-type''
main.cpp(170) : error C2227: left of '->DrawTextA' must point to class/struct/union
        type is ''unknown-type''
main.cpp(170) : error C3861: 'lpD3DFont': identifier not found, even with argument-dependent lookup
main.cpp(245) : error C3861: 'lpD3DFont': identifier not found, even with argument-dependent lookup
main.cpp(255) : error C3861: 'lpD3DFont': identifier not found, even with argument-dependent lookup
main.cpp(257) : error C2227: left of '->Release' must point to class/struct/union
        type is ''unknown-type''
main.cpp(257) : error C3861: 'lpD3DFont': identifier not found, even with argument-dependent lookup
main.cpp(258) : error C3861: 'lpD3DFont': identifier not found, even with argument-dependent lookup
Process terminated with status 2 (0 minutes, 0 seconds)
10 errors, 0 warnings

    Was hab ich da schon wieder vergessen? 😞

    0
  • H

    zeig mal den code.
    und finde heraus, ob das, was links von "->DrawTextA" eine klasse oder ein struct ist.

    edit: aus den Fehlermeldungen geschlossen scheint es, dass links davon lpD3DFont steht. Diese Klasse ist dem Compiler aber nicht bekannt. Bist du wirklich sicher, dass alles richtig inkludiert ist und dass der Klassenname richtig geschrieben ist (Groß-/Kleinschreibung)?

    0
  • A

    Hier der Code, wie gesagt aus einem Buch 1:1 übernommen

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

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

// Anwendungsfenster erzeugen
HWND CreateMainWindow(HINSTANCE hInstance);

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

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

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

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

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

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

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

// Das Fensterhandle
HWND hWnd = 0;

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

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

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

    // Schrift erzeugen
    CreateD3DFont();

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

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

    // Freigeben der Objekte
    CleanUpDirect3D();

    // Rückgabewert an Windows
    return 0;
}

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

    // Klasse registrieren
    RegisterClassEx(&wndClass);

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

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

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

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

       case WM_PAINT:

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

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

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

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

               lpD3DDevice->BeginScene();

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

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

               lpD3DDevice->EndScene();

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

             break;

    }

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

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

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

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

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

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

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

   return TRUE;
}

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

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

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

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

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

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

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

    schau dir zeile 28(der erste vom compiler gemeldete fehler) mal GANZ genau an :p

    0
  • A

    Die chinesische Glückszahl ^^

    Warum können die Typen, die solche Bücher schreiben, nicht mal ihren Quelltext überprüfen? 😉

    Naja, ein Fehler bleibt noch:

    -------------- Build: default in DirectX ---------------

Linking executable: DirectX.exe
main.obj : error LNK2019: unresolved external symbol _D3DXCreateFontIndirectA@12 referenced in function "void __cdecl CreateD3DFont(void)" (?CreateD3DFont@@YAXXZ)
DirectX.exe : fatal error LNK1120: 1 unresolved externals
Process terminated with status 1120 (0 minutes, 0 seconds)
2 errors, 0 warnings

    Ich google noch ein bisschen, aber falls jemand die Lösung kennt, soll er bitte posten 😃

    EDIT: Unglaublich! Schaut euch mal das an:

    http://www.spieleprogrammierer.de/phpBB2/viewtopic.php?t=9620&sid=049e421582eaef2d8286e49f2e41fdd2

    http://www.jliforum.de/board/viewtopic.php?p=70198&sid=f52c5ddb159025c0bd8b3bf79afd69d0

    Das sind alles die QTs aus dem Buch das ich hab, das jliforum ist sogar das zum Buch gehörende Forum 😃

    0
  • A

    Habs geschafft mit

    #pragma comment(lib,"d3d9.lib")
    #pragma comment(lib,"d3dx9.lib")

    den Fehler wegzubekommen, aber jetzt hab ich noch den am Hals:

    -------------- Build: default in DirectX ---------------

main.cpp
Linking executable: DirectX.exe
main.obj : error LNK2019: unresolved external symbol _Direct3DCreate9@4 referenced in function "int __cdecl InitDirect3D(struct HWND__ *)" (?InitDirect3D@@YAHPAUHWND__@@@Z)
DirectX.exe : fatal error LNK1120: 1 unresolved externals
Process terminated with status 1120 (0 minutes, 1 seconds)
2 errors, 0 warnings
    0
  • A

    Haleluja! Es geht!

    Hab einfach nochmal ein Projekt erstellt und den QT dort reinkopiert.
    Wahrscheinlich lag der Fehler bei den #include's

    Danke an alle! 😃

    0
Anmelden zum Antworten