JLI Spieleprogrammierung Foren-Übersicht JLI Spieleprogrammierung

 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen 
 medals.php?sid=69266607d58410a85f23b7a48e56f27cMedaillen   RegistrierenRegistrieren   ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

LINKERFEHLER HIIILFEEEE!!!!!

 
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Fragen, Antworten und Kritik
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
magigman
Junior JLI'ler



Anmeldedatum: 25.09.2007
Beiträge: 87

Medaillen: Keine

BeitragVerfasst am: 21.05.2009, 15:57    Titel: LINKERFEHLER HIIILFEEEE!!!!! Antworten mit Zitat

ich habe folgenden Code:

CPP:
// Dieses Programm zeigt wie ein Sprite mit Hilfe von
// GetAsyncKeyState() bewegt werden werden kann. Die
// Bewegung ist jetzt fluessig. Ausserdem kann das Sprite
// mit LSHIFT und RSHIFT skaliert und mit SPACE rotiert werden.


// Headerdateien
#include "Direct3D.h"

// Anwendungsfenster erzeugen
HWND CreateMainWindow(HINSTANCE hInstance);

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

// Das Fensterhandle
HWND hWnd = 0;

// Instanz der Klasse CDirect3D
CDirect3D Direct3D;

// Dateiname des Sprite
const char* FILE_NAME = "SuperFlash.png";


// Sprite-Position
float g_x = 40.0f;
float g_y = 40.0f;


// Windows main-Funktion
int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{


    // 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(!Direct3D.Init(hWnd, FALSE))
    {
        return -1;
    }

    // Farbe die beim Loeschen verwendet werden soll
    Direct3D.SetClearColor(D3DCOLOR_XRGB(0, 0, 0));

    // Initialisierung
    LPD3DXSPRITE       lpSprite        = NULL;
    LPDIRECT3DDEVICE9  lpD3DDevice     = NULL;
    LPDIRECT3DTEXTURE9 lpSpriteTexture = NULL;

    // Skalierungsfaktor des Sprites
    float Scale    = 1.0f;

    // Rotation des Sprites
    float Rotation = 0.0f;

    // Neue Methode der CDirect3D-Klasse
    lpD3DDevice = Direct3D.GetDevice();

    // Textur laden, FILE_NAME enthaelt den Dateinamen
    D3DXCreateTextureFromFileEx(lpD3DDevice,
                                FILE_NAME,
                                128, 128,
                                1, 0,
                                D3DFMT_UNKNOWN,
                                D3DPOOL_MANAGED,
                                D3DX_FILTER_NONE,
                                D3DX_FILTER_NONE,
                                0xFFFF00FF,
                                0, 0,
                                &lpSpriteTexture);

    // Sprite kreiern
    D3DXCreateSprite(lpD3DDevice, &lpSprite);

    // Struktur, in der Informationen zur Nachricht gespeichert werden
    MSG msg = { 0 };

    while(msg.message != WM_QUIT)
    {
        if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
             // Tasten abfragen - Bewegung des Sprites
            if(GetAsyncKeyState(VK_LEFT) & 0x8000)
            {
                g_x -= 10.0f;
            }
            else if(GetAsyncKeyState(VK_RIGHT) & 0x8000)
            {
                g_x += 10.0f;
            }
            if(GetAsyncKeyState(VK_UP) & 0x8000)
            {
                g_y -= 10.0f;
            }
            else if(GetAsyncKeyState(VK_DOWN) & 0x8000)
            {
                g_y += 10.0f;
            }
            // Wenn Space gedrueckt wurde, Sprite rotieren
            if(GetAsyncKeyState(VK_SPACE) & 0x8000)
            {
                Rotation += .1f;
            }
            // Bei Shift-Taste Sprite vergroessern
            if(GetAsyncKeyState(VK_SHIFT) & 0x8000)
            {
                Scale += .1f;
            }
            // Bei Control-Taste Sprite verkleinern
            if(GetAsyncKeyState(VK_CONTROL) & 0x8000)
            {
                Scale -= .1f;
            }

            // Zeichnen des Sprites
            D3DXMATRIX Matrix;

            D3DXVECTOR2 vCenter(64.0f, 64.0f);
            D3DXVECTOR2 vPosition(g_x, g_y);
            D3DXVECTOR2 vScaling(Scale, Scale);

            // Farben der Textur sollen nicht veraendert werden
            D3DCOLOR ModulateColor = 0xFFFFFFFF;

            Direct3D.BeginScene();

            lpSprite->Begin(D3DXSPRITE_ALPHABLEND);

            // Matrix fuer die 2D-Transformation berechnen
            D3DXMatrixTransformation2D(
                    &Matrix,
                    &vCenter,
                    0.0f,
                    &vScaling,
                    &vCenter,
                    Rotation,
                    &vPosition);

            // Transformations-Matrix setzen
            lpSprite->SetTransform(&Matrix);

            // Sprite zeichnen
            lpSprite->Draw(lpSpriteTexture,
                           NULL,
                           NULL,
                           NULL,
                           ModulateColor);

            lpSprite->End();

            Direct3D.DrawText("Fluessige Bewegung mit Hilfe von GetAsyncKeyState()", 10, 10, 0xFFFFFFFF);

            Direct3D.EndScene();
        }
    }

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

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

    // Rueckgabewert 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
                          "MoveSpriteEx",         // Fenstertitel
                          WS_OVERLAPPEDWINDOW |   // Fenster
                          WS_VISIBLE,             // Eigenschaften
                          50, 50,                 // Anfangsposition
                          SCR_WIDTH, SCR_HEIGHT,  // und Groesse des Fensters
                          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)
{
    // testen, um welche Nachricht 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)
           {
             // Bei F1 einen Screenshot speichern
             case VK_F1:
                    Direct3D.CreateScreenshot("c:\\screenshot.bmp");
                 break;

             // Wenn ESC gedrueckt, Programm beenden
             case VK_ESCAPE:
                     DestroyWindow(hWnd);
                  break;
           }
         break;
    }
    // Standardnachrichtenverarbeitung von Windows
    return DefWindowProc(hwnd, msg, wParam, lParam);
}
in main.cpp

