dfhack/shmserver/shms-windows.cpp

782 lines
24 KiB
C++

/*
www.sourceforge.net/projects/dfhack
Copyright (c) 2009 Petr Mrázek (peterix)
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.
Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source
distribution.
*/
/**
2010-01-04 15:20:17 -07:00
* This is the source for the DF <-> dfhack shm bridge,
* to be used with SDL 1.2 and DF 40d16. Windows sucks
* using hacks like this sucks even more
*/
2010-01-04 15:20:17 -07:00
#include <windows.h>
#include <stdarg.h>
#define DFhackCExport extern "C" __declspec(dllexport)
2010-01-04 15:20:17 -07:00
#include "../library/integers.h"
2010-03-02 21:43:38 -07:00
#include <vector>
#include <string>
#include "shms.h"
2010-03-04 16:05:01 -07:00
#include "mod-core.h"
#include <stdio.h>
2010-01-07 22:52:37 -07:00
int errorstate = 0;
char *shm = 0;
int shmid = 0;
bool inited = 0;
HANDLE shmHandle = 0;
HANDLE DFSVMutex = 0;
HANDLE DFCLMutex = 0;
void SHM_Init ( void )
{
// check that we do this only once per process
if(inited)
{
//MessageBox(0,"SDL_Init was called twice or more!","FUN", MB_OK);
2010-01-07 22:52:37 -07:00
return;
}
inited = true;
char svmutexname [256];
sprintf(svmutexname,"DFSVMutex-%d",OS_getPID());
char clmutexname [256];
sprintf(clmutexname,"DFCLMutex-%d",OS_getPID());
char shmname [256];
sprintf(shmname,"DFShm-%d",OS_getPID());
2010-01-07 22:52:37 -07:00
// create or open mutexes
DFSVMutex = CreateMutex( 0, 1, svmutexname);
2010-01-07 22:52:37 -07:00
if(DFSVMutex == 0)
{
DFSVMutex = OpenMutex(SYNCHRONIZE,false, svmutexname);
2010-01-07 22:52:37 -07:00
if(DFSVMutex == 0)
{
errorstate = 1;
return;
}
}
DFCLMutex = CreateMutex( 0, 0, clmutexname);
2010-01-07 22:52:37 -07:00
if(DFCLMutex == 0)
{
DFCLMutex = OpenMutex(SYNCHRONIZE,false, clmutexname);
2010-01-07 22:52:37 -07:00
if(DFCLMutex == 0)
{
CloseHandle(DFSVMutex);
errorstate = 1;
return;
}
}
// try locking server mutex
uint32_t result;
result = WaitForSingleObject(DFSVMutex,0);
switch (result)
{
case WAIT_ABANDONED:
{
// picked up after a crashed DF process
// do some sanity checks on client attached
// otherwise the same thing as WAIT_OBJECT_0
break;
}
case WAIT_OBJECT_0:
{
// all right, we have the mutex and are the one and only DF server
break;
}
case WAIT_TIMEOUT:
case WAIT_FAILED:
default:
{
// error, bail
errorstate = 1;
MessageBox(0,"Could not aquire mutex","Error", MB_OK);
2010-01-07 22:52:37 -07:00
CloseHandle(DFSVMutex);
CloseHandle(DFCLMutex);
return;
}
}
// create virtual memory mapping
shmHandle = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,SHM_SIZE,shmname);
2010-01-07 22:52:37 -07:00
// if can't create or already exists -> nothing happens
if(GetLastError() == ERROR_ALREADY_EXISTS)
{
MessageBox(0,"SHM bridge already in use","Error", MB_OK);
errorstate = 1;
ReleaseMutex(DFSVMutex);
CloseHandle(DFSVMutex);
CloseHandle(DFCLMutex);
return;
}
if(!shmHandle)
2010-01-07 22:52:37 -07:00
{
MessageBox(0,"Couldn't create SHM bridge","Error", MB_OK);
2010-01-07 22:52:37 -07:00
errorstate = 1;
ReleaseMutex(DFSVMutex);
CloseHandle(DFSVMutex);
CloseHandle(DFCLMutex);
return;
}
// attempt to attach the created mapping
shm = (char *) MapViewOfFile(shmHandle,FILE_MAP_ALL_ACCESS, 0,0, SHM_SIZE);
if(shm)
{
2010-03-02 21:43:38 -07:00
((shm_cmd *)shm)->pingpong = CORE_RUNNING;
2010-01-07 22:52:37 -07:00
}
else
{
MessageBox(0,"Couldn't attach SHM bridge","Error", MB_OK);
2010-01-07 22:52:37 -07:00
errorstate = 1;
ReleaseMutex(DFSVMutex);
CloseHandle(DFSVMutex);
CloseHandle(DFCLMutex);
}
2010-03-02 21:43:38 -07:00
InitModules();
2010-01-07 22:52:37 -07:00
}
void SHM_Destroy ( void )
{
if(errorstate)
return;
2010-03-04 16:05:01 -07:00
KillModules();
2010-01-07 22:52:37 -07:00
ReleaseMutex(DFSVMutex);
CloseHandle(DFSVMutex);
CloseHandle(DFCLMutex);
}
2010-03-02 21:43:38 -07:00
uint32_t OS_getPID()
2010-01-07 22:52:37 -07:00
{
return GetCurrentProcessId();
}
2010-03-04 16:05:01 -07:00
// TODO: move to some utils file
uint32_t OS_getAffinity()
{
HANDLE hProcess = GetCurrentProcess();
DWORD dwProcessAffinityMask, dwSystemAffinityMask;
GetProcessAffinityMask( hProcess, &dwProcessAffinityMask, &dwSystemAffinityMask );
return dwProcessAffinityMask;
}
2010-01-07 22:52:37 -07:00
// is the other side still there?
bool isValidSHM()
{
// try if CL mutex is free
uint32_t result = WaitForSingleObject(DFCLMutex,0);
switch (result)
{
case WAIT_ABANDONED:
case WAIT_OBJECT_0:
{
ReleaseMutex(DFCLMutex);
return false;
}
case WAIT_TIMEOUT:
{
// mutex is held by a process already
return true;
}
default:
case WAIT_FAILED:
{
// TODO: now how do I respond to this?
return false;
}
}
}
/*************************************************************************/
// boring wrappers beyond this point. Only fix when broken
2010-01-04 15:20:17 -07:00
// function and variable pointer... we don't try to understand what SDL does here
typedef void * fPtr;
typedef void * vPtr;
/// wrappers for SDL 1.2 functions used in 40d16
/***** Condition variables
SDL_CreateCond
SDL_cond * SDLCALL SDL_CreateCond(void);
SDL_CondSignal
2010-01-04 15:20:17 -07:00
int SDLCALL SDL_CondSignal(SDL_cond *cond);
SDL_CondWait
2010-01-04 15:20:17 -07:00
int SDLCALL SDL_CondWait(SDL_cond *cond, SDL_mutex *mut);
SDL_DestroyCond
void SDLCALL SDL_DestroyCond(SDL_cond *cond);
*/
static vPtr (*_SDL_CreateCond)() = 0;
DFhackCExport vPtr SDL_CreateCond()
2010-01-04 15:20:17 -07:00
{
return _SDL_CreateCond();
}
static int (*_SDL_CondSignal)(vPtr cond) = 0;
DFhackCExport int SDL_CondSignal(vPtr cond)
2010-01-04 15:20:17 -07:00
{
return _SDL_CondSignal(cond);
}
static int (*_SDL_CondWait)(vPtr cond, vPtr mutex) = 0;
DFhackCExport int SDL_CondWait(vPtr cond, vPtr mutex)
2010-01-04 15:20:17 -07:00
{
return _SDL_CondWait(cond, mutex);
}
static void (*_SDL_DestroyCond)(vPtr cond) = 0;
DFhackCExport void SDL_DestroyCond(vPtr cond)
2010-01-04 15:20:17 -07:00
{
_SDL_DestroyCond(cond);
}
/***** mutexes
SDL_CreateMutex
2010-01-04 15:20:17 -07:00
SDL_mutex * SDLCALL SDL_CreateMutex(void);
SDL_mutexP
int SDLCALL SDL_mutexP(SDL_mutex *mutex);
SDL_DestroyMutex
void SDLCALL SDL_DestroyMutex(SDL_mutex *mutex);
*/
static vPtr (*_SDL_CreateMutex)(void) = 0;
DFhackCExport vPtr SDL_CreateMutex(void)
2010-01-04 15:20:17 -07:00
{
return _SDL_CreateMutex();
}
static int (*_SDL_mutexP)(vPtr mutex) = 0;
DFhackCExport int SDL_mutexP(vPtr mutex)
2010-01-04 15:20:17 -07:00
{
return _SDL_mutexP(mutex);
}
static void (*_SDL_DestroyMutex)(vPtr mutex) = 0;
DFhackCExport void SDL_DestroyMutex(vPtr mutex)
2010-01-04 15:20:17 -07:00
{
_SDL_DestroyMutex(mutex);
}
/***** timers
SDL_AddTimer
SDL_TimerID SDLCALL SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback, void *param);
SDL_RemoveTimer
SDL_bool SDLCALL SDL_RemoveTimer(SDL_TimerID t);
SDL_GetTicks
Uint32 SDLCALL SDL_GetTicks(void);
*/
static vPtr (*_SDL_AddTimer)(uint32_t interval, fPtr callback, vPtr param) = 0;
DFhackCExport vPtr SDL_AddTimer(uint32_t interval, fPtr callback, vPtr param)
2010-01-04 15:20:17 -07:00
{
return _SDL_AddTimer(interval, callback, param);
}
static bool (*_SDL_RemoveTimer)(vPtr timer) = 0;
DFhackCExport bool SDL_RemoveTimer(vPtr timer)
2010-01-04 15:20:17 -07:00
{
return _SDL_RemoveTimer(timer);
}
static uint32_t (*_SDL_GetTicks)(void) = 0;
DFhackCExport uint32_t SDL_GetTicks(void)
2010-01-04 15:20:17 -07:00
{
return _SDL_GetTicks();
}
/***** Surfaces
SDL_CreateRGBSurface
2010-01-04 15:20:17 -07:00
SDL_Surface * SDLCALL SDL_CreateRGBSurface
(Uint32 flags, int width, int height, int depth,
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
SDL_CreateRGBSurfaceFrom
2010-01-04 15:20:17 -07:00
SDL_Surface * SDLCALL SDL_CreateRGBSurfaceFrom
(void *pixels, int width, int height, int depth, int pitch,
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
SDL_FreeSurface
2010-01-04 15:20:17 -07:00
void SDLCALL SDL_FreeSurface(SDL_Surface *surface);
SDL_ConvertSurface
SDL_Surface * SDLCALL SDL_ConvertSurface
(SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
SDL_LockSurface
2010-01-04 15:20:17 -07:00
int SDLCALL SDL_LockSurface(SDL_Surface *surface);
SDL_UnlockSurface
void SDLCALL SDL_UnlockSurface(SDL_Surface *surface);
*/
static vPtr (*_SDL_CreateRGBSurface)(uint32_t flags, int width, int height, int depth,
uint32_t Rmask, uint32_t Gmask, uint32_t Bmask, uint32_t Amask) = 0;
DFhackCExport vPtr SDL_CreateRGBSurface(uint32_t flags, int width, int height, int depth,
2010-01-04 15:20:17 -07:00
uint32_t Rmask, uint32_t Gmask, uint32_t Bmask, uint32_t Amask)
{
return _SDL_CreateRGBSurface(flags, width, height, depth, Rmask, Gmask, Bmask, Amask);
}
static vPtr (*_SDL_CreateRGBSurfaceFrom)(vPtr pixels, int width, int height, int depth, int pitch,
uint32_t Rmask, uint32_t Gmask, uint32_t Bmask, uint32_t Amask) = 0;
DFhackCExport vPtr SDL_CreateRGBSurfaceFrom(vPtr pixels, int width, int height, int depth, int pitch,
2010-01-04 15:20:17 -07:00
uint32_t Rmask, uint32_t Gmask, uint32_t Bmask, uint32_t Amask)
{
return _SDL_CreateRGBSurfaceFrom(pixels, width, height, depth, pitch, Rmask, Gmask, Bmask, Amask);
}
static void (*_SDL_FreeSurface)(vPtr surface) = 0;
DFhackCExport void SDL_FreeSurface(vPtr surface)
2010-01-04 15:20:17 -07:00
{
_SDL_FreeSurface(surface);
}
static vPtr (*_SDL_ConvertSurface)(vPtr surface, vPtr format, uint32_t flags) = 0;
DFhackCExport vPtr SDL_ConvertSurface(vPtr surface, vPtr format, uint32_t flags)
2010-01-04 15:20:17 -07:00
{
return _SDL_ConvertSurface(surface, format, flags);
}
static int (*_SDL_LockSurface)(vPtr surface) = 0;
DFhackCExport int SDL_LockSurface(vPtr surface)
2010-01-04 15:20:17 -07:00
{
return _SDL_LockSurface(surface);
}
static void (*_SDL_UnlockSurface)(vPtr surface) = 0;
DFhackCExport void SDL_UnlockSurface(vPtr surface)
2010-01-04 15:20:17 -07:00
{
_SDL_UnlockSurface(surface);
}
/***** More surface stuff
SDL_MapRGB
2010-01-04 15:20:17 -07:00
Uint32 SDLCALL SDL_MapRGB
(const SDL_PixelFormat * const format, const Uint8 r, const Uint8 g, const Uint8 b);
SDL_SaveBMP_RW
2010-01-04 15:20:17 -07:00
int SDLCALL SDL_SaveBMP_RW
(SDL_Surface *surface, SDL_RWops *dst, int freedst);
SDL_SetAlpha
2010-01-04 15:20:17 -07:00
int SDLCALL SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha);
SDL_SetColorKey
2010-01-04 15:20:17 -07:00
int SDLCALL SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key);
SDL_GetVideoInfo
const SDL_VideoInfo * SDLCALL SDL_GetVideoInfo(void);
SDL_SetVideoMode
2010-01-04 15:20:17 -07:00
SDL_Surface * SDLCALL SDL_SetVideoMode
(int width, int height, int bpp, Uint32 flags);
SDL_UpperBlit
2010-01-04 15:20:17 -07:00
int SDLCALL SDL_UpperBlit
(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect);
*/
static uint32_t (*_SDL_MapRGB)(vPtr pixelformat, uint8_t r, uint8_t g, uint8_t b) = 0;
DFhackCExport uint32_t SDL_MapRGB(vPtr pixelformat, uint8_t r, uint8_t g, uint8_t b)
2010-01-04 15:20:17 -07:00
{
return _SDL_MapRGB(pixelformat,r,g,b);
}
static int (*_SDL_SaveBMP_RW)(vPtr surface, vPtr dst, int freedst) = 0;
DFhackCExport int SDL_SaveBMP_RW(vPtr surface, vPtr dst, int freedst)
2010-01-04 15:20:17 -07:00
{
return _SDL_SaveBMP_RW(surface,dst,freedst);
}
static int (*_SDL_SetAlpha)(vPtr surface, uint32_t flag, uint8_t alpha) = 0;
DFhackCExport int SDL_SetAlpha(vPtr surface, uint32_t flag, uint8_t alpha)
2010-01-04 15:20:17 -07:00
{
return _SDL_SetAlpha(surface,flag,alpha);
}
static int (*_SDL_SetColorKey)(vPtr surface, uint32_t flag, uint32_t key) = 0;
DFhackCExport int SDL_SetColorKey(vPtr surface, uint32_t flag, uint32_t key)
2010-01-04 15:20:17 -07:00
{
return _SDL_SetColorKey(surface,flag,key);
}
static vPtr (*_SDL_GetVideoInfo)(void) = 0;
DFhackCExport vPtr SDL_GetVideoInfo(void)
2010-01-04 15:20:17 -07:00
{
return _SDL_GetVideoInfo();
}
static vPtr (*_SDL_SetVideoMode)(int width, int height, int bpp, uint32_t flags) = 0;
DFhackCExport vPtr SDL_SetVideoMode(int width, int height, int bpp, uint32_t flags)
2010-01-04 15:20:17 -07:00
{
return _SDL_SetVideoMode(width, height, bpp, flags);
}
static int (*_SDL_UpperBlit)(vPtr src, vPtr srcrect, vPtr dst, vPtr dstrect) = 0;
DFhackCExport int SDL_UpperBlit(vPtr src, vPtr srcrect, vPtr dst, vPtr dstrect)
2010-01-04 15:20:17 -07:00
{
return _SDL_UpperBlit(src, srcrect, dst, dstrect);
}
/***** Even more surface
SDL_GL_GetAttribute
int SDLCALL SDL_GL_GetAttribute(SDL_GLattr attr, int* value);
SDL_GL_SetAttribute
int SDLCALL SDL_GL_SetAttribute(SDL_GLattr attr, int value);
SDL_WM_SetCaption
2010-01-04 15:20:17 -07:00
void SDLCALL SDL_WM_SetCaption(const char *title, const char *icon);
SDL_WM_SetIcon
2010-01-04 15:20:17 -07:00
void SDLCALL SDL_WM_SetIcon(SDL_Surface *icon, Uint8 *mask);
SDL_FillRect
int SDLCALL SDL_FillRect(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
*/
2010-02-10 21:56:24 -07:00
static void * (*_SDL_GetVideoSurface)( void ) = 0;
DFhackCExport void * SDL_GetVideoSurface(void)
2010-02-10 21:56:24 -07:00
{
return _SDL_GetVideoSurface();
}
static void * (*_SDL_DisplayFormat)( void * surface ) = 0;
DFhackCExport void * SDL_DisplayFormat(void *surface)
2010-02-10 21:56:24 -07:00
{
return _SDL_DisplayFormat(surface);
}
2010-01-04 15:20:17 -07:00
static int (*_SDL_GL_GetAttribute)(int attr, int * value) = 0;
DFhackCExport int SDL_GL_GetAttribute(int attr, int * value)
2010-01-04 15:20:17 -07:00
{
return _SDL_GL_GetAttribute(attr,value);
}
static int (*_SDL_GL_SetAttribute)(int attr, int value) = 0;
DFhackCExport int SDL_GL_SetAttribute(int attr, int value)
2010-01-04 15:20:17 -07:00
{
return _SDL_GL_SetAttribute(attr,value);
}
static void (*_SDL_WM_SetCaption)(const char *title, const char *icon) = 0;
DFhackCExport void SDL_WM_SetCaption(const char *title, const char *icon)
2010-01-04 15:20:17 -07:00
{
//_SDL_WM_SetCaption("DwarfHacked the Fortress of Hacks",icon);
_SDL_WM_SetCaption(title,icon);
2010-01-04 15:20:17 -07:00
}
static void (*_SDL_WM_SetIcon)(vPtr icon, uint8_t *mask) = 0;
DFhackCExport void SDL_WM_SetIcon(vPtr icon, uint8_t *mask)
2010-01-04 15:20:17 -07:00
{
_SDL_WM_SetIcon(icon, mask);
}
static int (*_SDL_FillRect)(vPtr dst, vPtr dstrect, uint32_t color) = 0;
DFhackCExport int SDL_FillRect(vPtr dst, vPtr dstrect, uint32_t color)
2010-01-04 15:20:17 -07:00
{
2010-01-10 23:27:59 -07:00
return _SDL_FillRect(dst,dstrect,color);
2010-01-04 15:20:17 -07:00
}
/***** Events and input
SDL_EnableKeyRepeat
int SDLCALL SDL_EnableKeyRepeat(int delay, int interval);
SDL_EnableUNICODE
int SDLCALL SDL_EnableUNICODE(int enable);
SDL_GetKeyState
Uint8 * SDLCALL SDL_GetKeyState(int *numkeys);
SDL_PollEvent
int SDLCALL SDL_PollEvent(SDL_Event *event);
*/
static int (*_SDL_EnableKeyRepeat)(int delay, int interval) = 0;
DFhackCExport int SDL_EnableKeyRepeat(int delay, int interval)
2010-01-04 15:20:17 -07:00
{
return _SDL_EnableKeyRepeat(delay, interval);
}
static int (*_SDL_EnableUNICODE)(int enable) = 0;
DFhackCExport int SDL_EnableUNICODE(int enable)
2010-01-04 15:20:17 -07:00
{
return _SDL_EnableUNICODE(enable);
}
static uint8_t * (*_SDL_GetKeyState)(int* numkeys) = 0;
DFhackCExport uint8_t * SDL_GetKeyState(int* numkeys)
2010-01-04 15:20:17 -07:00
{
return _SDL_GetKeyState(numkeys);
}
static int (*_SDL_PollEvent)(vPtr event) = 0;
DFhackCExport int SDL_PollEvent(vPtr event)
2010-01-04 15:20:17 -07:00
{
return _SDL_PollEvent(event);
}
/***** error handling
SDL_GetError
char * SDLCALL SDL_GetError(void);
SDL_SetError
extern DECLSPEC void SDLCALL SDL_SetError(const char *fmt, ...);
SDL_ClearError
extern DECLSPEC void SDLCALL SDL_ClearError(void);
SDL_Error
extern DECLSPEC void SDLCALL SDL_Error(SDL_errorcode code);
*/
static char * (*_SDL_GetError)(void) = 0;
DFhackCExport char * SDL_GetError(void)
2010-01-04 15:20:17 -07:00
{
return _SDL_GetError();
}
static void (*_SDL_SetError)(const char *fmt, ...) = 0;
DFhackCExport void SDL_SetError(const char *fmt, ...)
2010-01-04 15:20:17 -07:00
{
char buf[1024];
va_list args;
va_start(args,fmt);
vsnprintf(buf, sizeof(buf) - 1 ,fmt,args);
va_end(args);
_SDL_SetError(buf);
}
static void (*_SDL_ClearError)(void) = 0;
DFhackCExport void SDL_ClearError(void)
2010-01-04 15:20:17 -07:00
{
_SDL_ClearError();
}
static void (*_SDL_Error)(int code) = 0;
DFhackCExport void SDL_Error(int code)
2010-01-04 15:20:17 -07:00
{
_SDL_Error(code);
}
/***** symbol resolution
SDL_LoadFunction
extern DECLSPEC void * SDLCALL SDL_LoadFunction(void *handle, const char *name);
SDL_LoadObject
extern DECLSPEC void * SDLCALL SDL_LoadObject(const char *sofile);
SDL_UnloadObject
extern DECLSPEC void SDLCALL SDL_UnloadObject(void *handle);
*/
static vPtr (*_SDL_LoadFunction)(void *handle, const char *name) = 0;
DFhackCExport vPtr SDL_LoadFunction(void *handle, const char *name)
2010-01-04 15:20:17 -07:00
{
return _SDL_LoadFunction(handle, name);
}
static vPtr (*_SDL_LoadObject)(const char *sofile) = 0;
DFhackCExport vPtr SDL_LoadObject(const char *sofile)
2010-01-04 15:20:17 -07:00
{
return _SDL_LoadObject(sofile);
}
static void (*_SDL_UnloadObject)(vPtr handle) = 0;
DFhackCExport void SDL_UnloadObject(vPtr handle)
2010-01-04 15:20:17 -07:00
{
_SDL_UnloadObject(handle);
}
/***** r/w
SDL_ReadBE32
extern DECLSPEC Uint32 SDLCALL SDL_ReadBE32(SDL_RWops *src);
SDL_ReadLE16
extern DECLSPEC Uint16 SDLCALL SDL_ReadLE16(SDL_RWops *src);
SDL_ReadLE32
extern DECLSPEC Uint32 SDLCALL SDL_ReadLE32(SDL_RWops *src);
*/
static uint32_t (*_SDL_ReadBE32)(vPtr src) = 0;
DFhackCExport uint32_t SDL_ReadBE32(vPtr src)
2010-01-04 15:20:17 -07:00
{
return _SDL_ReadBE32(src);
}
static uint16_t (*_SDL_ReadLE16)(vPtr src) = 0;
DFhackCExport uint16_t SDL_ReadLE16(vPtr src)
2010-01-04 15:20:17 -07:00
{
return _SDL_ReadLE16(src);
}
static uint32_t (*_SDL_ReadLE32)(vPtr src) = 0;
DFhackCExport uint32_t SDL_ReadLE32(vPtr src)
2010-01-04 15:20:17 -07:00
{
return _SDL_ReadLE32(src);
}
/***** Misc
SDL_RWFromFile
SDL_RWops * SDLCALL SDL_RWFromFile(const char *file, const char *mode);
SDL_SetModuleHandle
void SDLCALL SDL_SetModuleHandle(void *hInst);
SDL_ShowCursor
int SDLCALL SDL_ShowCursor(int toggle);
SDL_strlcpy
2010-01-04 15:20:17 -07:00
size_t SDLCALL SDL_strlcpy(char *dst, const char *src, size_t maxlen);
*/
static vPtr (*_SDL_RWFromFile)(const char* file, const char *mode) = 0;
DFhackCExport vPtr SDL_RWFromFile(const char* file, const char *mode)
2010-01-04 15:20:17 -07:00
{
return _SDL_RWFromFile(file, mode);
}
static void (*_SDL_SetModuleHandle)(vPtr hInst) = 0;
DFhackCExport void SDL_SetModuleHandle(vPtr hInst)
2010-01-04 15:20:17 -07:00
{
_SDL_SetModuleHandle(hInst);
}
static int (*_SDL_ShowCursor)(int toggle) = 0;
DFhackCExport int SDL_ShowCursor(int toggle)
2010-01-04 15:20:17 -07:00
{
return _SDL_ShowCursor(toggle);
}
static size_t (*_SDL_strlcpy)(char *dst, const char *src, size_t maxlen) = 0;
DFhackCExport size_t SDL_strlcpy(char *dst, const char *src, size_t maxlen)
2010-01-04 15:20:17 -07:00
{
if(!_SDL_strlcpy)
{
HMODULE realSDLlib = LoadLibrary("SDLreal.dll");
_SDL_strlcpy = (size_t (*)(char*, const char*, size_t))GetProcAddress(realSDLlib,"SDL_strlcpy");
}
return _SDL_strlcpy(dst,src,maxlen);
}
/***** The real meat of this
SDL_Init
SDL_Quit
SDL_GL_SwapBuffers
void SDLCALL SDL_GL_SwapBuffers(void);
*/
2010-01-04 15:20:17 -07:00
static void (*_SDL_Quit)(void) = 0;
DFhackCExport void SDL_Quit(void)
2010-01-04 15:20:17 -07:00
{
fprintf(stderr,"Quitting!\n");
2010-01-07 22:52:37 -07:00
SHM_Destroy();
2010-01-04 15:20:17 -07:00
_SDL_Quit();
}
static void (*_SDL_GL_SwapBuffers)(void) = 0;
DFhackCExport void SDL_GL_SwapBuffers(void)
2010-01-04 15:20:17 -07:00
{
2010-03-02 21:43:38 -07:00
if(!errorstate && ((shm_cmd *)shm)->pingpong != CORE_RUNNING)
2010-01-11 11:57:57 -07:00
{
SHM_Act();
}
2010-01-04 15:20:17 -07:00
_SDL_GL_SwapBuffers();
}
2010-02-10 21:56:24 -07:00
// hook - called every tick in the 2D mode of DF
static int (*_SDL_Flip)(void * some_ptr) = 0;
DFhackCExport int SDL_Flip(void * some_ptr)
2010-02-10 21:56:24 -07:00
{
if(_SDL_Flip)
{
2010-03-02 21:43:38 -07:00
if(!errorstate && ((shm_cmd *)shm)->pingpong != CORE_RUNNING)
2010-02-10 21:56:24 -07:00
{
SHM_Act();
}
return _SDL_Flip(some_ptr);
}
return 0;
2010-02-10 21:56:24 -07:00
}
2010-01-04 15:20:17 -07:00
static int (*_SDL_Init)(uint32_t flags) = 0;
DFhackCExport int SDL_Init(uint32_t flags)
2010-01-04 15:20:17 -07:00
{
HMODULE realSDLlib = LoadLibrary("SDLreal.dll");
if(!realSDLlib)
{
MessageBox(0,"Can't load SDLreal.dll\n","Error", MB_OK);
2010-01-04 15:20:17 -07:00
fprintf(stderr, "Can't load SDLreal.dll\n");
return -1;
}
// stuff for DF
_SDL_AddTimer = (void*(*)(uint32_t, void*, void*)) GetProcAddress(realSDLlib,"SDL_AddTimer");
_SDL_CondSignal = (int (*)(void*))GetProcAddress(realSDLlib,"SDL_CondSignal");
_SDL_CondWait = (int (*)(void*, void*))GetProcAddress(realSDLlib,"SDL_CondWait");
_SDL_ConvertSurface = (void*(*)(void*, void*, uint32_t))GetProcAddress(realSDLlib,"SDL_ConvertSurface");
_SDL_CreateCond = (void*(*)())GetProcAddress(realSDLlib,"SDL_CreateCond");
_SDL_CreateMutex = (void*(*)())GetProcAddress(realSDLlib,"SDL_CreateMutex");
_SDL_CreateRGBSurface = (void*(*)(uint32_t, int, int, int, uint32_t, uint32_t, uint32_t, uint32_t))GetProcAddress(realSDLlib,"SDL_CreateRGBSurface");
_SDL_CreateRGBSurfaceFrom = (void*(*)(void*, int, int, int, int, uint32_t, uint32_t, uint32_t, uint32_t))GetProcAddress(realSDLlib,"SDL_CreateRGBSurfaceFrom");
_SDL_DestroyCond = (void (*)(void*))GetProcAddress(realSDLlib,"SDL_DestroyCond");
_SDL_DestroyMutex = (void (*)(void*))GetProcAddress(realSDLlib,"SDL_DestroyMutex");
_SDL_EnableKeyRepeat = (int (*)(int, int))GetProcAddress(realSDLlib,"SDL_EnableKeyRepeat");
_SDL_EnableUNICODE = (int (*)(int))GetProcAddress(realSDLlib,"SDL_EnableUNICODE");
2010-02-10 21:56:24 -07:00
_SDL_GetVideoSurface = (void*(*)())GetProcAddress(realSDLlib,"SDL_GetVideoSurface");
_SDL_DisplayFormat = (void * (*) (void *))GetProcAddress(realSDLlib,"SDL_DisplayFormat");
2010-01-04 15:20:17 -07:00
_SDL_FreeSurface = (void (*)(void*))GetProcAddress(realSDLlib,"SDL_FreeSurface");
_SDL_GL_GetAttribute = (int (*)(int, int*))GetProcAddress(realSDLlib,"SDL_GL_GetAttribute");
_SDL_GL_SetAttribute = (int (*)(int, int))GetProcAddress(realSDLlib,"SDL_GL_SetAttribute");
_SDL_GL_SwapBuffers = (void (*)())GetProcAddress(realSDLlib,"SDL_GL_SwapBuffers");
_SDL_GetError = (char*(*)())GetProcAddress(realSDLlib,"SDL_GetError");
_SDL_GetKeyState = (uint8_t*(*)(int*))GetProcAddress(realSDLlib,"SDL_GetKeyState");
_SDL_GetTicks = (uint32_t (*)())GetProcAddress(realSDLlib,"SDL_GetTicks");
_SDL_GetVideoInfo = (void*(*)())GetProcAddress(realSDLlib,"SDL_GetVideoInfo");
_SDL_Init = (int (*)(uint32_t))GetProcAddress(realSDLlib,"SDL_Init");
2010-02-10 21:56:24 -07:00
_SDL_Flip = (int (*)( void * )) GetProcAddress(realSDLlib, "SDL_Flip");
2010-01-04 15:20:17 -07:00
_SDL_LockSurface = (int (*)(void*))GetProcAddress(realSDLlib,"SDL_LockSurface");
_SDL_MapRGB = (uint32_t (*)(void*, uint8_t, uint8_t, uint8_t))GetProcAddress(realSDLlib,"SDL_MapRGB");
_SDL_PollEvent = (int (*)(void*))GetProcAddress(realSDLlib,"SDL_PollEvent");
_SDL_Quit = (void (*)())GetProcAddress(realSDLlib,"SDL_Quit");
_SDL_RWFromFile = (void*(*)(const char*, const char*))GetProcAddress(realSDLlib,"SDL_RWFromFile");
_SDL_RemoveTimer = (bool (*)(void*))GetProcAddress(realSDLlib,"SDL_RemoveTimer");
_SDL_SaveBMP_RW = (int (*)(void*, void*, int))GetProcAddress(realSDLlib,"SDL_SaveBMP_RW");
_SDL_SetAlpha = (int (*)(void*, uint32_t, uint8_t))GetProcAddress(realSDLlib,"SDL_SetAlpha");
_SDL_SetColorKey = (int (*)(void*, uint32_t, uint32_t))GetProcAddress(realSDLlib,"SDL_SetColorKey");
_SDL_SetModuleHandle = (void (*)(void*))GetProcAddress(realSDLlib,"SDL_SetModuleHandle");
_SDL_SetVideoMode = (void*(*)(int, int, int, uint32_t))GetProcAddress(realSDLlib,"SDL_SetVideoMode");
_SDL_ShowCursor = (int (*)(int))GetProcAddress(realSDLlib,"SDL_ShowCursor");
_SDL_UnlockSurface = (void (*)(void*))GetProcAddress(realSDLlib,"SDL_UnlockSurface");
_SDL_UpperBlit = (int (*)(void*, void*, void*, void*))GetProcAddress(realSDLlib,"SDL_UpperBlit");
_SDL_WM_SetCaption = (void (*)(const char*, const char*))GetProcAddress(realSDLlib,"SDL_WM_SetCaption");
_SDL_WM_SetIcon = (void (*)(void*, uint8_t*))GetProcAddress(realSDLlib,"SDL_WM_SetIcon");
_SDL_mutexP = (int (*)(void*))GetProcAddress(realSDLlib,"SDL_mutexP");
_SDL_strlcpy = (size_t (*)(char*, const char*, size_t))GetProcAddress(realSDLlib,"SDL_strlcpy");
// stuff for SDL_Image
_SDL_ClearError = (void (*)())GetProcAddress(realSDLlib,"SDL_ClearError");
_SDL_Error = (void (*)(int))GetProcAddress(realSDLlib,"SDL_Error");
_SDL_LoadFunction = (void*(*)(void*, const char*))GetProcAddress(realSDLlib,"SDL_LoadFunction");
_SDL_LoadObject = (void*(*)(const char*))GetProcAddress(realSDLlib,"SDL_LoadObject");
_SDL_ReadBE32 = (uint32_t (*)(void*))GetProcAddress(realSDLlib,"SDL_ReadBE32");
_SDL_ReadLE16 = (uint16_t (*)(void*))GetProcAddress(realSDLlib,"SDL_ReadLE16");
_SDL_ReadLE32 = (uint32_t (*)(void*))GetProcAddress(realSDLlib,"SDL_ReadLE32");
_SDL_SetError = (void (*)(const char*, ...))GetProcAddress(realSDLlib,"SDL_SetError");
_SDL_UnloadObject = (void (*)(void*))GetProcAddress(realSDLlib,"SDL_UnloadObject");
_SDL_FillRect = (int (*)(void*,void*,uint32_t))GetProcAddress(realSDLlib,"SDL_FillRect");
fprintf(stderr,"Initized HOOKS!\n");
2010-01-07 22:52:37 -07:00
SHM_Init();
2010-01-04 15:20:17 -07:00
return _SDL_Init(flags);
}