000
20.04.2009, 01:12 Uhr
heikod
|
Hallo erstmal,
ich gebe zu ich bin kein C++ Profi, eher Neuling, aber ich versuche mich auch in anderen Sprachen und so ist mir das Programmieren nicht fremd.
Ich stehe vor einem Mittelschweren Problem.
Ich beschäftige mich zunehmen mit DirectX9 und habe ein kleines Projekt vor.
Und zwar nutze ich eine 3D Engine, für welche ich ein addon coden möchte.
Eine 2D Library(dll).So mit einigen Funktionen wie LoadImage, DrawImage etc.
Um diese 2D Engine anwenden zu können muß nachdem die 3D Engine gestartet hat und sich ein D3D9 Device zugelegt hat, meine dll injected werden.
Ein Hook sozusagen.
Ich habe einiges an code gefunden, aber ich bin wohl noch zu noobisch um ihn allein anzupassen, daher bitte ich euch um mithilfe.
Zuerst muss ich jedoch sagen, daß dieser code schon funktionieren kan und wird, aber nicht in meinem Sinne.
Denn Ich benötige ja in meiner dll zwei funktionen ala "StartDraw" und "EndDraw".
Die codes die ich fand, verlangen aber, daß man dort in einem rutsch einfach sein dx9 zeugs reinwirft und fertig.
Es soll ja eine engine werden, wobei der StartDraw Befehl die IDirect3D9 Device erhält und erst bei EndDraw zurückgibt.
Ich poste hier mal Code...
Ach und ganz wichtig, falls es etwas nutzt, ich kann mir nen Pointer auf die Device der 3D Engine mittels "GetDevice()" holen.
so hier mal zwei codes die ich fand...
| C++: |
// dllmain.cpp : Defines the entry point for the DLL application.
#include "stdafx.h"
#include <winsock2.h>
/*
Fake export function
*/
extern "C" __declspec(dllexport) void fakeexportfunction()
{
return ;
}
// Functions to be Hooked/Detoured
IDirect3D9 * (WINAPI * Real_Direct3DCreate9)(UINT SDKVersion) = Direct3DCreate9;
// Functions that replace Hooked/Detoured version
IDirect3D9 * WINAPI Hook_Direct3DCreate9(UINT a0)
{
Beep(1000, 1000);
IDirect3D9 * rv;
__try {
rv = Real_Direct3DCreate9(a0);
} __finally {
OutputDebugString(TEXT("Direct3DCreate9\n"));
}
OutputDebugString(TEXT("Direct3DCreate9\n"));
return rv;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
LONG error;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
DetourRestoreAfterWith();
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)Real_Direct3DCreate9, Hook_Direct3DCreate9);
error = DetourTransactionCommit();
if (error == NO_ERROR)
OutputDebugString(TEXT("Attached Hooks\n"));
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourDetach(&(PVOID&)Real_Direct3DCreate9, Hook_Direct3DCreate9);
error = DetourTransactionCommit();
OutputDebugString(TEXT("Detached Hooks\n"));
break;
}
return TRUE;
}
|
und hier ein anderer, denke aber der erste ist besser...
| C++: |
/ D3d hook
#include <windows.h>
#include <cstdio>
#include <d3d9.h>
#include <d3dx9.h>
typedef HRESULT(__stdcall* EndScene_t)(LPDIRECT3DDEVICE9); // typedef
EndScene_t pEndScene;
void InitHook();
void *DetourFunc(BYTE *src, const BYTE *dst, const int len);
HRESULT __stdcall hkEndScene(LPDIRECT3DDEVICE9 pDevice)
{
// das ist das entscheidende: Wenn normalerweise EndScene aufgerufen wird, wird diese Funktion von dem Programm aufgerufen
// hier kommen deine Sachen hin die man drawn mit pDevice.
// und dann noch zurück zum originalen EndScene, diese muss ja auch aufgerufen werden
return pEndScene(pDevice);
}
int WINAPI DllMain(HINSTANCE hInst,DWORD reason,LPVOID reserved)
{
switch(reason)
{
case DLL_PROCESS_ATTACH:
CreateThread(0, 0, (LPTHREAD_START_ROUTINE) InitHook, 0, 0, 0);
break;
}
return true;
}
void InitHook()
{
HMODULE hModule = NULL;
while( !hModule )
{
hModule = GetModuleHandleA( "d3d9.dll" ); // Handle zur DLL holen
Sleep( 100 ); // 100ms warten
}
// 0x4FDD71B0 ist die Addresse für EndScene in d3d9.dll
pEndScene = ( EndScene_t )DetourFunc((PBYTE) 0x4FDD71B0,(PBYTE)hkEndScene, 5); // hier ist der hook
}
void *DetourFunc(BYTE *src, const BYTE *dst, const int len) // detour, muss man nicht wirklich verstehen. Der Code ersetzt das alte endScene durch unseres. Ist von gd
{
BYTE *jmp = (BYTE*)malloc(len+5);
DWORD dwback;
VirtualProtect(src, len, PAGE_READWRITE, &dwback);
memcpy(jmp, src, len); jmp += len;
jmp[0] = 0xE9;
*(DWORD*)(jmp+1) = (DWORD)(src+len - jmp) - 5;
src[0] = 0xE9;
*(DWORD*)(src+1) = (DWORD)(dst - src) - 5;
VirtualProtect(src, len, dwback, &dwback);
return (jmp-len);
}
|
|