CPP:
#include "Direct3D.h"
#include <dxerr9.h>

CDirect3D::CDirect3D()
{
    m_lpD3D        = NULL;
    m_lpD3DFont    = NULL;
    m_lpD3DDevice  = NULL;
    m_lpBackBuffer = NULL;
}

CDirect3D::~CDirect3D()
{
    CleanUp();
}

// Direct3D initialisieren
BOOL CDirect3D::Init(HWND hWnd, BOOL bWindowed)
{
    // Direct3D-Objekt erzeugen
    m_lpD3D = Direct3DCreate9(D3D_SDK_VERSION);

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

    // Parameter fuer den Modus festlegen
    D3DPRESENT_PARAMETERS PParams;
    ZeroMemory(&PParams, sizeof(PParams));

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

    PParams.BackBufferWidth  = SCR_WIDTH;
    PParams.BackBufferHeight = SCR_HEIGHT;
    PParams.BackBufferFormat = D3DFMT_A8R8G8B8;

    HRESULT hr;

    // Direct3D-Geraet anlegen
    if(FAILED(hr = m_lpD3D->CreateDevice(
                                 D3DADAPTER_DEFAULT,
                                 D3DDEVTYPE_HAL,
                                 hWnd,
                                 D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                 &PParams,
                                 &m_lpD3DDevice)))
    {
        // Fehler, Geraet kann nicht angelegt werden
        const char* Err = DXGetErrorDescription9(hr);

        DXTRACE_MSG(Err);

        return FALSE;
    }

    // Schrift erzeugen
    CreateFont();

    // Zeiger auf dem Hintergrundpuffer holen
    m_lpD3DDevice->GetBackBuffer(0, 0,
                                 D3DBACKBUFFER_TYPE_MONO,
                                 &m_lpBackBuffer);

    return TRUE;
}

