Kennt jemand ein Engine Tutorial? Denn ich will eine Engine programmieren, und weiss nicht genau wie ich das machen soll.

Ich danke für eure Antworten

Gruss Patrick

01: Nee, eine DLL-Engine

PARSE ERROR @Main: Line 01: exported Symbol 'DLL-Engine' not found !

Hä ? Was willst du ?

Grafik-Engine, Physik-Engine, Gui-Engine, ...
was willst du denn überhaupt programmieren ?

Oder willst du einfach nur wissen, wie man eine DLL erstellt ?

MFG, userland

// Dark3DCubeEnginedll.h
//
// Definitions of the functions
//
#ifndef DARK_HPP
#define DARK_HPP

#include <windows.h>
#include "Structures.h"

// create a namespace, called DCE
//
namespace DCE
{
	// Create a class, called Dark3DCubeEngine
	//
	class Dark3DCubeEngine
	{
	public:

		static __declspec(dllexport) void Initialize (const int WindowWidth, const int WindowHeight, const int WindowDepth);
		static __declspec(dllexport) HWND OpenWindow (HINSTANCE hInstance);
		static __declspec(dllexport) LRESULT WINAPI MsgProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

	private:

		static int m_WindowWidth;
		static int m_WindowHeight;
		static int m_WindowDepth;

	}; // End of the class

} // End of the namespace

#endif

// Dark3DCubeEnginedll.cpp
//
// Definitions of the functions
//
#include "Dark3DCubeEnginedll.h"

// Create a namespace, called DCE
//
namespace DCE
{
	Dark3DCubeEngineProperties * props = new Dark3DCubeEngineProperties();
	int Dark3DCubeEngine::m_WindowDepth;  // = 0
	int Dark3DCubeEngine::m_WindowHeight; // = 0
	int Dark3DCubeEngine::m_WindowWidth;  // = 0 

	void Dark3DCubeEngine::Initialize (const int WindowWidth, const int WindowHeight, const int WindowDepth)
	{
		m_WindowWidth = WindowWidth;
		m_WindowHeight = WindowHeight;
		m_WindowDepth = WindowDepth;

		props->WindowWidth = WindowWidth;
		props->WindowHeight = WindowHeight;
		props->WindowDepth = WindowDepth;
	}

	HWND Dark3DCubeEngine::OpenWindow(HINSTANCE hInstance)
	{
		WNDCLASSEX wc;

		wc.style			= CS_HREDRAW | CS_VREDRAW;
		wc.cbSize			= sizeof (wc);
		wc.lpfnWndProc		= MsgProc;
		wc.cbClsExtra		= 0;
		wc.cbWndExtra		= 0;
		wc.hInstance		= hInstance;
		wc.hIcon			= LoadIcon (NULL, IDI_APPLICATION);
		wc.hCursor			= LoadCursor (NULL, IDC_ARROW);
		wc.hbrBackground	= (HBRUSH)GetStockObject(BLACK_BRUSH);
		wc.lpszMenuName		= NULL;
		wc.lpszClassName	= TEXT ("Dark3DCubeEngine");
		wc.hIconSm			= LoadIcon (NULL, IDI_APPLICATION);

		if (RegisterClassEx (&wc) == 0) return 0;

		return CreateWindowEx (NULL, TEXT("Dark3DCubeEngine"), "Dark3DCubeEngine",
							   WS_OVERLAPPEDWINDOW | WS_VISIBLE,
							   GetSystemMetrics(SM_CXSCREEN)/2 - 250,
							   GetSystemMetrics(SM_CYSCREEN)/2 - 187,
							   m_WindowWidth, m_WindowHeight, NULL,
							   NULL, hInstance, NULL);
	}

	LRESULT WINAPI Dark3DCubeEngine::MsgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
	{
		switch (msg)
		{
			// key was pressed
			//
		case WM_KEYDOWN:
			{
				switch (wParam)
				{
				case VK_ESCAPE:
					{
						PostMessage (hwnd, WM_CLOSE, 0, 0);
						return 0;
					}
				default: break;
				}
			} break;

		case WM_DESTROY:
			{
				PostQuitMessage (0);
				return 1;
			}
		default: break;
		}

		return DefWindowProc(hwnd, msg, wParam, lParam);
	}
} // End of the namespace

// Structures.h
//
// Definitions of the Structures
//

