root/lang/c/GSD/trunk/hook.cpp @ 6952

/*
 * GSD
 *
 * Copyright (C) 2008 mosa ��e5bW6vDOJ. <pcyp4g@gmail.com>
 * 
 * This is free software with ABSOLUTELY NO WARRANTY.
 * 
 * You can redistribute it and/or modify it under the terms of
 * the GNU Lesser General Public License.
 *
 */

#include <windows.h>
#include <stdio.h>

#include "common.h"
#include "tools.h"
#include "version.h"

#include "hook.h"
#include "hookd3d9.h"
#include "hookd3d8.h"
#include "hookogl.h"

//-----------------------------------------------------------------------------

#pragma data_seg(".sharedata")
static HHOOK hHook = NULL;
BOOL dllActive = FALSE;
#pragma data_seg()

//-----------------------------------------------------------------------------

HINSTANCE g_hInstance = NULL;

static bool hooked9 = false;
static bool hooked8 = false;
static bool hookedOGL = false;
static DWORD dwCheckTimer = 0;

static struct sLocal *lo = NULL;

//-----------------------------------------------------------------------------

typeSetWindowsHookExW extSetWindowsHookExW = NULL;
void *addrSetWindowsHookExW = NULL;

__declspec(naked) HHOOK WINAPI extSetWindowsHookExWXP(int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId)
{
        __asm
        {
                push    ebp  
                mov             ebp, esp
                jmp             addrSetWindowsHookExW           
        }
}

//-----------------------------------------------------------------------------

bool InitSub();

VOID CALLBACK CheckTimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
        if(!hooked9)
        {
                if(GetModuleHandle("d3d9.dll") != NULL)
                {
                        dprintf("Direct3D9 hook...");

                        InitSub();

                        SetHookD3D9();
                        hooked9 = true;
                }
        }

        if(!hooked8)
        {
                if(GetModuleHandle("d3d8.dll") != NULL)
                {
                        dprintf("Direct3D8 hook...");

                        InitSub();

                        SetHookD3D8();
                        hooked8 = true;
                }
        }

        if(!hookedOGL)
        {
                if(GetModuleHandle("opengl32.dll") != NULL)
                {
                        dprintf("OpenGL hook...");

                        InitSub();

                        SetHookOGL();
                        hookedOGL = true;
                }
        }

        if(hooked9)
                CheckHookD3D9();
        if(hooked8)
                CheckHookD3D8();
        if(hookedOGL)
                CheckHookOGL();
}

//-----------------------------------------------------------------------------

bool Init()
{       // �v���Z�X�ɓǂݍ��܂ꂽ�Ƃ��Ăяo��������1��   bool succeed = false;

        CheckTimerProc(NULL, 0, 0, 0);

        do
        {
                dwCheckTimer = SetTimer(NULL, 0, 1000, CheckTimerProc);
                if(dwCheckTimer == 0)
                {
                        dprintf("SetTimer() failed.");
                        break;
                }

                succeed = true;

        }while(false);

        return succeed;
}

//-----------------------------------------------------------------------------

bool InitSub()
{       // Hook�����Ƃ��Ɍďo��������������        if(g == NULL)
        {
                g = new sGlobal;

                CMicroTimer::calcError();
        }

        return true;
}

//-----------------------------------------------------------------------------

void UninitSub()
{       // Hook������ꂽ�Ƃ��Ɍďo���� (1��  if(g != NULL)
                delete g;
        g = NULL;
}

//-----------------------------------------------------------------------------

void Uninit()
{       // �v���Z�X���������[�h�����Ƃ��Ăяo���� (1��     KillTimer(NULL, dwCheckTimer);

        if(hooked9 || hooked8|| hookedOGL)
        {
                if(hooked9)
                        ResetHookD3D9();
                if(hooked8)
                        ResetHookD3D8();
                if(hookedOGL)
                        ResetHookOGL();

                UninitSub();

                hooked9 = false;
                hooked8 = false;
                hookedOGL = false;
        }
}

//-----------------------------------------------------------------------------

static bool initiated = false;