// Zeiger auf den Hintergrundbuffer zurueckgeben
LPDIRECT3DSURFACE9 CDirect3D::GetBackbuffer(void)
{
    return m_lpBackBuffer;
}

// Farbe fuer den Backbuffer festlegen
void CDirect3D::SetClearColor(D3DCOLOR Color)
{
    m_ClearColor = Color;
}

// Text an Position x, y ausgeben
void CDirect3D::DrawText(LPCSTR Text, int x, int y, D3DCOLOR TextColor)
{
    RECT r = { x, y, 0, 0 };

    // Groesse des Rechtecks berechnen
    m_lpD3DFont->DrawText(NULL, Text, -1, &r, DT_CALCRECT, TextColor);

    // Text ausgeben
    m_lpD3DFont->DrawText(NULL, Text, -1, &r, DT_CENTER, TextColor);
}

// Methoden zum Start/Beenden der Szene
void CDirect3D::BeginScene(void)
{
    m_lpD3DDevice->Clear(0, 0, D3DCLEAR_TARGET, m_ClearColor, 0, 0);

    m_lpD3DDevice->BeginScene();
}


void CDirect3D::EndScene(void)
{
    m_lpD3DDevice->EndScene();

    m_lpD3DDevice->Present(0, 0, 0, 0);
}

// Erzeugen der D3D-Schrift
void CDirect3D::CreateFont(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(m_lpD3DDevice,
                           &FontDesc,
                           &m_lpD3DFont);
}


// Diese Methode zeichnet eine Ellipse
void CDirect3D::DrawEllipse(int x1, int y1, int x2, int y2, LPDIRECT3DSURFACE9 lpSurface)
{
    HDC hDC;

    if(FAILED(lpSurface->GetDC(&hDC)))
    {
        DXTRACE_MSG("DC ist nicht verfuegbar");
    }
    else
    {
        // Ellipse zeichnen
        Ellipse(hDC, x1, y1, x2, y2);

        // Wichtig! Device Context wieder freigeben
        lpSurface->ReleaseDC(hDC);
    }
}
in Direct3D.cpp

CPP:
#include <d3d9.h>
#include <d3dx9.h>
#include "global.h"


class CDirect3D
{
   public:

        CDirect3D();
        virtual ~CDirect3D();

        // Direct3D initialisieren
        BOOL Init(HWND hWnd, BOOL bWindowed = TRUE);

        // Farbe fuer den Backbuffer festlegen
        void SetClearColor(D3DCOLOR Color);

        // Text an Position x, y ausgeben
        void DrawText(LPCSTR Text, int x, int y, D3DCOLOR TextColor);

        // Methoden zum Start/Beenden der Szene
        void BeginScene(void);
        void EndScene(void);

        void DrawEllipse(int x1, int y1, int x2, int y2, LPDIRECT3DSURFACE9 lpSurface);

        // Zeiger auf den Hintergrundbuffer zurueckgeben
        LPDIRECT3DSURFACE9 GetBackbuffer(void);

        // Screenshot erstellen
        void CreateScreenshot(char* Filename);

        // das Direct3D-Device zurueckgeben
        LPDIRECT3DDEVICE9 GetDevice(void);

   protected:

        // Erzeugen der D3D-Schrift
        void CreateFont(void);
        // Freigeben der Objekte
        void CleanUp(void);

        // Farbe fuer den Backbuffer
        D3DCOLOR          m_ClearColor;

        // Direct3D Variablen
        LPDIRECT3D9       m_lpD3D;
        LPDIRECT3DDEVICE9 m_lpD3DDevice;
        LPD3DXFONT        m_lpD3DFont;