// Create a namespace, called DCE
//
namespace DCE
{
	// Create a struct, called Dark3DCubeEngineProperties
	//
	struct Dark3DCubeEngineProperties
	{
		int WindowWidth;
		int WindowHeight;
		int WindowDepth;
	}; // End of the struct

} // End of the namespace

Und so habe ich diese DLL getestet:

// main.h
//
// MyGame
//
#include <windows.h>
#include "Dark3DCubeEnginedll.h"

// Create a class, called MyApplication
//
class MyApplication : public DCE::Dark3DCubeEngine
{
public:

	MyApplication (){}
	virtual ~MyApplication (){}

};

// main.cpp
//
// MyGame
//
#include "main.h"

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					LPSTR lpCmdLine, int nShowCmd)
{
	MSG msg;
	HWND hwnd;
	bool bDone = false;

	MyApplication * pApp = new MyApplication ();

	pApp->Initialize(800, 600, 32);
	hwnd = pApp->OpenWindow(hInstance);

	while (!bDone)
	{
		while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	delete pApp;

	return 0;
}

Kann mir jemand sagen, ob ich so eine Engine schreiben kann, oder ob ich anders vorgehen soll?

1. Die Kommentare sind schlecht.
2. Zuerst planen, dann entwickeln.

Na dann bring doch mal Vorschläge zur Planung anstatt hier einfach deine Stichpunkte in den Raum reinzuschmeißen.

Also die Kommentare finde ich erst mal ganz ok. Warum auch nicht - sind ja auch nicht viele, denn es ist ja auch noch nicht sooo viel Sourcecode vorhanden.

Ähm jo. Du exportierst also jede Funktion einzeln aus deiner Klasse, wie ich hier sehe. Habe ich selbst noch nie so gemacht, weil ich das eher umständlich finde jeder einzelnen Funktion das __declspec (dllexport) voranzustellen und der Cpp-Compiler am Ende ganz ulkige Exportnamen mit @, Klassen -, Funktionsnamen und Argumentenlänge generiert. Kannst dir ja mal mit "Dependency Walker" deine exportierten Funktionsnamen angucken. Aber das ist nur eine Meinung.

Du könntest es auch so machen, wie es DirectX (z.B. d3d9.dll) macht - deine Klasse ganz normal deklarieren (also ohne die __declspec (dllexports) ) und dann eine einzige globale Funktion (die sich nicht in einer Klasse befindet) aus deiner DLL exportieren, die dem Aufrufer einen Zeiger auf eine Instanz deiner Klasse zurückgibt, wie z.B. Direct3DCreate9() das macht.

Ansonsten würde sich dabei nicht viel ändern:

Du gibst dem Benutzer deiner DLL wieder die Dark3DCubeEnginedll.h und die *.lib mit auf den Weg, die der Compiler benötigt und dann braucht er nur noch deine exportierte Funktion aufzurufen - sagen wir mal Dark3DCreateCubeEngine() - und bekommt dadurch einen Zeiger auf eine Instanz deiner Klasse im Speicher.

Also die exportierte Funktion sieht dann in deiner DLL ungefähr so aus:

extern "C" __declspec (dllexport) Dark3DCubeEngine * Dark3DCreateCubeEngine(void) 
{
    return new Dark3DCubeEngine ();
}

Benutzer-Code:

#include "Dark3DCubeEnginedll.h"

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine, int nShowCmd)
{
    MSG msg;
    HWND hwnd;
    bool bDone = false;
    Dark3DCubeEngine * pCubeEngine;

    pCubeEngine = Dark3DCreateCubeEngine();
    pCubeEngine->Initialize(800, 600, 32);
    hwnd = pCubeEngine->OpenWindow(hInstance);

    while (!bDone)
    {
        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    delete pCubeEngine;
    return 0;
}

k.A. könnte vielleicht professioneller rüberkommen, wenn DirectX das schon so macht - das ganze ist in Anlehnung an die COM - Spezifikation von Microsoft (Component Object Model), also eher Windows-konform. Wenn du aber darauf bestehst, mit Namespaces zu arbeiten, dann ist deine Variante sicherlich vorteilhafter.

Joa...is nur ein Vorschlag.
Vielleicht gibts ja Jemand mit noch besseren Ideen. :p

MFG, userland

Nun Frage, wo kann ich mich ein wenig in COM einarbeiten?

Kannst du mir eine Seite nennen, diese mir beim erlenen von COM hilft? Oder kannst du mir ein Bespielcode schreiben?

Gruss Patrick