BOOL APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
        OSVERSIONINFO ver;
        void *baseAddr;

        switch(dwReason)
        {
        case DLL_PROCESS_ATTACH:
                g_hInstance = hInstance;
                DisableThreadLibraryCalls(hInstance);

                LoadLibrary("user32.dll");

                baseAddr = GetProcAddress(GetModuleHandle("user32.dll"), "SetWindowsHookExW");

                ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
                GetVersionEx(&ver);

                if(ver.dwMajorVersion == 5)
                {
                        if(ver.dwMinorVersion > 0)
                        {
                                addrSetWindowsHookExW = (char *)baseAddr + 5;
                                extSetWindowsHookExW = extSetWindowsHookExWXP;
                        }
                }

                if(ver.dwMajorVersion == 6)
                {
                        addrSetWindowsHookExW = (char *)baseAddr + 5;
                        extSetWindowsHookExW = extSetWindowsHookExWXP;
                }
                
                if(extSetWindowsHookExW == NULL)
                        extSetWindowsHookExW = (typeSetWindowsHookExW)baseAddr;

                {
                        bool pass = true;
                        char sztemp[MAX_PATH*2], windir[MAX_PATH*2];

                        GetWindowsDirectory(windir, MAX_PATH*2);
                        GetModuleFileName(GetModuleHandle(NULL), sztemp, MAX_PATH*2);

                        if(dllActive == FALSE)
                                pass = false;

                        if(strstr(sztemp, windir))
                                pass = false;

                        if(strstr(sztemp, "rrtest.exe"))
                                pass = false;

                        if(pass)
                        {
                                dprintf("Inject %s (%d)", sztemp, GetCurrentProcessId());

                                Init();
                                initiated = true;
                        }
                }
                break;
        case DLL_PROCESS_DETACH:

                if(initiated)
                        Uninit();

                break;
        }

    return TRUE;
}

//-----------------------------------------------------------------------------

LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
        return CallNextHookEx(hHook, nCode, wParam, lParam);
}

//-----------------------------------------------------------------------------

DllExport BOOL WINAPI GSD_Initialize()
{
        int n1 = 128, n2 = 128, n3 = 128;

        if(lo)
                return FALSE;

        lo = new sLocal;

        GetOffsetD3D9(&n1);
        GetOffsetD3D8(&n2);
        GetOffsetOGL(&n3);

        lo->maxTextureSize = min(n1, min(n2, n3));

        hHook = extSetWindowsHookExW(WH_CBT, HookProc, g_hInstance, 0);
        if(!hHook)
        {
                dprintf("SetWindowsHook() failed.");

                delete lo;
                lo = NULL;

                return FALSE;
        }

        dllActive = TRUE;

        return TRUE;
}

//-----------------------------------------------------------------------------

DllExport void WINAPI GSD_Finalize()
{
        dllActive = FALSE;

        if(lo)
        {
                delete lo;
                lo = NULL;
        }

        if(hHook)
        {
                UnhookWindowsHookEx(hHook);
                hHook = NULL;
        }
}

//-----------------------------------------------------------------------------

DllExport int WINAPI GSD_GetMaxTextureNum()
{
        return MAX_TEXNUM;
}

//-----------------------------------------------------------------------------

DllExport int WINAPI GSD_GetMaxTextureSize()
{
        if(!lo)
                return 0;

        return lo->maxTextureSize;
}

//-----------------------------------------------------------------------------

DllExport DWORD WINAPI GSD_GetLastUpdate()
{
        if(!lo || !lo->settings)
                return 0;

        return lo->settings->lastUpdate;
}

//-----------------------------------------------------------------------------

DllExport DWORD WINAPI GSD_GetVersion()
{
        sVersionInfo info;

        if(ReadVersionModule(g_hInstance, &info))
        {
                DWORD out;

                out = ((info.word.wVer1&0xff)<<24) | ((info.word.wVer2&0xff)<<16) | ((info.word.wVer3&0xff)<<8) | (info.word.wVer4&0xff);

                return out;
        }
        else
        {
                return 0;
        }
}

//-----------------------------------------------------------------------------