        LPDIRECT3DSURFACE9 m_lpBackBuffer;
};
inDirect3D.h

CPP:
const int SCR_WIDTH  = 1024;
const int SCR_HEIGHT =  768;
in Global.h

nun bekomme ich das vom kompiler:
Code:
-------------- Build: default in Battle of Heroes ---------------
Linking executable: Battle of Heroes.exe
main.obj : error LNK2019: unresolved external symbol "public: void __thiscall CDirect3D::CreateScreenshot(char *)" (?CreateScreenshot@CDirect3D@@QAEXPAD@Z) referenced in function "long __stdcall MessageHandler(struct HWND__ *,unsigned int,unsigned int,long)" (?MessageHandler@@YGJPAUHWND__@@IIJ@Z)
main.obj : error LNK2019: unresolved external symbol "public: struct IDirect3DDevice9 * __thiscall CDirect3D::GetDevice(void)" (?GetDevice@CDirect3D@@QAEPAUIDirect3DDevice9@@XZ) referenced in function _WinMain@16
Direct3D.obj : error LNK2019: unresolved external symbol "protected: void __thiscall CDirect3D::CleanUp(void)" (?CleanUp@CDirect3D@@IAEXXZ) referenced in function "public: virtual __thiscall CDirect3D::~CDirect3D(void)" (??1CDirect3D@@UAE@XZ)
Battle of Heroes.exe : fatal error LNK1120: 3 unresolved externals
Process terminated with status 1 (0 minutes, 0 seconds)
4 errors, 0 warnings

ich verwende codeblocks v1.0 und visual c++ toolkit 2003
danke bereits im vorraus

PS.:ich habe alles wie im Buch eingestellt!!!!!

*edit* neuinstallation bereits getestet!!!
_________________
Wer einen Rechtschreibefehler findet, darf ihn behalten, in ein Regal stellen und jedem der vobei geht sagen, dass ER ihn gefunden hat.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
User_User
JLI'ler



Anmeldedatum: 05.08.2004
Beiträge: 137

Medaillen: Keine

BeitragVerfasst am: 21.05.2009, 21:01    Titel: Antworten mit Zitat

Bei Fehler Nummer 1 fehlt in der Datei

Direct3D.cpp die Funktion CreateScreenshot(), welche du in Direct3D.h ankündigst.

Wenn du die Fehlermeldungen aufmerksam liest, solltes du alle Fehler selber finden.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
magigman
Junior JLI'ler



Anmeldedatum: 25.09.2007
Beiträge: 87

Medaillen: Keine

BeitragVerfasst am: 22.05.2009, 06:31    Titel: Antworten mit Zitat

das komische ist nur, dass ich ein beispiel aus dem buch verwendet habe...
danke trotzdem. ich werde es einmal versuchen. jetzt wo du es sagst ist es mir auch aufgefallen^^
_________________
Wer einen Rechtschreibefehler findet, darf ihn behalten, in ein Regal stellen und jedem der vobei geht sagen, dass ER ihn gefunden hat.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
magigman
Junior JLI'ler



Anmeldedatum: 25.09.2007
Beiträge: 87

Medaillen: Keine

BeitragVerfasst am: 23.05.2009, 12:17    Titel: Antworten mit Zitat

DANKE!!!
Wegen dir konnt ich mein Spiel nun endlich umsetzen und bin noch dabei es zu verbessern!!! (siehe Signatur)

PS.: Nicht das du dich wunderst. den Beispieltext hab ich mir nur noch einmal angeguckt
Zitat:
das komische ist nur, dass ich ein beispiel aus dem buch verwendet habe...

_________________
Wer einen Rechtschreibefehler findet, darf ihn behalten, in ein Regal stellen und jedem der vobei geht sagen, dass ER ihn gefunden hat.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Fragen, Antworten und Kritik Alle Zeiten sind GMT
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de

Impressum