1
0
mirror of https://github.com/DxWnd/DxWnd.reloaded synced 2024-12-30 09:25:35 +01:00

v2_03_99_src

Former-commit-id: c27808ea4ecc17b6cb1142194301389efa4eabe9
This commit is contained in:
gho tik 2016-07-12 12:48:29 -04:00 committed by Refael ACkermann
parent 221a7c720c
commit f37215c5dc
26 changed files with 421 additions and 108 deletions

@ -27,7 +27,7 @@
#define FIXWINFRAME 0x00002000
#define HIDEHWCURSOR 0x00004000
#define SLOWDOWN 0x00008000
#define ENABLECLIPPING 0x00010000
#define DISABLECLIPPING 0x00010000
#define LOCKWINSTYLE 0x00020000
#define MAPGDITOPRIMARY 0x00040000
#define FIXTEXTOUT 0x00080000
@ -254,6 +254,9 @@
#define FORCEVSYNC 0x00000004 // Forces hardware VSync
#define FORCENOVSYNC 0x00000008 // Forces NO hardware VSync
#define VSYNCSCANLINE 0x00000010 // Activates WaitForVerticalBlank algorythm based on reaching a given scan line
#define TRIMTEXTUREFORMATS 0x00000020 // Emulates "DirectXTrimTextureFormats" shim to fix textures in Heavy Gear II
#define NOHALDEVICE 0x00000040 // Simulates a situation of lack of 3D hardware support, like in presence of remote desktop
#define CLIPLOCKED 0x00000080 // never destroy cursor clipper on window move events ....
// logging Tflags DWORD:
#define OUTTRACE 0x00000001 // enables tracing to dxwnd.log in general
@ -354,6 +357,7 @@ void OutTraceHex(BYTE *, int);
void *HookAPI(HMODULE, char *, void *, const char *, void *);
void AdjustWindowFrame(HWND, DWORD, DWORD);
char *hexdump(unsigned char *, int);
void HexTrace(unsigned char *, int);
LRESULT CALLBACK extWindowProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK extChildWindowProc(HWND, UINT, WPARAM, LPARAM);

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:c17fbc2f441f7355d88a7b189dfbba0ab31f0295b6900c1343849006fcce9f68
size 706560
oid sha256:bb1649c75e814ca6706d0e6951fb34ade18b013d75a1c8d2afce83c6c8143042
size 709632

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:4c369251987e49585a3cb5776a808fafe262ccf2d6b0ef0265275ba2080189ac
size 667136
oid sha256:ef6bb4b84f380a5e3e519d08ce9fca17bb67783b32655728f48197f403477976
size 668160

@ -1371,3 +1371,11 @@ fix: fixed CreateDialogIndirectParam and CreateDialogParam wrappers to make inne
fix: recovered DEFAULTMESSAGES option
fix: normalized output for ddraw GetScanLine() method
fix: fixed the policy for redrecting the WindowProc routine. Fixes "Ultimate Spiderman" clipping problems, and possibly much more
v2.03.99
fix: unwanted hook to directsound when passing by CoCreateInstance()
fix: transient mode, now checks for both the target and the launcher to be dead before terminating
add: Direct3D TRIMTEXTUREFORMAT flag, to mimic MS "DirectXTrimTextureFormat" shim. Fixes problems in "Heavy Gear 2" and "Star Wars: Rogue Squardon 3D".
add: D3DDevice GetCaps hooking and full dump of D3DDevice capabilities
add: "No HAL Device" flag, making it unavailable the IID_Direct3DHALDevice device. Fixes "Grand Prix World" when the 3D car models are invisible.
add: reorganization of mouse clipper fields, with the addition of LOCK mode (useful for Tribal Rage)