DllExport BOOL WINAPI GSD_InitTexture(const DWORD *size, int num)
{
        int i;
        DWORD total;
        char sztemp[256];

        if(!lo || !lo->settings)
                return FALSE;

        if(!size || num < 1)
                return FALSE;

        lo->offsets[0] = 0;
        lo->sizes[0] = size[0];

        for(i=1; i<num; i++)
        {
                lo->offsets[i] = lo->offsets[i-1] + size[i-1];
                lo->sizes[i] = size[i];
        }

        for(; i<MAX_TEXNUM; i++)
        {
                lo->offsets[i] = 0;
                lo->sizes[i] = 0;
        }

        total = 0;
        for(i=0; i<num; i++)
                total += size[i];

        lo->settings->pixelsRevision++;

        sprintf(sztemp, "%s%d", SHARED_PIXELS, lo->settings->pixelsRevision);

        if(lo->smPixels.create(sztemp, total))
        {
                lo->settings->pixelsDataSize = total;
                lo->maxIndex = num;
        }
        else
        {
                lo->settings->pixelsDataSize = 0;
                lo->maxIndex = 0;
                return FALSE;
        }

        return TRUE;
}

//-----------------------------------------------------------------------------

DllExport BOOL WINAPI GSD_SetTexture(int index, const struct GSD_TextureInfo *info)
{
        if(!lo || !lo->settings)
                return FALSE;

        if(!info || index >= MAX_TEXNUM)
                return FALSE;

        if(index >= lo->maxIndex && info->data)
                return FALSE;

        if(!lo->smPixels.getData() && info->data)
                return FALSE;

        lo->settings->texInfo[index].active = info->active;
        lo->settings->texInfo[index].align = info->align;
        lo->settings->texInfo[index].color = info->color;
        lo->settings->texInfo[index].x = info->x;
        lo->settings->texInfo[index].y = info->y;
        lo->settings->texInfo[index].texSize = info->texSize;

        if(info->data)
        {
                lo->settings->texInfo[index].offset = lo->offsets[index];
                lo->settings->texInfo[index].revision++;

                memcpy(lo->smPixels.getData() + lo->offsets[index], info->data, lo->sizes[index]);
        }

        return TRUE;
}

//-----------------------------------------------------------------------------

DllExport BOOL WINAPI GSD_GetTexture(int index, struct GSD_TextureInfo *info)
{
        if(!lo || !lo->settings)
                return FALSE;

        if(!info || index >= MAX_TEXNUM)
                return FALSE;

        if(index >= lo->maxIndex && info->data)
                return FALSE;

        if(!lo->smPixels.getData() && info->data)
                return FALSE;

        info->active = lo->settings->texInfo[index].active;
        info->align = lo->settings->texInfo[index].align;
        info->color = lo->settings->texInfo[index].color;
        info->x = lo->settings->texInfo[index].x;
        info->y = lo->settings->texInfo[index].y;
        info->texSize = lo->settings->texInfo[index].texSize;

        if(info->data)
                memcpy(info->data, lo->smPixels.getData() + lo->offsets[index], lo->sizes[index]);

        return TRUE;
}

//-----------------------------------------------------------------------------

DllExport void WINAPI GSD_DelTexture(int index)
{
        if(!lo || !lo->settings)
                return;

        if(index >= MAX_TEXNUM)
                return;

        lo->settings->texInfo[index].texSize = 0;
}

//-----------------------------------------------------------------------------

DllExport void WINAPI GSD_SetTimerOrg(__int64 org)
{
        if(!lo || !lo->settings)
                return;

        lo->settings->orgTime = org;
}

//-----------------------------------------------------------------------------

DllExport void WINAPI GSD_SetFpsLimit(double fps)
{
        if(!lo || !lo->settings)
                return;

        if(fps < 0.0)
                return;

        lo->settings->fpsLimit = fps;
}

//-----------------------------------------------------------------------------

DllExport void WINAPI GSD_SetFpsAlign(DWORD align)
{
        if(!lo || !lo->settings)
                return;

        lo->settings->fpsAlign = align;
}

//-----------------------------------------------------------------------------

DllExport void WINAPI GSD_ShowFps(BOOL show)
{
        if(!lo || !lo->settings)
                return;

        lo->settings->showFPS = show;
}

//-----------------------------------------------------------------------------

DllExport void WINAPI GSD_UpdateOnActive(BOOL uoa)
{
        if(!lo || !lo->settings)
                return;

        lo->settings->updateOnActive = uoa;
}

//-----------------------------------------------------------------------------

DllExport void WINAPI GSD_DataLock()
{
        if(!lo)
                return;

        lo->mutexSettings.lock();
}

//-----------------------------------------------------------------------------

DllExport void WINAPI GSD_DataUnlock()
{
        if(!lo)
                return;

        lo->mutexSettings.unlock();
}

//-----------------------------------------------------------------------------