@ -1555,6 +1555,7 @@ static void HandleCapsD(char *sLabel, LPDDCAPS c)
sLabel, c->dwVidMemTotal, c->dwVidMemFree, c->dwZBufferBitDepths, ExplainZBufferBitDepths(c->dwZBufferBitDepths));
OutTraceDDRAW("GetCaps(%s): MaxVisibleOverlays=%x CurrVisibleOverlays=%x\n",
sLabel, c->dwMaxVisibleOverlays, c->dwCurrVisibleOverlays);
if(IsDebug) HexTrace((unsigned char *)c, c->dwSize);
if(dxw.bHintActive){
if(c->dwVidMemTotal > dwMaxMem) ShowHint(HINT_LIMITMEM);
@ -1591,13 +1592,14 @@ static HRESULT WINAPI extGetCapsD(int dxversion, GetCapsD_Type pGetCapsD, LPDIRE
HRESULT res;
OutTraceDDRAW("GetCaps(D%d): lpdd=%x %s %s\n", dxversion, lpdd, c1?"c1":"NULL", c2?"c2":"NULL");
res=(*pGetCapsD)(lpdd, c1, c2);
if(res)
if(res) {
OutTraceE("GetCaps(D): ERROR res=%x(%s)\n", res, ExplainDDError(res));
else {
if (c1) HandleCapsD("D-HW", c1);
if (c2) HandleCapsD("D-SW", c2);
return res;
}
if (c1) HandleCapsD("D-HW", c1);
if (c2) HandleCapsD("D-SW", c2);
if((dxw.dwFlags3 & FORCESHEL) && c1) {
DDCAPS_DX7 swcaps; // DDCAPS_DX7 because it is the bigger in size
int size;
@ -1619,6 +1621,20 @@ static HRESULT WINAPI extGetCapsD(int dxversion, GetCapsD_Type pGetCapsD, LPDIRE
if (c2) HandleCapsD("D-SW(fixed)", c2);
}
if((dxw.dwFlags8 & NOHALDEVICE) && c1) {
OutTraceDW("GetCaps(D): NOHALDEVICE\n");
c1->ddsCaps.dwCaps = DDCAPS_NOHARDWARE;
c1->ddsCaps.dwCaps2 = DDCAPS2_CANRENDERWINDOWED;
c1->dwPalCaps = 0;
c1->dwFXCaps = 0;
c1->dwFXAlphaCaps = 0;
c1->dwCKeyCaps = 0;
c1->dwVidMemTotal = c1->dwVidMemFree = 0;
c1->dwZBufferBitDepths = 0;
c1->dwMaxVisibleOverlays = c1->dwCurrVisibleOverlays = 0;
HandleCapsD("D-HW(NoHAL)", c1);
}
if((dxw.dwFlags3 & MINIMALCAPS)) SetMinimalCaps(c1, c2);
if(dxw.dwFlags3 & CAPMASK) MaskCapsD(c1, c2);
@ -2602,6 +2618,13 @@ HRESULT WINAPI extGetAttachedSurface(int dxversion, GetAttachedSurface_Type pGet
return DDERR_NOTFOUND;
}
}
if((dxw.dwFlags8 & NOHALDEVICE) && (lpddsc->dwCaps & DDSCAPS_ZBUFFER)){
// tested with "Grand Prix World": if a ZBUFFER is returned, CreateDevice fails!
*lplpddas = NULL;
OutTraceDW("GetAttachedSurface(%d): NOHALDEVICE no attached ZBUFFER\n", dxversion);
return DDERR_NOTFOUND;
}
}
else {
// Virtual primary surfaces are created with no DDSCAPS_3DDEVICE caps, so don't look for it ....
@ -4797,6 +4820,7 @@ static HRESULT WINAPI extGetCapsS(int dxInterface, GetCapsS_Type pGetCapsS, LPDI
caps->dwCaps |= (DDSCAPS_BACKBUFFER|DDSCAPS_VIDEOMEMORY|DDSCAPS_FLIP|DDSCAPS_LOCALVIDMEM); // you never know....
caps->dwCaps &= ~(DDSCAPS_SYSTEMMEMORY|DDSCAPS_OFFSCREENPLAIN); // backbuffer surfaces can't be this way
if(caps->dwCaps & DDSCAPS_3DDEVICE) caps->dwCaps |= DDSCAPS_LOCALVIDMEM;
//if(caps->dwCaps & DDSCAPS_3DDEVICE) caps->dwCaps |= (DDSCAPS_LOCALVIDMEM | DDSCAPS_COMPLEX);
}
// v2.03.82: fixed logic for ZBUFFER capabilities: "The Creed" may have two, in SYSTEMMEMORY or in VIDEOMEMORY ...

@ -73,6 +73,8 @@ void HookDirectSoundInit()
void HookDirectSoundObj(LPDIRECTSOUND *lpds)
{
// v2.03.99: check or DirectSound could be hooked through CoCreateInstance !!
if(!(dxw.dwFlags7 & HOOKDIRECTSOUND)) return;
// IDIrectSound::SetCooperativeLevel
SetHook((void *)(**(DWORD **)lpds + 12), extCreateSoundBuffer, (void **)&pCreateSoundBuffer, "CreateSoundBuffer");
SetHook((void *)(**(DWORD **)lpds + 24), extDSSetCooperativeLevel, (void **)&pDSSetCooperativeLevel, "SetCooperativeLevel(DSound)");

@ -67,7 +67,7 @@ static char *FlagNames[32]={
"HOOKDI", "MODIFYMOUSE", "HANDLEEXCEPTIONS", "SAVELOAD",
"EMULATEBUFFER", "HOOKDI8", "BLITFROMBACKBUFFER", "SUPPRESSCLIPPING",
"AUTOREFRESH", "FIXWINFRAME", "HIDEHWCURSOR", "SLOWDOWN",
"ENABLECLIPPING", "LOCKWINSTYLE", "MAPGDITOPRIMARY", "FIXTEXTOUT",
"DISABLECLIPPING", "LOCKWINSTYLE", "MAPGDITOPRIMARY", "FIXTEXTOUT",
"KEEPCURSORWITHIN", "USERGB565", "SUPPRESSDXERRORS", "PREVENTMAXIMIZE",
"LOCKEDSURFACE", "FIXPARENTWIN", "SWITCHVIDEOMEMORY", "CLIENTREMAPPING",
"HANDLEALTF4", "LOCKWINPOS", "HOOKCHILDWIN", "MESSAGEPROC"
@ -141,7 +141,7 @@ static char *Flag7Names[32]={
static char *Flag8Names[32]={
"FORCEWAIT", "FORCENOWAIT", "FORCEVSYNC", "FORCENOVSYNC",
"VSYNCSCANLINES", "", "", "",
"VSYNCSCANLINES", "TRIMTEXTUREFORMATS", "NOHALDEVICE", "CLIPLOCK",
"", "", "", "",
"", "", "", "",
"", "", "", "",
@ -277,6 +277,23 @@ void OutTrace(const char *format, ...)
dxw.dwTFlags = tFlags; // restore settings
}
void HexTrace(unsigned char *buf, int len)
{
char line[3*32 + 40];
char hex[6];
int count=0;
while(len){
sprintf(line,"%04X: ", count);
for(int i=32; i && len; i--, len--, buf++){
sprintf(hex, "%02X.", *buf);
strcat(line, hex);
}
strcat(line, "\n");
OutTrace(line);
count += 32;
}
}
// from MSDN:
// GetVersionEx may be altered or unavailable for releases after Windows 8.1. Instead, use the Version Helper functions
//

@ -363,7 +363,7 @@ POINT dxwCore::FixCursorPos(POINT prev)
if (h) curr.y = (curr.y * dxw.GetScreenHeight()) / h;
}
if((dxw.dwFlags1 & ENABLECLIPPING) && lpClipRegion){
if((dxw.dwFlags1 & DISABLECLIPPING) && lpClipRegion){
// v2.1.93:
// in clipping mode, avoid the cursor position to lay outside the valid rect
// note 1: the rect follow the convention and valid coord lay between left to righ-1,

@ -27,7 +27,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "TlHelp32.h"
#define VERSION "2.03.98.fx1"
#define VERSION "2.03.99"
#define DDTHREADLOCK 1
//#define LOCKTHREADS

Binary file not shown.

@ -45,6 +45,7 @@ typedef HRESULT (WINAPI *CreateDevice2_Type)(void *, REFCLSID, LPDIRECTDRAWSURFA
typedef HRESULT (WINAPI *CreateDevice3_Type)(void *, REFCLSID, LPDIRECTDRAWSURFACE4, LPDIRECT3DDEVICE3 *, LPUNKNOWN);
typedef HRESULT (WINAPI *CreateDevice7_Type)(void *, REFCLSID, LPDIRECTDRAWSURFACE7, LPDIRECT3DDEVICE7 *);
typedef HRESULT (WINAPI *EnumZBufferFormats_Type)(void *, REFCLSID, LPD3DENUMPIXELFORMATSCALLBACK, LPVOID);
typedef HRESULT (WINAPI *EnumTextureFormats_Type)(void *, LPD3DENUMPIXELFORMATSCALLBACK, LPVOID);
QueryInterfaceD3_Type pQueryInterfaceD31 = NULL;
QueryInterfaceD3_Type pQueryInterfaceD32 = NULL;
@ -73,6 +74,8 @@ CreateDevice7_Type pCreateDevice7 = NULL;
EnumZBufferFormats_Type pEnumZBufferFormats3 = NULL;
EnumZBufferFormats_Type pEnumZBufferFormats7 = NULL;
EnumTextureFormats_Type pEnumTextureFormats1, pEnumTextureFormats2, pEnumTextureFormats3, pEnumTextureFormats7;
HRESULT WINAPI extQueryInterfaceD31(void *, REFIID, LPVOID *);
HRESULT WINAPI extQueryInterfaceD32(void *, REFIID, LPVOID *);
HRESULT WINAPI extQueryInterfaceD33(void *, REFIID, LPVOID *);
@ -88,13 +91,18 @@ HRESULT WINAPI extCreateLight3(void *, LPDIRECT3DLIGHT *, IUnknown *);
HRESULT WINAPI extEnumZBufferFormats3(void *, REFCLSID, LPD3DENUMPIXELFORMATSCALLBACK, LPVOID);
HRESULT WINAPI extEnumZBufferFormats7(void *, REFCLSID, LPD3DENUMPIXELFORMATSCALLBACK, LPVOID);
HRESULT WINAPI extEnumTextureFormats1(void *, LPD3DENUMPIXELFORMATSCALLBACK, LPVOID);
HRESULT WINAPI extEnumTextureFormats2(void *, LPD3DENUMPIXELFORMATSCALLBACK, LPVOID);
HRESULT WINAPI extEnumTextureFormats3(void *, LPD3DENUMPIXELFORMATSCALLBACK, LPVOID);
HRESULT WINAPI extEnumTextureFormats7(void *, LPD3DENUMPIXELFORMATSCALLBACK, LPVOID);
// Direct3DDevice-n interfaces
typedef ULONG (WINAPI *ReleaseD3D_Type)(LPDIRECT3DDEVICE);
typedef HRESULT (WINAPI *QueryInterfaceD3D_Type)(void *, REFIID, LPVOID *);
typedef HRESULT (WINAPI *D3DInitialize_Type)(void *, LPDIRECT3D , LPGUID, LPD3DDEVICEDESC);
typedef HRESULT (WINAPI *D3DGetCaps_Type)(void *, LPD3DDEVICEDESC ,LPD3DDEVICEDESC);
typedef HRESULT (WINAPI *D3DGetCaps3_Type)(void *, LPD3DDEVICEDESC, LPD3DDEVICEDESC);
typedef HRESULT (WINAPI *D3DGetCaps7_Type)(void *, LPD3DDEVICEDESC7);
typedef HRESULT (WINAPI *AddViewport1_Type)(void *, LPDIRECT3DVIEWPORT);
typedef HRESULT (WINAPI *AddViewport2_Type)(void *, LPDIRECT3DVIEWPORT2);
typedef HRESULT (WINAPI *AddViewport3_Type)(void *, LPDIRECT3DVIEWPORT3);
@ -115,8 +123,8 @@ typedef HRESULT (WINAPI *SwapTextureHandles2_Type)(void *, LPDIRECT3DTEXTURE2, L
QueryInterfaceD3_Type pQueryInterfaceD3D = NULL;
ReleaseD3D_Type pReleaseD3D1, pReleaseD3D2, pReleaseD3D3, pReleaseD3D7;
D3DInitialize_Type pD3DInitialize = NULL;
D3DGetCaps_Type pD3DGetCaps = NULL;
D3DGetCaps3_Type pGetCaps3 = NULL;
D3DGetCaps_Type pD3DGetCaps1, pD3DGetCaps2, pD3DGetCaps3;
D3DGetCaps7_Type pD3DGetCaps7;
AddViewport1_Type pAddViewport1 = NULL;
AddViewport2_Type pAddViewport2 = NULL;
AddViewport3_Type pAddViewport3 = NULL;
@ -225,7 +233,6 @@ HRESULT WINAPI extQueryInterfaceD3(void *, REFIID, LPVOID *);
HRESULT WINAPI extQueryInterfaceD3D(void *, REFIID, LPVOID *);
HRESULT WINAPI extD3DInitialize(void *, LPDIRECT3D , LPGUID, LPD3DDEVICEDESC);
HRESULT WINAPI extD3DGetCaps(void *, LPD3DDEVICEDESC ,LPD3DDEVICEDESC);
ULONG WINAPI extReleaseD3D1(LPDIRECT3DDEVICE);
ULONG WINAPI extReleaseD3D2(LPDIRECT3DDEVICE);
@ -242,7 +249,10 @@ HRESULT WINAPI extEndScene7(void *);
HRESULT WINAPI extSetRenderState2(void *, D3DRENDERSTATETYPE, DWORD);
HRESULT WINAPI extSetRenderState3(void *, D3DRENDERSTATETYPE, DWORD);
HRESULT WINAPI extSetRenderState7(void *, D3DRENDERSTATETYPE, DWORD);
HRESULT WINAPI extGetCaps3(void *, LPD3DDEVICEDESC, LPD3DDEVICEDESC);
HRESULT WINAPI extD3DGetCaps1(void *, LPD3DDEVICEDESC, LPD3DDEVICEDESC);
HRESULT WINAPI extD3DGetCaps2(void *, LPD3DDEVICEDESC, LPD3DDEVICEDESC);
HRESULT WINAPI extD3DGetCaps3(void *, LPD3DDEVICEDESC, LPD3DDEVICEDESC);
HRESULT WINAPI extD3DGetCaps7(void *, LPD3DDEVICEDESC7);
HRESULT WINAPI extSetLightState3(void *d3dd, D3DLIGHTSTATETYPE d3dls, DWORD t);
HRESULT WINAPI extSetViewport3(void *, LPD3DVIEWPORT);
HRESULT WINAPI extGetViewport3(void *, LPD3DVIEWPORT);
@ -494,24 +504,26 @@ void HookDirect3DDevice(void **lpd3ddev, int d3dversion)
case 1:
SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D, (void **)&pQueryInterfaceD3D, "QueryInterface(D3D)");
SetHook((void *)(**(DWORD **)lpd3ddev + 8), extReleaseD3D1, (void **)&pReleaseD3D1, "ReleaseD3D(1)");
//SetHook((void *)(**(DWORD **)lpd3ddev + 16), extGetCaps1, (void **)&pGetCaps1, "GetCaps(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 16), extD3DGetCaps1, (void **)&pD3DGetCaps1, "GetCaps(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 20), extSwapTextureHandles, (void **)&pSwapTextureHandles, "SwapTextureHandles(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 32), extExecute, (void **)&pExecute, "Execute(1)");
//SetHook((void *)(**(DWORD **)lpd3ddev + 32), extExecute, NULL, "Execute(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 36), extAddViewport1, (void **)&pAddViewport1, "AddViewport(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 40), extDeleteViewport1, (void **)&pDeleteViewport1, "DeleteViewport(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 44), extNextViewport1, (void **)&pNextViewport1, "NextViewport(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 56), extEnumTextureFormats1, (void **)&pEnumTextureFormats1, "EnumTextureFormats(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 76), extBeginScene1, (void **)&pBeginScene1, "BeginScene(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 80), extEndScene1, (void **)&pEndScene1, "EndScene(1)");
break;
case 2:
SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D, (void **)&pQueryInterfaceD3D, "QueryInterface(D3D)");
SetHook((void *)(**(DWORD **)lpd3ddev + 8), extReleaseD3D2, (void **)&pReleaseD3D2, "ReleaseD3D(2)");
//SetHook((void *)(**(DWORD **)lpd3ddev + 12), extGetCaps2, (void **)&pGetCaps2, "GetCaps(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 16), extSwapTextureHandles, (void **)&pSwapTextureHandles, "SwapTextureHandles(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 12), extD3DGetCaps2, (void **)&pD3DGetCaps2, "GetCaps(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 16), extSwapTextureHandles, (void **)&pSwapTextureHandles, "SwapTextureHandles(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 24), extAddViewport2, (void **)&pAddViewport2, "AddViewport(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 28), extDeleteViewport2, (void **)&pDeleteViewport2, "DeleteViewport(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 32), extNextViewport2, (void **)&pNextViewport2, "NextViewport(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 36), extEnumTextureFormats2, (void **)&pEnumTextureFormats2, "EnumTextureFormats(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 40), extBeginScene2, (void **)&pBeginScene2, "BeginScene(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 44), extEndScene2, (void **)&pEndScene2, "EndScene(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 52), extSetCurrentViewport2, (void **)&pSetCurrentViewport2, "SetCurrentViewport(2)");
@ -526,8 +538,9 @@ void HookDirect3DDevice(void **lpd3ddev, int d3dversion)
case 3:
SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D, (void **)&pQueryInterfaceD3D, "QueryInterface(D3D)");
SetHook((void *)(**(DWORD **)lpd3ddev + 8), extReleaseD3D3, (void **)&pReleaseD3D3, "ReleaseD3D(3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 12), extGetCaps3, (void **)&pGetCaps3, "GetCaps(3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 12), extD3DGetCaps3, (void **)&pD3DGetCaps3, "GetCaps(3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 20), extAddViewport3, (void **)&pAddViewport3, "AddViewport(3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 32), extEnumTextureFormats3, (void **)&pEnumTextureFormats3, "EnumTextureFormats(3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 36), extBeginScene3, (void **)&pBeginScene3, "BeginScene(3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 40), extEndScene3, (void **)&pEndScene3, "EndScene(3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 48), extSetCurrentViewport3, (void **)&pSetCurrentViewport3, "SetCurrentViewport(3)");
@ -544,6 +557,8 @@ void HookDirect3DDevice(void **lpd3ddev, int d3dversion)
case 7:
//SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D, (void **)&pQueryInterfaceD3D, "QueryInterface(D3D)");
SetHook((void *)(**(DWORD **)lpd3ddev + 8), extReleaseD3D7, (void **)&pReleaseD3D7, "ReleaseD3D(7)");
SetHook((void *)(**(DWORD **)lpd3ddev + 12), extD3DGetCaps7, (void **)&pD3DGetCaps7, "GetCaps(7)");
SetHook((void *)(**(DWORD **)lpd3ddev + 16), extEnumTextureFormats7, (void **)&pEnumTextureFormats7, "EnumTextureFormats(7)");
SetHook((void *)(**(DWORD **)lpd3ddev + 20), extBeginScene7, (void **)&pBeginScene7, "BeginScene(7)");
SetHook((void *)(**(DWORD **)lpd3ddev + 24), extEndScene7, (void **)&pEndScene7, "EndScene(7)");
//SetHook((void *)(**(DWORD **)lpd3ddev + 52), extSetViewport7, (void **)&pSetViewport7, "SetViewport(7)");
@ -785,7 +800,7 @@ typedef struct {
LPVOID arg;
} CallbackArg7;
static void DumpD3DDevideDesc(LPD3DDEVICEDESC d3, char *label)
static void DumpD3DDeviceDesc(LPD3DDEVICEDESC d3, char *label)
{
if(IsTraceD3D){
if(d3){
@ -802,7 +817,34 @@ static void DumpD3DDevideDesc(LPD3DDEVICEDESC d3, char *label)
if(d3->dwFlags & D3DDD_MAXBUFFERSIZE) OutTrace("MaxBufferSize=%d ", d3->dwMaxBufferSize);
if(d3->dwFlags & D3DDD_MAXVERTEXCOUNT) OutTrace("MaxVertexCount=%d ", d3->dwMaxVertexCount);
OutTrace("Texture min=(%dx%d) max=(%dx%d)\n", d3->dwMinTextureWidth, d3->dwMinTextureHeight, d3->dwMaxTextureWidth, d3->dwMaxTextureHeight);
HexTrace((unsigned char *)d3, d3->dwSize);
}
else
OutTrace("EnumDevices: CALLBACK dev=%s ddesc=NULL\n", label);
}
}
static void DumpD3DPrimCaps(char *label, D3DPRIMCAPS *pc)
{
OutTrace("%s={siz=%d Misc=%x Raster=%x ZCmp=%x SrcBlend=%x DestBlend=%x AlphaCmp=%x Shade=%x Tex=%x TexFil=%x TexBlend=%x TexAddr=%x Stipple=(%dx%d)} ",
label,
pc->dwSize, pc->dwMiscCaps, pc->dwRasterCaps, pc->dwZCmpCaps, pc->dwSrcBlendCaps, pc->dwDestBlendCaps, pc->dwAlphaCmpCaps,
pc->dwShadeCaps, pc->dwTextureCaps, pc->dwTextureFilterCaps, pc->dwTextureBlendCaps, pc->dwTextureAddressCaps,
pc->dwStippleWidth, pc->dwStippleHeight);
}
static void DumpD3DDeviceDesc7(LPD3DDEVICEDESC7 d3, char *label)
{
if(IsTraceD3D){
if(d3){
OutTrace("EnumDevices: CALLBACK dev=%s DevCaps=%x ", label, d3->dwDevCaps);
DumpD3DPrimCaps("LineCaps", &d3->dpcLineCaps);
DumpD3DPrimCaps("TriCaps", &d3->dpcLineCaps);
OutTrace("RenderBitDepth=%d ZBufferBitDepth", d3->dwDeviceRenderBitDepth, d3->dwDeviceZBufferBitDepth);
OutTrace("Texture min=(%dx%d) max=(%dx%d)\n", d3->dwMinTextureWidth, d3->dwMinTextureHeight, d3->dwMaxTextureWidth, d3->dwMaxTextureHeight);
// to be completed ....
//OutTrace("\n");
HexTrace((unsigned char *)d3, sizeof(D3DDEVICEDESC7));
}
else
OutTrace("EnumDevices: CALLBACK dev=%s ddesc=NULL\n", label);
@ -813,8 +855,16 @@ HRESULT WINAPI extDeviceProxy(GUID FAR *lpGuid, LPSTR lpDeviceDescription, LPSTR
{
HRESULT res;
OutTraceD3D("EnumDevices: CALLBACK GUID=%x(%s) DeviceDescription=\"%s\", DeviceName=\"%s\", arg=%x\n", lpGuid->Data1, ExplainGUID(lpGuid), lpDeviceDescription, lpDeviceName, ((CallbackArg *)arg)->arg);
DumpD3DDevideDesc(lpd3ddd1, "HWDEV");
DumpD3DDevideDesc(lpd3ddd2, "SWDEV");
DumpD3DDeviceDesc(lpd3ddd1, "HWDEV");
DumpD3DDeviceDesc(lpd3ddd2, "SWDEV");
// IID_IDirect3DHALDevice = 0x84e63de0....
if((dxw.dwFlags8 & NOHALDEVICE) && (lpGuid->Data1 == 0x84e63de0))
{
OutTraceDW("EnumDevices: D3DHALDEVICE SKIP\n");
return TRUE;
}
if(dxw.dwFlags4 & NOPOWER2FIX){
D3DDEVICEDESC lpd3ddd1fix, lpd3ddd2fix;
if(lpd3ddd1) memcpy(&lpd3ddd1fix, lpd3ddd1, sizeof(D3DDEVICEDESC));
@ -836,7 +886,10 @@ HRESULT WINAPI extDeviceProxy7(LPSTR lpDeviceDescription, LPSTR lpDeviceName, LP
{
HRESULT res;
OutTraceD3D("EnumDevices(D3D7): CALLBACK DeviceDescription=\"%s\", DeviceName=\"%s\", arg=%x\n", lpDeviceDescription, lpDeviceName, ((CallbackArg *)arg)->arg);
DumpD3DDevideDesc((LPD3DDEVICEDESC)lpd3ddd, "DEV");
DumpD3DDeviceDesc((LPD3DDEVICEDESC)lpd3ddd, "DEV");
// to do: NOHALDEVICE handling, we have no GUID here!
if(dxw.dwFlags4 & NOPOWER2FIX){
D3DDEVICEDESC7 lpd3dddfix;
if(lpd3ddd) memcpy(&lpd3dddfix, lpd3ddd, sizeof(D3DDEVICEDESC7));
@ -1000,8 +1053,8 @@ static HRESULT WINAPI extFindDevice(int d3dversion, FindDevice_Type pFindDevice,
if(res) OutTraceE("FindDevice ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else {
OutTraceD3D("FindDevice: GUID=%x.%x.%x.%x\n", p2->guid.Data1, p2->guid.Data2, p2->guid.Data3, p2->guid.Data4);
DumpD3DDevideDesc(&(p2->ddHwDesc), "HWDEV");
DumpD3DDevideDesc(&(p2->ddSwDesc), "SWDEV");
DumpD3DDeviceDesc(&(p2->ddHwDesc), "HWDEV");
DumpD3DDeviceDesc(&(p2->ddSwDesc), "SWDEV");
}
return res;
}
@ -1071,6 +1124,12 @@ HRESULT WINAPI extInitializeVP(void *lpvp, LPDIRECT3D lpd3d)
return res;
}
#ifndef D3DERR_NOTAVAILABLE
#define _FACD3D 0x876
#define D3DERR_NOTAVAILABLE MAKE_HRESULT(1, _FACD3D, 2154)
#endif
HRESULT WINAPI extCreateDevice2(void *lpd3d, REFCLSID Guid, LPDIRECTDRAWSURFACE lpdds, LPDIRECT3DDEVICE2 *lplpd3dd)
{
HRESULT res;
@ -1078,6 +1137,11 @@ HRESULT WINAPI extCreateDevice2(void *lpd3d, REFCLSID Guid, LPDIRECTDRAWSURFACE
OutTraceD3D("CreateDevice(D3D2): d3d=%x GUID=%x(%s) lpdds=%x%s\n",
lpd3d, Guid.Data1, ExplainGUID((GUID *)&Guid), lpdds, dxwss.ExplainSurfaceRole((LPDIRECTDRAWSURFACE)lpdds));
if((dxw.dwFlags8 & NOHALDEVICE) && (Guid.Data1 == 0x84e63de0)) {
OutTraceDW("CreateDevice(D3D2): D3DHALDEVICE SKIP\n");
return D3DERR_NOTAVAILABLE;
}
res=(*pCreateDevice2)(lpd3d, Guid, lpdds, lplpd3dd);
if(res!=DD_OK) {
OutTraceE("CreateDevice(D3D2) ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
@ -1097,6 +1161,11 @@ HRESULT WINAPI extCreateDevice3(void *lpd3d, REFCLSID Guid, LPDIRECTDRAWSURFACE4
OutTraceD3D("CreateDevice(D3D3): d3d=%x GUID=%x(%s) lpdds=%x%s\n",
lpd3d, Guid.Data1, ExplainGUID((GUID *)&Guid), lpdds, dxwss.ExplainSurfaceRole((LPDIRECTDRAWSURFACE)lpdds));
if((dxw.dwFlags8 & NOHALDEVICE) && (Guid.Data1 == 0x84e63de0)) {
OutTraceDW("CreateDevice(D3D3): D3DHALDEVICE SKIP\n");
return D3DERR_NOTAVAILABLE;
}
res=(*pCreateDevice3)(lpd3d, Guid, lpdds, lplpd3dd, unk);
if(res!=DD_OK) {
OutTraceE("CreateDevice(D3D3) ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
@ -1137,18 +1206,7 @@ HRESULT WINAPI extD3DInitialize(void *d3dd, LPDIRECT3D lpd3d, LPGUID lpGuid, LPD
OutTraceD3D("Initialize: d3dd=%x lpd3d=%x GUID=%x lpd3ddd=%x\n", d3dd, lpd3d, lpGuid->Data1, lpd3dd);
res=(*pD3DInitialize)(d3dd, lpd3d, lpGuid, lpd3dd);
if(res) OutTraceE("Initialize ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
DumpD3DDevideDesc(lpd3dd, "INIT");
return res;
}
HRESULT WINAPI extD3DGetCaps(void *d3dd, LPD3DDEVICEDESC lpd3dd ,LPD3DDEVICEDESC lpd3dd2)
{
HRESULT res;
OutTraceD3D("GetCaps(D3D): d3dd=%x lpd3dd=%x lpd3dd2=%x \n", d3dd, lpd3dd, lpd3dd2);
res=(*pD3DGetCaps)(d3dd, lpd3dd, lpd3dd2);
if(res) OutTraceE("GetCaps(D3D) ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
DumpD3DDevideDesc(lpd3dd, "HWDEV");
DumpD3DDevideDesc(lpd3dd2, "SWDEV");
DumpD3DDeviceDesc(lpd3dd, "INIT");
return res;
}
@ -1368,21 +1426,27 @@ HRESULT WINAPI extEndScene7(void *d3dd)
return res;
}
HRESULT WINAPI extGetCaps3(void *d3dd, LPD3DDEVICEDESC hd, LPD3DDEVICEDESC sd)
HRESULT WINAPI extD3DGetCaps(int d3dversion, D3DGetCaps_Type pD3DGetCaps, void *d3dd, LPD3DDEVICEDESC hd, LPD3DDEVICEDESC sd)
{
HRESULT res;
OutTraceD3D("GetCaps(3): d3dd=%x hd=%x sd=%x\n", d3dd, hd, sd);
res=(*pGetCaps3)(d3dd, hd, sd);
OutTraceD3D("GetCaps(D3D%d): d3dd=%x hd=%x sd=%x\n", d3dversion, d3dd, hd, sd);
res=(*pD3DGetCaps)(d3dd, hd, sd);
if(res) {
OutTraceE("GetCaps(3): res=%x(%s)\n", res, ExplainDDError(res));
OutTraceE("GetCaps(D3D): ERROR res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
DumpD3DDeviceDesc(hd, "HWDEV");
DumpD3DDeviceDesc(sd, "SWDEV");
if(dxw.dwFlags4 & NOPOWER2FIX){
if(hd) {
OutTraceDW("GetCaps(D3D): Fixing NOPOWER2FIX hw caps\n");
hd->dpcLineCaps.dwTextureCaps|=D3DPTEXTURECAPS_NONPOW2CONDITIONAL|D3DPTEXTURECAPS_POW2;
hd->dpcTriCaps.dwTextureCaps|=D3DPTEXTURECAPS_NONPOW2CONDITIONAL|D3DPTEXTURECAPS_POW2;
}
if(sd) {
OutTraceDW("GetCaps(D3D): Fixing NOPOWER2FIX sw caps\n");
sd->dpcLineCaps.dwTextureCaps|=D3DPTEXTURECAPS_NONPOW2CONDITIONAL|D3DPTEXTURECAPS_POW2;
sd->dpcTriCaps.dwTextureCaps|=D3DPTEXTURECAPS_NONPOW2CONDITIONAL|D3DPTEXTURECAPS_POW2;
}
@ -1390,6 +1454,35 @@ HRESULT WINAPI extGetCaps3(void *d3dd, LPD3DDEVICEDESC hd, LPD3DDEVICEDESC sd)
return res;
}
HRESULT WINAPI extD3DGetCaps1(void *d3dd, LPD3DDEVICEDESC hd, LPD3DDEVICEDESC sd)
{ return extD3DGetCaps(1, pD3DGetCaps1, d3dd, hd, sd); }
HRESULT WINAPI extD3DGetCaps2(void *d3dd, LPD3DDEVICEDESC hd, LPD3DDEVICEDESC sd)
{ return extD3DGetCaps(2, pD3DGetCaps2, d3dd, hd, sd); }
HRESULT WINAPI extD3DGetCaps3(void *d3dd, LPD3DDEVICEDESC hd, LPD3DDEVICEDESC sd)
{ return extD3DGetCaps(3, pD3DGetCaps3, d3dd, hd, sd); }
HRESULT WINAPI extD3DGetCaps7(void *d3dd, LPD3DDEVICEDESC7 lpd3ddd)
{
HRESULT res;
OutTraceD3D("GetCaps(D3D7): d3dd=%x lpd3ddd=%x\n", d3dd, lpd3ddd);
res=(*pD3DGetCaps7)(d3dd, lpd3ddd);
if(res) {
OutTraceE("GetCaps(D3D): ERROR res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
DumpD3DDeviceDesc7(lpd3ddd, "DEV7");
if(dxw.dwFlags4 & NOPOWER2FIX){
if(lpd3ddd) {
OutTraceDW("GetCaps(D3D): Fixing NOPOWER2FIX hw caps\n");
lpd3ddd->dpcLineCaps.dwTextureCaps|=D3DPTEXTURECAPS_NONPOW2CONDITIONAL|D3DPTEXTURECAPS_POW2;
lpd3ddd->dpcTriCaps.dwTextureCaps|=D3DPTEXTURECAPS_NONPOW2CONDITIONAL|D3DPTEXTURECAPS_POW2;
}
}
return res;
}
HRESULT WINAPI extSetLightState3(void *d3dd, D3DLIGHTSTATETYPE d3dls, DWORD t)
{
HRESULT res;
@ -1787,33 +1880,90 @@ HRESULT WINAPI extTexUnload(void *t)
typedef struct {
LPD3DENUMPIXELFORMATSCALLBACK *cb;
LPVOID arg;
} CallbackZBufArg;
} CallbackPixFmtArg;
HRESULT WINAPI extZBufferProxy(LPDDPIXELFORMAT lpDDPixFmt, LPVOID lpContext)
{
HRESULT res;
OutTraceD3D("EnumZBufferFormats: CALLBACK context=%x %s \n", ((CallbackZBufArg *)lpContext)->arg, ExplainPixelFormat(lpDDPixFmt));
res = (*(((CallbackZBufArg *)lpContext)->cb))(lpDDPixFmt, ((CallbackZBufArg *)lpContext)->arg);
OutTraceD3D("EnumZBufferFormats: CALLBACK context=%x %s \n", ((CallbackPixFmtArg *)lpContext)->arg, ExplainPixelFormat(lpDDPixFmt));
res = (*(((CallbackPixFmtArg *)lpContext)->cb))(lpDDPixFmt, ((CallbackPixFmtArg *)lpContext)->arg);
OutTraceD3D("EnumZBufferFormats: CALLBACK ret=%x\n", res);
return res;
}
static HRESULT WINAPI extEnumZBufferFormats(EnumZBufferFormats_Type pEnumZBufferFormats, void *lpd3d, REFCLSID riidDevice, LPD3DENUMPIXELFORMATSCALLBACK lpEnumCallback, LPVOID lpContext)
#define MAXPFTABLESIZE 50
#define MAXTRIMMEDENTRIES 3
typedef struct {
int nEntries;
// LPDDPIXELFORMAT lpPixelFormatEntries;
DDPIXELFORMAT lpPixelFormatEntries[MAXPFTABLESIZE];
} PixelFormatTable_Type;
HRESULT WINAPI FillPixelFormatTable(LPDDPIXELFORMAT lpDDPixFmt, LPVOID Arg)
{
PixelFormatTable_Type *lpPixelFormatTable = (PixelFormatTable_Type *)Arg;
OutTraceD3D("EnumZBufferFormats: FILL CALLBACK entry=%d %s\n", lpPixelFormatTable->nEntries, ExplainPixelFormat(lpDDPixFmt));
if(lpPixelFormatTable->nEntries >= MAXPFTABLESIZE) return FALSE;
memcpy((LPVOID)&(lpPixelFormatTable->lpPixelFormatEntries[lpPixelFormatTable->nEntries]), (LPVOID)lpDDPixFmt, sizeof(DDPIXELFORMAT));
lpPixelFormatTable->nEntries ++;
//lpPixelFormatTable->lpPixelFormatEntries = (LPDDPIXELFORMAT)realloc((LPVOID)(lpPixelFormatTable->lpPixelFormatEntries), lpPixelFormatTable->nEntries * sizeof(DDPIXELFORMAT));
//OutTrace("lp=%x err=%s\n", lpPixelFormatTable->lpPixelFormatEntries, GetLastError());
return TRUE;
}
static HRESULT WINAPI extEnumZBufferFormats(int d3dversion, EnumZBufferFormats_Type pEnumZBufferFormats, void *lpd3d, REFCLSID riidDevice, LPD3DENUMPIXELFORMATSCALLBACK lpEnumCallback, LPVOID lpContext)
{
HRESULT ret;
CallbackZBufArg Arg;
OutTraceD3D("Direct3D::EnumZBufferFormats d3d=%x clsid=%x context=%x\n", lpd3d, riidDevice.Data1, lpContext);
Arg.cb= &lpEnumCallback;
Arg.arg=lpContext;
ret = (*pEnumZBufferFormats)(lpd3d, riidDevice, (LPD3DENUMPIXELFORMATSCALLBACK)extZBufferProxy, (LPVOID)&Arg);
OutTraceD3D("Direct3D::EnumZBufferFormats(%d) d3d=%x clsid=%x context=%x\n", d3dversion, lpd3d, riidDevice.Data1, lpContext);
if(dxw.dwFlags8 & TRIMTEXTUREFORMATS){
int iIndex;
int iEnumerated;
PixelFormatTable_Type PixelFormatTable;
PixelFormatTable.nEntries = 0;
//PixelFormatTable.lpPixelFormatEntries = (LPDDPIXELFORMAT)malloc(sizeof(DDPIXELFORMAT));
ret = (*pEnumZBufferFormats)(lpd3d, riidDevice, (LPD3DENUMPIXELFORMATSCALLBACK)FillPixelFormatTable, (LPVOID)&PixelFormatTable);
OutTraceD3D("EnumZBufferFormats: collected entries=%d\n", PixelFormatTable.nEntries);
// bubble sorting;
while(TRUE){
BOOL bSorted = FALSE;
for(iIndex=0; iIndex<PixelFormatTable.nEntries-1; iIndex++){
if(PixelFormatTable.lpPixelFormatEntries[iIndex].dwRGBBitCount > PixelFormatTable.lpPixelFormatEntries[iIndex+1].dwRGBBitCount){
DDPIXELFORMAT tmp;
tmp = PixelFormatTable.lpPixelFormatEntries[iIndex];
PixelFormatTable.lpPixelFormatEntries[iIndex] = PixelFormatTable.lpPixelFormatEntries[iIndex+1];
PixelFormatTable.lpPixelFormatEntries[iIndex+1] = tmp;
bSorted = TRUE;
}
}
if(!bSorted) break;
}
for(iIndex=0, iEnumerated=0; (iIndex < PixelFormatTable.nEntries) && (iEnumerated < MAXTRIMMEDENTRIES); iIndex++){
if(PixelFormatTable.lpPixelFormatEntries[iIndex].dwRGBBitCount >= 32) break;
if((dxw.dwFlags7 & CLEARTEXTUREFOURCC) && (PixelFormatTable.lpPixelFormatEntries[iIndex].dwFlags & DDPF_FOURCC)) continue;
ret = (*lpEnumCallback)(&(PixelFormatTable.lpPixelFormatEntries[iIndex]), lpContext);
OutTraceD3D("EnumZBufferFormats: CALLBACK entry=%d ret=%x %s\n", iIndex, ret, ExplainPixelFormat(&PixelFormatTable.lpPixelFormatEntries[iIndex]));
if(!ret) break;
iEnumerated++;
}
//free((LPVOID)(PixelFormatTable.lpPixelFormatEntries));
ret = DD_OK;
}
else {
CallbackPixFmtArg Arg;
Arg.cb= &lpEnumCallback;
Arg.arg=lpContext;
ret = (*pEnumZBufferFormats)(lpd3d, riidDevice, (LPD3DENUMPIXELFORMATSCALLBACK)extZBufferProxy, (LPVOID)&Arg);
}
OutTraceE("Direct3D::EnumZBufferFormats res=%x(%s)\n", ret, ExplainDDError(ret));
return ret;
}
HRESULT WINAPI extEnumZBufferFormats3(void *lpd3d, REFCLSID riidDevice, LPD3DENUMPIXELFORMATSCALLBACK lpEnumCallback, LPVOID lpContext)
{ return extEnumZBufferFormats(pEnumZBufferFormats3, lpd3d, riidDevice, lpEnumCallback, lpContext); }
{ return extEnumZBufferFormats(3, pEnumZBufferFormats3, lpd3d, riidDevice, lpEnumCallback, lpContext); }
HRESULT WINAPI extEnumZBufferFormats7(void *lpd3d, REFCLSID riidDevice, LPD3DENUMPIXELFORMATSCALLBACK lpEnumCallback, LPVOID lpContext)
{ return extEnumZBufferFormats(pEnumZBufferFormats7, lpd3d, riidDevice, lpEnumCallback, lpContext); }
{ return extEnumZBufferFormats(7, pEnumZBufferFormats7, lpd3d, riidDevice, lpEnumCallback, lpContext); }
// Beware: using service surfaces with DDSCAPS_SYSTEMMEMORY capability may lead to crashes in D3D operations
// like Vievport::Clear() in "Forsaken" set in emulation AERO-friendly mode. To avoid the problem, you can
@ -1844,4 +1994,49 @@ HRESULT WINAPI extExecute(void *lpd3d, LPDIRECT3DEXECUTEBUFFER eb, LPDIRECT3DVIE
ret=(*pExecute)(lpd3d, eb, vp, dw);
if (ret) OutTraceE("Direct3DDevice::Execute res=%x(%s)\n", ret, ExplainDDError(ret));
return DD_OK;
}
}
static HRESULT CALLBACK lpTextureTrimmer(LPDDPIXELFORMAT lpDDPixFmt, LPVOID lpContext)
{
HRESULT res;
OutTraceD3D("EnumTextureFormats: CALLBACK context=%x %s \n", lpContext, ExplainPixelFormat(lpDDPixFmt));
if(lpDDPixFmt->dwFlags & DDPF_FOURCC)
res = DD_OK;
else
res = (*(((CallbackPixFmtArg *)lpContext)->cb))(lpDDPixFmt, ((CallbackPixFmtArg *)lpContext)->arg);
return res;
}
static HRESULT CALLBACK lpTextureDumper(LPDDPIXELFORMAT lpDDPixFmt, LPVOID lpContext)
{
OutTraceD3D("EnumTextureFormats: CALLBACK context=%x %s \n", lpContext, ExplainPixelFormat(lpDDPixFmt));
return TRUE;
}
HRESULT WINAPI extEnumTextureFormats(int d3dversion, EnumTextureFormats_Type pEnumTextureFormats, void *lpd3dd, LPD3DENUMPIXELFORMATSCALLBACK lptfcallback, LPVOID arg)
{
HRESULT res;
OutTrace("EnumTextureFormats(%d): lpd3dd=%x cb=%x arg=%x\n", d3dversion, lpd3dd, lptfcallback, arg);
if(IsDebug) (*pEnumTextureFormats)(lpd3dd, lpTextureDumper, arg);
if(dxw.dwFlags7 & CLEARTEXTUREFOURCC){
CallbackPixFmtArg Arg;
Arg.cb= &lptfcallback;
Arg.arg=arg;
res = (*pEnumTextureFormats)(lpd3dd, lpTextureTrimmer, (LPVOID)&Arg);
}
else{
res = (*pEnumTextureFormats)(lpd3dd, lptfcallback, arg);
}
if(res) OutTrace("EnumTextureFormats: res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
HRESULT WINAPI extEnumTextureFormats1(void *lpd3dd, LPD3DENUMPIXELFORMATSCALLBACK lptfcallback, LPVOID arg)
{ return extEnumTextureFormats(1, pEnumTextureFormats1, lpd3dd, lptfcallback, arg); }
HRESULT WINAPI extEnumTextureFormats2(void *lpd3dd, LPD3DENUMPIXELFORMATSCALLBACK lptfcallback, LPVOID arg)
{ return extEnumTextureFormats(2, pEnumTextureFormats2, lpd3dd, lptfcallback, arg); }
HRESULT WINAPI extEnumTextureFormats3(void *lpd3dd, LPD3DENUMPIXELFORMATSCALLBACK lptfcallback, LPVOID arg)
{ return extEnumTextureFormats(3, pEnumTextureFormats3, lpd3dd, lptfcallback, arg); }
HRESULT WINAPI extEnumTextureFormats7(void *lpd3dd, LPD3DENUMPIXELFORMATSCALLBACK lptfcallback, LPVOID arg)
{ return extEnumTextureFormats(7, pEnumTextureFormats7, lpd3dd, lptfcallback, arg); }

@ -153,7 +153,7 @@ HRESULT STDAPICALLTYPE extCoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter,
break;
case 0x47d4d946: // CLSID_DirectSound
OutTraceDW("CoCreateInstance: CLSID_DirectSound object\n");
HookDirectSoundObj((LPDIRECTSOUND *)ppv);
HookDirectSoundObj((LPDIRECTSOUND *)ppv);
break;
case 0x4fd2a832: // CLSID_DirectDrawFactory
if ((rclsid.Data2==0x86c8) && (rclsid.Data3 == 0x11d0)){

@ -2121,7 +2121,8 @@ BOOL WINAPI extClipCursor(RECT *lpRectArg)
OutTrace("ClipCursor: rect=(NULL)\n");
}
if (!(dxw.dwFlags1 & ENABLECLIPPING)) return 1;
if (!(dxw.dwFlags1 & DISABLECLIPPING)) return TRUE;
if ((dxw.dwFlags8 & CLIPLOCKED) && (lpRectArg == NULL)) return TRUE;
if(lpRectArg){
Rect=*lpRectArg;
@ -2150,12 +2151,12 @@ BOOL WINAPI extClipCursor(RECT *lpRectArg)
BOOL WINAPI extGetClipCursor(LPRECT lpRect)
{
// v2.1.93: if ENABLECLIPPING, return the saved clip rect coordinates
// v2.1.93: if DISABLECLIPPING, return the saved clip rect coordinates
BOOL ret;
// proxy....
if (!(dxw.dwFlags1 & ENABLECLIPPING)) {
if (!(dxw.dwFlags1 & DISABLECLIPPING)) {
ret=(*pGetClipCursor)(lpRect);
// v2.03.11: fix for "SubCulture" mouse movement
if(lpRect && dxw.Windowize) *lpRect = dxw.GetScreenRect();

@ -384,8 +384,8 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
dxw.dwFlags1 &= ~LOCKWINPOS;
}
while((*pShowCursor)(1) < 0);
if(dxw.dwFlags1 & CLIPCURSOR) dxw.EraseClipCursor();
if(dxw.dwFlags1 & ENABLECLIPPING) (*pClipCursor)(NULL);
if((dxw.dwFlags1 & CLIPCURSOR) && !(dxw.dwFlags8 & CLIPLOCKED)) dxw.EraseClipCursor();
if(dxw.dwFlags1 & DISABLECLIPPING) dxw.EraseClipCursor();
break;
case WM_EXITSIZEMOVE:
if(IsToBeLocked){
@ -394,7 +394,7 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
}
if((dxw.dwFlags1 & HIDEHWCURSOR) && dxw.IsFullScreen()) while((*pShowCursor)(0) >= 0);
if(dxw.dwFlags2 & SHOWHWCURSOR) while((*pShowCursor)(1) < 0);
if(dxw.dwFlags1 & ENABLECLIPPING) extClipCursor(lpClipRegion);
if(dxw.dwFlags1 & DISABLECLIPPING) extClipCursor(lpClipRegion);
if(dxw.dwFlags2 & REFRESHONRESIZE) dxw.ScreenRefresh();
if(dxw.dwFlags4 & HIDEDESKTOP) dxw.HideDesktop(dxw.GethWnd());
if(dxw.dwFlags5 & CENTERTOWIN) {
@ -489,12 +489,12 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
case WM_SETFOCUS:
OutTraceDW("WindowProc: hwnd=%x GOT FOCUS\n", hwnd);
if(dxw.dwFlags1 & CLIPCURSOR) dxw.SetClipCursor();
if (dxw.dwFlags1 & ENABLECLIPPING) extClipCursor(lpClipRegion);
if (dxw.dwFlags1 & DISABLECLIPPING) extClipCursor(lpClipRegion);
break;
case WM_KILLFOCUS:
OutTraceDW("WindowProc: hwnd=%x LOST FOCUS\n", hwnd);
if (dxw.dwFlags1 & CLIPCURSOR) dxw.EraseClipCursor();
if (dxw.dwFlags1 & ENABLECLIPPING) (*pClipCursor)(NULL);
if((dxw.dwFlags1 & CLIPCURSOR) && !(dxw.dwFlags8 & CLIPLOCKED)) dxw.EraseClipCursor();
if (dxw.dwFlags1 & DISABLECLIPPING) dxw.EraseClipCursor();
break;
case WM_SYSCOMMAND:
// v2.03.56.fix1 by FunkyFr3sh: ensure that "C&C Red Alert 2" receives the WM_SYSCOMMAND / SC_CLOSE message

@ -34,6 +34,7 @@ void CTabDirect3D::DoDataExchange(CDataExchange* pDX)
DDX_Check(pDX, IDC_NOD3DRESET, cTarget->m_NoD3DReset);
DDX_Check(pDX, IDC_SUPPRESSD3DEXT, cTarget->m_SuppressD3DExt);
DDX_Check(pDX, IDC_ENUM16BITMODES, cTarget->m_Enum16bitModes);
DDX_Check(pDX, IDC_TRIMTEXTUREFORMATS, cTarget->m_TrimTextureFormats);
// Direct3D window tweaks
DDX_Check(pDX, IDC_FIXD3DFRAME, cTarget->m_FixD3DFrame);

@ -35,6 +35,7 @@ void CTabDirectX2::DoDataExchange(CDataExchange* pDX)
DDX_Check(pDX, IDC_FIXREFCOUNTER, cTarget->m_FixRefCounter);
DDX_Check(pDX, IDC_RETURNNULLREF, cTarget->m_ReturnNullRef);
DDX_Check(pDX, IDC_FORCESHEL, cTarget->m_ForcesHEL);
DDX_Check(pDX, IDC_NOHALDEVICE, cTarget->m_NoHALDevice);
DDX_Check(pDX, IDC_MINIMALCAPS, cTarget->m_MinimalCaps);
DDX_Check(pDX, IDC_SETZBUFFERBITDEPTHS, cTarget->m_SetZBufferBitDepths);
DDX_Check(pDX, IDC_DEINTERLACE, cTarget->m_Deinterlace);

@ -31,8 +31,8 @@ void CTabInput::DoDataExchange(CDataExchange* pDX)
DDX_Radio(pDX, IDC_CURSORAUTOMATIC, cTarget->m_MouseVisibility);
// Cursor Handling
DDX_Check(pDX, IDC_MODIFYMOUSE, cTarget->m_ModifyMouse);
DDX_Check(pDX, IDC_ENABLECLIPPING, cTarget->m_EnableClipping);
DDX_Check(pDX, IDC_CLIPCURSOR, cTarget->m_CursorClipping);
//DDX_Check(pDX, IDC_DISABLECLIPPING, cTarget->m_EnableClipping);
//DDX_Check(pDX, IDC_CLIPCURSOR, cTarget->m_CursorClipping);
DDX_Check(pDX, IDC_KEEPCURSORWITHIN, cTarget->m_KeepCursorWithin);
DDX_Check(pDX, IDC_KEEPCURSORFIXED, cTarget->m_KeepCursorFixed);
DDX_Check(pDX, IDC_MESSAGEPROC, cTarget->m_MessageProc);
@ -41,7 +41,8 @@ void CTabInput::DoDataExchange(CDataExchange* pDX)
DDX_Check(pDX, IDC_SLOW, cTarget->m_SlowDown);
DDX_Check(pDX, IDC_RELEASEMOUSE, cTarget->m_ReleaseMouse);
DDX_Check(pDX, IDC_VIRTUALJOYSTICK, cTarget->m_VirtualJoystick);
//DDX_Check(pDX, IDC_FRAMECOMPENSATION, cTarget->m_FrameCompensation);
// Cursor Clipper
DDX_Radio(pDX, IDC_CLIPPERAUTO, cTarget->m_MouseClipper);
// DirectInput
DDX_Check(pDX, IDC_HOOKDI, cTarget->m_HookDI);
DDX_Check(pDX, IDC_HOOKDI8, cTarget->m_HookDI8);

@ -31,6 +31,7 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
m_DxFilterMode = 0; // default: ddraw filtering
m_DCEmulationMode = 0; // default: no emulation
m_MouseVisibility = 0;
m_MouseClipper = 0;
m_OffendingMessages = 0;
m_TextureHandling = 0;
m_HookDI = FALSE;
@ -58,6 +59,7 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
m_SuppressIME = FALSE;
m_SuppressD3DExt = FALSE;
m_Enum16bitModes = FALSE;
m_TrimTextureFormats = FALSE;
m_SetCompatibility = TRUE; // default true !!
m_AEROBoost = TRUE; // default true !!
m_DiabloTweak = FALSE;
@ -148,8 +150,8 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
m_IndependentRefresh = FALSE;
m_TextureFormat = FALSE;
m_FixWinFrame = FALSE;
m_EnableClipping = FALSE;
m_CursorClipping = FALSE;
//m_EnableClipping = FALSE;
//m_CursorClipping = FALSE;
m_VideoToSystemMem = FALSE;
m_FixTextOut = FALSE;
m_SharedDC = FALSE;

@ -33,6 +33,7 @@ public:
int m_DxFilterMode;
int m_DCEmulationMode;
int m_MouseVisibility;
int m_MouseClipper;
int m_OffendingMessages;
int m_TextureHandling;
int m_SonProcessMode;
@ -110,8 +111,8 @@ public:
BOOL m_IndependentRefresh;
BOOL m_TextureFormat;
BOOL m_FixWinFrame;
BOOL m_EnableClipping;
BOOL m_CursorClipping;
//BOOL m_EnableClipping;
//BOOL m_CursorClipping;
BOOL m_VideoToSystemMem;
BOOL m_FixTextOut;
BOOL m_SharedDC;
@ -234,6 +235,7 @@ public:
BOOL m_DisableDisableAltTab;
BOOL m_NoImagehlp;
BOOL m_ForcesHEL;
BOOL m_NoHALDevice;
BOOL m_MinimalCaps;
BOOL m_SetZBufferBitDepths;
BOOL m_ForcesSwapEffect;
@ -259,7 +261,7 @@ public:
BOOL m_BlackWhite;
BOOL m_SuppressD3DExt;
BOOL m_Enum16bitModes;
//BOOL m_Force16BPP;
BOOL m_TrimTextureFormats;
BOOL m_LimitScreenRes;
BOOL m_InitialRes;
BOOL m_MaximumRes;

Binary file not shown.

@ -39,6 +39,7 @@ BOOL gWarnOnExit = FALSE;
BOOL gTransientMode = FALSE;
BOOL gAutoHideMode = FALSE;
BOOL gQuietMode = FALSE;
BOOL gMustDie = FALSE;
int iProgIndex;
extern char m_ConfigFileName[20+1] = "dxwnd.ini";

Binary file not shown.

Binary file not shown.

@ -36,6 +36,7 @@ extern int KillProcByName(char *, BOOL);
extern BOOL gTransientMode;
extern BOOL gAutoHideMode;
extern BOOL gbDebug;
extern BOOL gMustDie;
extern int iProgIndex;
PRIVATEMAP *pTitles; // global ptr: get rid of it!!
@ -276,6 +277,13 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
case 2: t->flags2 |= SHOWHWCURSOR; break;
}
switch(dlg->m_MouseClipper){
case 0: break;
case 1: t->flags |= DISABLECLIPPING; break;
case 2: t->flags |= CLIPCURSOR; break;
case 3: t->flags |= CLIPCURSOR; t->flags8 |= CLIPLOCKED; break;
}
switch(dlg->m_OffendingMessages){
case 0: break;
case 1: t->flags3 |= FILTERMESSAGES; break;
@ -379,6 +387,7 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
if(dlg->m_SuppressIME) t->flags2 |= SUPPRESSIME;
if(dlg->m_SuppressD3DExt) t->flags3 |= SUPPRESSD3DEXT;
if(dlg->m_Enum16bitModes) t->flags7 |= ENUM16BITMODES;
if(dlg->m_TrimTextureFormats) t->flags8 |= TRIMTEXTUREFORMATS;
if(dlg->m_SetCompatibility) t->flags2 |= SETCOMPATIBILITY;
if(dlg->m_AEROBoost) t->flags5 |= AEROBOOST;
if(dlg->m_DiabloTweak) t->flags5 |= DIABLOTWEAK;
@ -392,6 +401,7 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
if(dlg->m_DisableDisableAltTab) t->flags7 |= DISABLEDISABLEALTTAB;
if(dlg->m_NoImagehlp) t->flags5 |= NOIMAGEHLP;
if(dlg->m_ForcesHEL) t->flags3 |= FORCESHEL;
if(dlg->m_NoHALDevice) t->flags8 |= NOHALDEVICE;
if(dlg->m_MinimalCaps) t->flags3 |= MINIMALCAPS;
if(dlg->m_SetZBufferBitDepths) t->flags6 |= SETZBUFFERBITDEPTHS;
if(dlg->m_ForcesSwapEffect) t->flags6 |= FORCESWAPEFFECT;
@ -425,8 +435,8 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
if(dlg->m_IndependentRefresh) t->flags2 |= INDEPENDENTREFRESH;
if(dlg->m_TextureFormat) t->flags5 |= TEXTUREFORMAT;
if(dlg->m_FixWinFrame) t->flags |= FIXWINFRAME;
if(dlg->m_EnableClipping) t->flags |= ENABLECLIPPING;
if(dlg->m_CursorClipping) t->flags |= CLIPCURSOR;
//if(dlg->m_EnableClipping) t->flags |= DISABLECLIPPING;
//if(dlg->m_CursorClipping) t->flags |= CLIPCURSOR;
if(dlg->m_VideoToSystemMem) t->flags |= SWITCHVIDEOMEMORY;
if(dlg->m_FixTextOut) t->flags |= FIXTEXTOUT;
if(dlg->m_HookGlide) t->flags4 |= HOOKGLIDE;
@ -601,6 +611,11 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
if(t->flags & HIDEHWCURSOR) dlg->m_MouseVisibility = 1;
if(t->flags2 & SHOWHWCURSOR) dlg->m_MouseVisibility = 2;
dlg->m_MouseClipper = 0;
if(t->flags & DISABLECLIPPING) dlg->m_MouseClipper = 1;
if(t->flags & CLIPCURSOR) dlg->m_MouseClipper = 2;
if(t->flags8 & CLIPLOCKED) dlg->m_MouseClipper = 3;
dlg->m_OffendingMessages = 0;
if(t->flags3 & FILTERMESSAGES) dlg->m_OffendingMessages = 1;
if(t->flags3 & DEFAULTMESSAGES) dlg->m_OffendingMessages = 2;
@ -673,6 +688,7 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
dlg->m_SuppressIME = t->flags2 & SUPPRESSIME ? 1 : 0;
dlg->m_SuppressD3DExt = t->flags3 & SUPPRESSD3DEXT ? 1 : 0;
dlg->m_Enum16bitModes = t->flags7 & ENUM16BITMODES ? 1 : 0;
dlg->m_TrimTextureFormats = t->flags8 & TRIMTEXTUREFORMATS ? 1 : 0;
dlg->m_SetCompatibility = t->flags2 & SETCOMPATIBILITY ? 1 : 0;
dlg->m_AEROBoost = t->flags5 & AEROBOOST ? 1 : 0;
dlg->m_DiabloTweak = t->flags5 & DIABLOTWEAK ? 1 : 0;
@ -686,6 +702,7 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
dlg->m_DisableDisableAltTab = t->flags7 & DISABLEDISABLEALTTAB ? 1 : 0;
dlg->m_NoImagehlp = t->flags5 & NOIMAGEHLP ? 1 : 0;
dlg->m_ForcesHEL = t->flags3 & FORCESHEL ? 1 : 0;
dlg->m_NoHALDevice = t->flags8 & NOHALDEVICE ? 1 : 0;
dlg->m_MinimalCaps = t->flags3 & MINIMALCAPS ? 1 : 0;
dlg->m_SetZBufferBitDepths = t->flags6 & SETZBUFFERBITDEPTHS ? 1 : 0;
dlg->m_ForcesSwapEffect = t->flags6 & FORCESWAPEFFECT ? 1 : 0;
@ -738,8 +755,8 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
dlg->m_IndependentRefresh = t->flags2 & INDEPENDENTREFRESH ? 1 : 0;
dlg->m_TextureFormat = t->flags5 & TEXTUREFORMAT ? 1 : 0;
dlg->m_FixWinFrame = t->flags & FIXWINFRAME ? 1 : 0;
dlg->m_EnableClipping = t->flags & ENABLECLIPPING ? 1 : 0;
dlg->m_CursorClipping = t->flags & CLIPCURSOR ? 1 : 0;
//dlg->m_EnableClipping = t->flags & DISABLECLIPPING ? 1 : 0;
//dlg->m_CursorClipping = t->flags & CLIPCURSOR ? 1 : 0;
dlg->m_VideoToSystemMem = t->flags & SWITCHVIDEOMEMORY ? 1 : 0;
dlg->m_FixTextOut = t->flags & FIXTEXTOUT ? 1 : 0;
dlg->m_SharedDC = t->flags6 & SHAREDDC ? 1 : 0;
@ -1375,14 +1392,6 @@ void CDxwndhostView::OnInitialUpdate()
pTitles = &PrivateMaps[0];
pTargets= &TargetMaps[0];
// Hot Keys
//DWORD dwKey;
//extern Key_Type HKeys[];
//extern KeyCombo_Type HKeyCombo[];
//for(int i=0; HKeys[i].iLabelResourceId; i++){
// dwKey = GetPrivateProfileInt("keymapping", HKeys[i].sIniLabel, 0, gInitPath);
// if(dwKey) if(!RegisterHotKey(this->GetSafeHwnd(), i, MOD_ALT+MOD_SHIFT+MOD_CONTROL, dwKey)) VKeyError(HKeys[i].sIniLabel);
//}
UpdateHotKeys();
// Transient mode
@ -2337,23 +2346,10 @@ void CDxwndhostView::OnClearAllLogs()
_unlink(FilePath);
}
DWORD WINAPI SilentUpdate(CSystemTray *Tray)
DWORD WINAPI WaitForDeath(LPVOID arg)
{
int DxStatus;
int IdleCount;
IdleCount=0;
while (TRUE) {
// once a second ...
Sleep(1000);
DxStatus=GetHookStatus(NULL);
if (DxStatus != DXW_RUNNING){
IdleCount++;
if(IdleCount >= 2) exit(0);
}
else {
IdleCount=0;
}
}
while(!gMustDie) Sleep(1000);
exit(0);
}
DWORD WINAPI TrayIconUpdate(CSystemTray *Tray)
@ -2370,6 +2366,11 @@ DWORD WINAPI TrayIconUpdate(CSystemTray *Tray)
while (TRUE) {
// once a second ...
Sleep(1000);
if(gTransientMode && gMustDie) {
Tray->HideIcon();
delete(Tray->GetAncestor(GA_ROOTOWNER));
exit(0);
}
DxStatus=GetHookStatus(NULL);
switch (DxStatus){
case DXW_IDLE: IconId=IDI_DXIDLE; Status="DISABLED"; break;
@ -2383,11 +2384,6 @@ DWORD WINAPI TrayIconUpdate(CSystemTray *Tray)
Tray->SetIcon(IconId);
IdleCount++;
if(IdleCount == 2) {
if(gTransientMode) {
Tray->HideIcon();
delete(Tray->GetAncestor(GA_ROOTOWNER));
exit(0);
}
if(gAutoHideMode) {
Tray->MaximiseFromTray(pParent, FALSE); }
}
@ -2444,7 +2440,7 @@ void CDxwndhostView::OnGoToTrayIcon()
NIIF_INFO, 10)){
MessageBoxLang(DXW_STRING_TRAYFAIL, DXW_STRING_ERROR, MB_OK);
// error path: if can't create a system tray icon, transient logic must be silently placed here
if (gTransientMode) StatusThread= CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SilentUpdate, (LPVOID)NULL, 0, &dwThrdId);
if(gTransientMode) StatusThread= CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WaitForDeath, (LPVOID)NULL, 0, &dwThrdId);
return;
}
IconId=(menu->GetMenuState(ID_HOOK_START, MF_BYCOMMAND)==MF_CHECKED)?IDI_DXWAIT:IDI_DXIDLE;
@ -2636,6 +2632,56 @@ void CDxwndhostView::OnRButtonDown(UINT nFlags, CPoint point)
CListView::OnRButtonDown(nFlags, point);
}
typedef struct {
char *path;
char *launch;
} PROCESSMAP;
static DWORD WINAPI TransientWaitForChildDeath(void *p)
{
PROCESSMAP *ProcessMap = (PROCESSMAP *)p;
BOOL bIsSomeoneAlive;
int ret;
char sPath[MAX_PATH];
char sLaunch[MAX_PATH];
char sTemp[MAX_PATH];
char *lpProcName, *lpNext;
// strip full pathname and keep executable name only
strcpy(sPath, "");
if(ProcessMap->path[0]){
strncpy(sTemp, ProcessMap->path, MAX_PATH);
lpProcName=sTemp;
while (lpNext=strchr(lpProcName,'\\')) lpProcName=lpNext+1;
strncpy(sPath, lpProcName, MAX_PATH);
}
strcpy(sLaunch, "");
if(ProcessMap->launch[0]){
strncpy(sTemp, ProcessMap->launch, MAX_PATH);
lpProcName=sTemp;
while (lpNext=strchr(lpProcName,'\\')) lpProcName=lpNext+1;
strncpy(sLaunch, lpProcName, MAX_PATH);
}
Sleep(3000); // Wait for process creation - necessary?
while(TRUE){
Sleep(2000);
bIsSomeoneAlive = FALSE;
if(sPath[0]) {
if (!(ret=KillProcByName(sPath, FALSE))) bIsSomeoneAlive = TRUE;
}
if(sLaunch[0]) {
if (!(ret=KillProcByName(sLaunch, FALSE))) bIsSomeoneAlive = TRUE;
}
if(!bIsSomeoneAlive) {
break;
}
}
gMustDie = TRUE;
return 0;
}
static char *ExceptionCaption(DWORD ec)
{
char *c;
@ -3186,6 +3232,8 @@ static void MakeHiddenFile(char *sTargetPath)
CloseHandle(hTempFile);
}
PROCESSMAP pm;
void CDxwndhostView::OnRun()
{
CListCtrl& listctrl = GetListCtrl();
@ -3286,6 +3334,12 @@ void CDxwndhostView::OnRun()
CloseHandle(pinfo.hThread); // no longer needed, avoid handle leakage
}
if(gTransientMode){
pm.launch = &(PrivateMaps[i].launchpath[0]);
pm.path = &(TargetMaps[i].path[0]);
CreateThread( NULL, 0, TransientWaitForChildDeath, &pm, 0, NULL);
}
// wait & recover
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)RecoverTargetMaps, (LPVOID)TargetMaps, 0, NULL);
if(gAutoHideMode) this->OnGoToTrayIcon();

Binary file not shown.

Binary file not shown.