v2_03_92_src_fx2

Former-commit-id: 98071662a057f21e675d4a50be017788687cd8bc

Include/dxwnd.h

@@ -242,6 +242,7 @@
 #define MAXIMUMRES			0x01000000 // Set maximum screen resolution accorting to sizw x sizh fields
 #define LOCKCOLORDEPTH		0x02000000 // lock ddraw color depth to current desktop value (used in SetDisplayMode)
 #define FIXSMACKLOOP		0x04000000 // fix Smack loop by insert processmessage and blit between frames
+#define FIXFREELIBRARY		0x08000000 // fix FreeLibrary simulating retcode 0(error) when attempting free of unallocated module
 
 // eighth flags DWORD dxw.dwFlags8:
 

build/dxwnd.dll

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:316eb7122e88fb04f315feae566f9dd25795711486906c18921c705267ead3ea
+oid sha256:14919d03fd4ec468005183e338af3f4734eeed9ec11ef6aaf2540c1f9bb00872
-size 688640
+size 691712

build/dxwnd.exe

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a8ac20985704c056d733ed339eed0f3da3467d780f238d3717fb855f5d8dec20
+oid sha256:145095298932076ccdb75aec0627b07f05ad61d9559ed3481a57de4d8a58ea21
 size 662016

build/exports/Heavy Gear.dxw

@@ -0,0 +1,35 @@
+[target]
+title0=Heavy Gear
+path0=D:\Games\Heavy Gear\hg.exe
+startfolder0=
+launchpath0=
+module0=
+opengllib0=
+notes0=Game needs CD on first CD-Rom drive. \nIf multiple ones are present, need setting "hide empty CD-Rom drivers"  \nand unmount others CD.\nGame patched with patch v1.2 requires "fix FreeLibrary" flag\n3DFX & Glide support is still under development
+registry0=
+ver0=0
+monitorid0=-1
+coord0=0
+flag0=681574434
+flagg0=1207959552
+flagh0=20
+flagi0=-2009071612
+flagj0=4224
+flagk0=65536
+flagl0=134217728
+flagm0=0
+tflag0=0
+dflag0=0
+posx0=50
+posy0=50
+sizx0=800
+sizy0=600
+maxfps0=0
+initts0=0
+winver0=0
+maxres0=-1
+swapeffect0=0
+maxddinterface0=7
+slowratio0=2
+initresw0=800
+initresh0=600

build/exports/dxwnd.log

@@ -1,6 +1,31 @@
-OnRun idx=0 prog="G:\Games\Nascar Racing 3\NASCAR Racing 3.exe"
+OnRun idx=16 prog="F:\Games\Adrenix\Adrenix.exe"
 setwindowshook mode
-OnRun idx=0 prog="G:\Games\Nascar Racing 3\NASCAR Racing 3.exe"
+OnRun idx=17 prog="F:\Games\Adrenix\AdrenixD.exe"
 setwindowshook mode
-OnRun idx=0 prog="G:\Games\Nascar Racing 3\NASCAR Racing 3.exe"
+OnRun idx=16 prog="F:\Games\Adrenix\Adrenix.exe"
+checksafediscversion
+setwindowshook mode
+OnRun idx=16 prog="F:\Games\Adrenix\Adrenix.exe"
+setwindowshook mode
+OnRun idx=16 prog="F:\Games\Adrenix\Adrenix.exe"
+setwindowshook mode
+OnRun idx=18 prog="V:\ADRENIX.EXE"
+setwindowshook mode
+OnRun idx=19 prog="V:\ADRENIXD.EXE"
+setwindowshook mode
+OnRun idx=20 prog="V:\ADRHEAT.EXE"
+setwindowshook mode
+OnRun idx=21 prog="V:\ADRHEATD.EXE"
+setwindowshook mode
+OnRun idx=22 prog="V:\ADX_VID.EXE"
+setwindowshook mode
+OnRun idx=16 prog="F:\Games\Adrenix\Adrenix.exe"
+setwindowshook mode
+OnRun idx=17 prog="F:\Games\Adrenix\AdrenixD.exe"
+setwindowshook mode
+OnRun idx=17 prog="F:\Games\Adrenix\AdrenixD.exe"
+setwindowshook mode
+OnRun idx=16 prog="F:\Games\Adrenix\Adrenix.exe"
+setwindowshook mode
+OnRun idx=16 prog="F:\Games\Adrenix\Adrenix.exe"
 setwindowshook mode

build/readme-relnotes.txt

@@ -1301,4 +1301,12 @@ fix: USER32 EndPaint DC leakage - fixes "Yu No" leakage
 fix: window position problems
 fix: GUI auto hide mode enabled and disabled without need of GUI restart
 fix: ddraw surface stack policy. Recovers "Warhammer 40K Rites of War" after v2.03.83 fix.
-add: /q quiet mode, no message dialogs on screen
+add: /q quiet mode, no message dialogs on screen
+
+v2.03.92.fx1-2:
+add: option "Fix FreeLibrary" to emulate the Win9X behaviour returning errorcode upon attempts to free a deallocated module. Fixes "Heavy Gear" patch 1.2 endless loop problem.
+fix: added reference to Palette object to allow final Release() without crash - fixes "Heavy Gear" crash at end of mission
+fix: fix RECT structure passed to ddraw::Unlock method in case it points to bad coordinates. Fixes FIFA2000 in D3D mode
+fix: wrapped all OpenGL GetString methods and inserted proper logging. For diagnostic purposes.
+fix: fix ddraw::SetPalette wrapper in case lppd is NULL. Fixes Adrenix sw mode crash.
+fix: better way to manage extra modules to be hooked (Glide ddls, SmackW32)

dll/ddblit.cpp

@@ -150,6 +150,12 @@ static HRESULT sBltToPrimary(int dxversion, Blt_Type pBlt, char *api, LPDIRECTDR
 		if(dxw.dwFlags3 & NODDRAWBLT) return DD_OK;
 	}
 
+	// v2.03.48: on WinXP it may happen (reported by Cloudstr) that alt tabbing produces
+	// bad blit attempts where the client coordinates get the (-32000,-32000) - (-32000,-32000)
+	// value. In such cases, it's adviseable to simulate an OK return code without attempting
+	// any blit operation!
+	if(lpdestrect && (lpdestrect->left == -32000)) return DD_OK; // no blit on invisible window
+
 #ifdef ONEPIXELFIX
 	if (lpdestrect){
 		if ((lpdestrect->top == 0) && (lpdestrect->bottom == dxw.GetScreenHeight() -1)) lpdestrect->bottom = dxw.GetScreenHeight();
@@ -162,11 +168,15 @@ static HRESULT sBltToPrimary(int dxversion, Blt_Type pBlt, char *api, LPDIRECTDR
 #endif
 
 #if FIXBIGGERRECT
+	// seems necessary to "cure" the "FIFA 2000" soccer game in hw accelerated graphics, when the Unlock() method
+	// receives RECT coordinates with big negative numbers!
 	if(lpdestrect){
-		if((DWORD)lpdestrect->top < 0) lpdestrect->top = 0;
+		if(lpdestrect->top < 0) lpdestrect->top = 0;
-		if((DWORD)lpdestrect->left < 0) lpdestrect->left = 0;
+		if(lpdestrect->left < 0) lpdestrect->left = 0;
-		if((DWORD)lpdestrect->bottom > dxw.GetScreenHeight()) lpdestrect->bottom = dxw.GetScreenHeight();
+		if(lpdestrect->bottom > (LONG)dxw.GetScreenHeight()) lpdestrect->bottom = dxw.GetScreenHeight();
-		if((DWORD)lpdestrect->right > dxw.GetScreenWidth()) lpdestrect->right = dxw.GetScreenWidth();
+		if(lpdestrect->right > (LONG)dxw.GetScreenWidth()) lpdestrect->right = dxw.GetScreenWidth();
+		if(lpdestrect->bottom < lpdestrect->top) lpdestrect->bottom = (LONG)dxw.GetScreenHeight();
+		if(lpdestrect->right < lpdestrect->left) lpdestrect->right = (LONG)dxw.GetScreenWidth();
 	}
 #endif
 
@@ -187,12 +197,6 @@ static HRESULT sBltToPrimary(int dxversion, Blt_Type pBlt, char *api, LPDIRECTDR
 		destrect.left, destrect.top, destrect.right, destrect.bottom,
 		dxw.GetScreenWidth(), dxw.GetScreenHeight());
 
-	// v2.03.48: on WinXP it may happen (reported by Cloudstr) that alt tabbing produces
-	// bad blit attempts where the client coordinates get the (-32000,-32000) - (-32000,-32000)
-	// value. In such cases, it's adviseable to simulate an OK return code without attempting
-	// any blit operation!
-	if(destrect.left == -32000) return DD_OK; // no blit on invisible window
-
 	//if(!(lpddssrc || (dwflags & DDBLT_COLORFILL))) {
 	if((lpddssrc==0) && !(dwflags & DDBLT_COLORFILL)){
 		lpddssrc = dxwss.GetBackBufferSurface();

dll/ddraw.cpp

@@ -99,6 +99,11 @@ HRESULT WINAPI extInitialize2(LPDIRECTDRAW, FAR GUID *);
 HRESULT WINAPI extInitialize3(LPDIRECTDRAW, FAR GUID *);
 HRESULT WINAPI extInitialize4(LPDIRECTDRAW, FAR GUID *);
 HRESULT WINAPI extInitialize7(LPDIRECTDRAW, FAR GUID *);
+HRESULT WINAPI extRestoreDisplayMode1(LPDIRECTDRAW);
+HRESULT WINAPI extRestoreDisplayMode2(LPDIRECTDRAW);
+HRESULT WINAPI extRestoreDisplayMode3(LPDIRECTDRAW);
+HRESULT WINAPI extRestoreDisplayMode4(LPDIRECTDRAW);
+HRESULT WINAPI extRestoreDisplayMode7(LPDIRECTDRAW);
 HRESULT WINAPI extSetCooperativeLevel1(LPDIRECTDRAW, HWND, DWORD);
 HRESULT WINAPI extSetCooperativeLevel2(LPDIRECTDRAW, HWND, DWORD);
 HRESULT WINAPI extSetCooperativeLevel3(LPDIRECTDRAW, HWND, DWORD);
@@ -327,6 +332,7 @@ GetAvailableVidMem4_Type pGetAvailableVidMem4, pGetAvailableVidMem7;
 RestoreAllSurfaces_Type pRestoreAllSurfaces;
 TestCooperativeLevel_Type pTestCooperativeLevel4, pTestCooperativeLevel7;
 GetDeviceIdentifier_Type pGetDeviceIdentifier;
+RestoreDisplayMode_Type pRestoreDisplayMode1, pRestoreDisplayMode2, pRestoreDisplayMode3, pRestoreDisplayMode4, pRestoreDisplayMode7;
 
 /* DirectDrawSurface hook pointers */
 QueryInterface_Type pQueryInterfaceS1, pQueryInterfaceS2, pQueryInterfaceS3, pQueryInterfaceS4, pQueryInterfaceS7;
@@ -1151,6 +1157,7 @@ void HookDDSession(LPDIRECTDRAW *lplpdd, int dxversion)
 		SetHook((void *)(**(DWORD **)lplpdd + 48), extGetDisplayMode1, (void **)&pGetDisplayMode1, "GetDisplayMode(D1)");
 		SetHook((void *)(**(DWORD **)lplpdd + 56), extGetGDISurface1, (void **)&pGetGDISurface1, "GetGDISurface(D1)");
 		SetHook((void *)(**(DWORD **)lplpdd + 72), extInitialize1, (void **)&pInitialize1, "Initialize(D1)");
+		SetHook((void *)(**(DWORD **)lplpdd + 76), extRestoreDisplayMode1, (void **)&pRestoreDisplayMode1, "RestoreDisplayMode(D1)");
 		SetHook((void *)(**(DWORD **)lplpdd + 80), extSetCooperativeLevel1, (void **)&pSetCooperativeLevel1, "SetCooperativeLevel(D1)");
 		SetHook((void *)(**(DWORD **)lplpdd + 84), extSetDisplayMode1, (void **)&pSetDisplayMode1, "SetDisplayMode(D1)");
 		SetHook((void *)(**(DWORD **)lplpdd + 88), extWaitForVerticalBlank1, (void **)&pWaitForVerticalBlank1, "WaitForVerticalBlank(D1)");
@@ -1167,6 +1174,7 @@ void HookDDSession(LPDIRECTDRAW *lplpdd, int dxversion)
 		SetHook((void *)(**(DWORD **)lplpdd + 48), extGetDisplayMode2, (void **)&pGetDisplayMode2, "GetDisplayMode(D2)");
 		SetHook((void *)(**(DWORD **)lplpdd + 56), extGetGDISurface2, (void **)&pGetGDISurface2, "GetGDISurface(D2)");
 		SetHook((void *)(**(DWORD **)lplpdd + 72), extInitialize2, (void **)&pInitialize2, "Initialize(D2)");
+		SetHook((void *)(**(DWORD **)lplpdd + 76), extRestoreDisplayMode2, (void **)&pRestoreDisplayMode2, "RestoreDisplayMode(D2)");
 		SetHook((void *)(**(DWORD **)lplpdd + 80), extSetCooperativeLevel2, (void **)&pSetCooperativeLevel2, "SetCooperativeLevel(D2)");
 		SetHook((void *)(**(DWORD **)lplpdd + 84), extSetDisplayMode2, (void **)&pSetDisplayMode2, "SetDisplayMode(D2)");
 		SetHook((void *)(**(DWORD **)lplpdd + 88), extWaitForVerticalBlank2, (void **)&pWaitForVerticalBlank2, "WaitForVerticalBlank(D2)");
@@ -1185,6 +1193,7 @@ void HookDDSession(LPDIRECTDRAW *lplpdd, int dxversion)
 		SetHook((void *)(**(DWORD **)lplpdd + 48), extGetDisplayMode3, (void **)&pGetDisplayMode3, "GetDisplayMode(D3)");
 		SetHook((void *)(**(DWORD **)lplpdd + 56), extGetGDISurface3, (void **)&pGetGDISurface3, "GetGDISurface(D3)");
 		SetHook((void *)(**(DWORD **)lplpdd + 72), extInitialize3, (void **)&pInitialize3, "Initialize(D3)");
+		SetHook((void *)(**(DWORD **)lplpdd + 76), extRestoreDisplayMode3, (void **)&pRestoreDisplayMode3, "RestoreDisplayMode(D3)");
 		SetHook((void *)(**(DWORD **)lplpdd + 80), extSetCooperativeLevel3, (void **)&pSetCooperativeLevel3, "SetCooperativeLevel(D3)");
 		SetHook((void *)(**(DWORD **)lplpdd + 84), extSetDisplayMode3, (void **)&pSetDisplayMode3, "SetDisplayMode(D3)");
 		SetHook((void *)(**(DWORD **)lplpdd + 88), extWaitForVerticalBlank3, (void **)&pWaitForVerticalBlank3, "WaitForVerticalBlank(D3)");
@@ -1203,6 +1212,7 @@ void HookDDSession(LPDIRECTDRAW *lplpdd, int dxversion)
 		SetHook((void *)(**(DWORD **)lplpdd + 48), extGetDisplayMode4, (void **)&pGetDisplayMode4, "GetDisplayMode(D4)");
 		SetHook((void *)(**(DWORD **)lplpdd + 56), extGetGDISurface4, (void **)&pGetGDISurface4, "GetGDISurface(D4)");
 		SetHook((void *)(**(DWORD **)lplpdd + 72), extInitialize4, (void **)&pInitialize4, "Initialize(D4)");
+		SetHook((void *)(**(DWORD **)lplpdd + 76), extRestoreDisplayMode4, (void **)&pRestoreDisplayMode4, "RestoreDisplayMode(D4)");
 		SetHook((void *)(**(DWORD **)lplpdd + 80), extSetCooperativeLevel4, (void **)&pSetCooperativeLevel4, "SetCooperativeLevel(D4)");
 		SetHook((void *)(**(DWORD **)lplpdd + 84), extSetDisplayMode4, (void **)&pSetDisplayMode4, "SetDisplayMode(D4)");
 		SetHook((void *)(**(DWORD **)lplpdd + 88), extWaitForVerticalBlank4, (void **)&pWaitForVerticalBlank4, "WaitForVerticalBlank(D4)");
@@ -1223,6 +1233,7 @@ void HookDDSession(LPDIRECTDRAW *lplpdd, int dxversion)
 		SetHook((void *)(**(DWORD **)lplpdd + 48), extGetDisplayMode7, (void **)&pGetDisplayMode7, "GetDisplayMode(D7)");
 		SetHook((void *)(**(DWORD **)lplpdd + 56), extGetGDISurface7, (void **)&pGetGDISurface7, "GetGDISurface(D7)");
 		SetHook((void *)(**(DWORD **)lplpdd + 72), extInitialize7, (void **)&pInitialize7, "Initialize(D7)");
+		SetHook((void *)(**(DWORD **)lplpdd + 76), extRestoreDisplayMode7, (void **)&pRestoreDisplayMode7, "RestoreDisplayMode(D7)");
 		SetHook((void *)(**(DWORD **)lplpdd + 80), extSetCooperativeLevel7, (void **)&pSetCooperativeLevel7, "SetCooperativeLevel(D7)");
 		SetHook((void *)(**(DWORD **)lplpdd + 84), extSetDisplayMode7, (void **)&pSetDisplayMode7, "SetDisplayMode(D7)");
 		SetHook((void *)(**(DWORD **)lplpdd + 88), extWaitForVerticalBlank7, (void **)&pWaitForVerticalBlank7, "WaitForVerticalBlank(D7)");
@@ -1823,6 +1834,27 @@ HRESULT WINAPI extInitialize4(LPDIRECTDRAW lpdd, GUID FAR *lpguid)
 HRESULT WINAPI extInitialize7(LPDIRECTDRAW lpdd, GUID FAR *lpguid)
 { return extInitialize(pInitialize7, lpdd, lpguid); }
 
+static HRESULT WINAPI extRestoreDisplayMode(int dxversion, RestoreDisplayMode_Type pRestoreDisplayMode, LPDIRECTDRAW lpdd)
+{
+	OutTraceDW("RestoreDisplayMode(%d): lpdd=%x\n", dxversion, lpdd);
+	if((dxw.dwFlags1 & (EMULATESURFACE|EMULATEBUFFER))){ 
+		OutTraceDW("RestoreDisplayMode: BYPASS\n");
+		return DD_OK;
+	}
+	return (*pRestoreDisplayMode)(lpdd);
+}
+
+HRESULT WINAPI extRestoreDisplayMode1(LPDIRECTDRAW lpdd)
+{ return extRestoreDisplayMode(1, pRestoreDisplayMode1, lpdd); }
+HRESULT WINAPI extRestoreDisplayMode2(LPDIRECTDRAW lpdd)
+{ return extRestoreDisplayMode(2, pRestoreDisplayMode2, lpdd); }
+HRESULT WINAPI extRestoreDisplayMode3(LPDIRECTDRAW lpdd)
+{ return extRestoreDisplayMode(3, pRestoreDisplayMode3, lpdd); }
+HRESULT WINAPI extRestoreDisplayMode4(LPDIRECTDRAW lpdd)
+{ return extRestoreDisplayMode(4, pRestoreDisplayMode4, lpdd); }
+HRESULT WINAPI extRestoreDisplayMode7(LPDIRECTDRAW lpdd)
+{ return extRestoreDisplayMode(7, pRestoreDisplayMode7, lpdd); }
+
 static HRESULT WINAPI extQueryInterfaceD(int dxversion, QueryInterface_Type pQueryInterfaceD, void *lpdd, REFIID riid, LPVOID *obp)
 {
 	HRESULT res;
@@ -2081,7 +2113,7 @@ static HRESULT WINAPI extQueryInterfaceS(int dxversion, QueryInterface_Type pQue
 
 	if(dwLocalTexVersion) {
 		// Texture Handling on QueryInterface
-		if(dxw.dwFlags5 & TEXTUREMASK) TextureHandling((LPDIRECTDRAWSURFACE)lpdds, dwLocalTexVersion);
+		if(dxw.dwFlags5 & TEXTUREMASK) TextureHandling((LPDIRECTDRAWSURFACE)lpdds, dxversion);
 		HookTexture(obp, dwLocalTexVersion);
 	}
 
@@ -4227,7 +4259,13 @@ HRESULT WINAPI extSetPalette(int dxversion, SetPalette_Type pSetPalette, LPDIREC
 	OutTraceDDRAW("SetPalette(%d): lpdds=%x%s lpddp=%x\n", dxversion, lpdds, isPrim?"(PRIM)":"", lpddp);
 
 	res=(*pSetPalette)(lpdds, lpddp);
-	if(res)OutTraceE("SetPalette: ERROR res=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
+	if(res){
+		OutTraceE("SetPalette: ERROR res=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
+		// from MSDN, about lpddp:
+		// A pointer to the IDirectDrawPalette interface for the palette object to be used with this surface. 
+		// If NULL, the current palette is detached.
+		if(lpddp) lpddp->AddRef(); // to allow final Release() without crash - fixes "Heavy Gear" crash at end of mission
+	}
 	else OutTraceDDRAW("SetPalette: OK\n");
 	res=DD_OK;
 
@@ -4250,7 +4288,7 @@ HRESULT WINAPI extSetPalette(int dxversion, SetPalette_Type pSetPalette, LPDIREC
 				if(res) OutTraceE("SetPalette: ERROR res=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
 			}
 		// add a reference to simulate what would happen in reality....
-		lpdds->AddRef();
+		if(lpddp) lpdds->AddRef();
 		res=DD_OK;
 	}
 

dll/ddtexture.cpp

@@ -108,16 +108,20 @@ void TextureHighlight(LPDIRECTDRAWSURFACE s, int dxversion)
 	DDSURFACEDESC2 ddsd;
 	int x, y, w, h;
 	HRESULT res;
+
+	OutTraceB("TextureHigh(%d): lpdds=%x\n", dxversion, s);
+
 	memset(&ddsd,0,sizeof(DDSURFACEDESC2));
 	ddsd.dwSize = Set_dwSize_From_Surface();
 	ddsd.dwFlags = DDSD_LPSURFACE | DDSD_PITCH;
+//	if(res=(*pLockMethod(lpddsHookedVersion()))(s, 0, (LPDDSURFACEDESC)&ddsd, DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY|DDLOCK_WAIT, 0)){	
 	if(res=(*pLockMethod(dxversion))(s, 0, (LPDDSURFACEDESC)&ddsd, DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY|DDLOCK_WAIT, 0)){	
-		OutTraceE("TextureHigh: Lock ERROR res=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
+		OutTraceE("TextureHigh(%d): Lock ERROR res=%x(%s) at %d\n", dxversion, res, ExplainDDError(res), __LINE__);
 		return;
 	}
 	if((ddsd.ddsCaps.dwCaps & DDSCAPS_TEXTURE) && !dxwss.IsABackBufferSurface(s)) {
-		OutTrace("TextureHigh: lpdds=%x BitCount=%d size=(%dx%d)\n", 
+		OutTrace("TextureHigh(%d): lpdds=%x BitCount=%d size=(%dx%d)\n", 
-			s, ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.dwWidth, ddsd.dwHeight);
+			dxversion, s, ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.dwWidth, ddsd.dwHeight);
 		w = ddsd.dwWidth;
 		h = ddsd.dwHeight;
 		switch (ddsd.ddpfPixelFormat.dwRGBBitCount){
@@ -184,6 +188,8 @@ static void TextureDump(LPDIRECTDRAWSURFACE s, int dxversion)
 	static BOOL DoOnce = TRUE;
 	char pszFile[MAX_PATH];
 
+	OutTraceB("TextureDump(%d): lpdds=%x\n", dxversion, s);
+
 	if(DoOnce){
 		char sProfilePath[MAX_PATH];
 		sprintf(sProfilePath, "%s\\dxwnd.ini", GetDxWndPath());
@@ -206,8 +212,8 @@ static void TextureDump(LPDIRECTDRAWSURFACE s, int dxversion)
 	}
 
 	if((ddsd.ddsCaps.dwCaps & DDSCAPS_TEXTURE) && !dxwss.IsABackBufferSurface(s)) while (TRUE) {
-		OutTrace("TextureDump: lpdds=%x BitCount=%d size=(%dx%d)\n", 
+		OutTrace("TextureDump(%d): lpdds=%x BitCount=%d size=(%dx%d)\n", 
-			s, ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.dwWidth, ddsd.dwHeight);
+			dxversion, s, ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.dwWidth, ddsd.dwHeight);
 		w = ddsd.dwWidth;
 		h = ddsd.dwHeight;
 		if((MinTexX && (w<MinTexX)) || (MinTexY && (h<MinTexY))) {
@@ -304,6 +310,8 @@ static void TextureHack(LPDIRECTDRAWSURFACE s, int dxversion)
 	int w, h, iSurfaceSize, iScanLineSize;
 	HRESULT res;
 
+	OutTraceB("TextureHack(%d): lpdds=%x\n", dxversion, s);
+
 	memset(&ddsd,0,sizeof(DDSURFACEDESC2));
 	ddsd.dwSize = Set_dwSize_From_Surface();
 	ddsd.dwFlags = DDSD_LPSURFACE | DDSD_PITCH;
@@ -312,8 +320,8 @@ static void TextureHack(LPDIRECTDRAWSURFACE s, int dxversion)
 		return;
 	}
 	if((ddsd.ddsCaps.dwCaps & DDSCAPS_TEXTURE) && !dxwss.IsABackBufferSurface(s)) while (TRUE) { // fake loop to ensure final Unlock
-		OutTrace("TextureHack: lpdds=%x BitCount=%d size=(%dx%d)\n", 
+		OutTrace("TextureHack(%d): lpdds=%x BitCount=%d size=(%dx%d)\n", 
-			s, ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.dwWidth, ddsd.dwHeight);
+			dxversion, s, ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.dwWidth, ddsd.dwHeight);
 		w = ddsd.dwWidth;
 		h = ddsd.dwHeight;
 		iSurfaceSize = ddsd.dwHeight * ddsd.lPitch;

dll/dwhide.cpp

@@ -318,9 +318,12 @@ void dxwCore::HideDesktop(HWND hwnd)
 	if(!wHider) {
 		wHider=(*pCreateWindowExA)(0, "dxwnd:hider", "hider", 0, 0, 0, 0, 0, hParent, NULL, hinst, NULL);
 		if(!wHider) {
-			OutTrace("HideDesktop: CreateWindowEx ERROR hwnd=%x parent=%x err=%d\n", hwnd, hParent, GetLastError());
+			OutTraceE("HideDesktop: CreateWindowEx ERROR hwnd=%x parent=%x err=%d\n", hwnd, hParent, GetLastError());
 			return;
 		}
+		else{
+			OutTraceDW("HideDesktop: Created Window wHider=%x\n", wHider);
+		}
 		(*pSetWindowLongA)(wHider, GWL_STYLE, 0);
 	}
 

dll/dxhook.cpp

@@ -135,7 +135,7 @@ static char *Flag7Names[32]={
 	"FIXGLOBALUNLOCK", "SHOWHINTS", "SKIPDEVTYPEHID", "INJECTSUSPENDED",
 	"SSUPPRESSDIERRORS", "HOOKNORUN", "FIXBINDTEXTURE", "ENUM16BITMODES",
 	"SHAREDKEYBOARD", "HOOKNOUPDATE", "HOOKGLUT32", "INITIALRES",
-	"MAXIMUMRES", "LOCKCOLORDEPTH", "FIXSMACKLOOP", "",
+	"MAXIMUMRES", "LOCKCOLORDEPTH", "FIXSMACKLOOP", "FIXFREELIBRARY",
 	"", "", "", "",
 };
 
@@ -1465,6 +1465,15 @@ void HookInit(TARGETMAP *target, HWND hwnd)
 
 	HookSysLibsInit(); // this just once...
 
+	if(dxw.dwFlags4 & HOOKGLIDE) {
+		dxw.PushDLL("glide",	SYSLIBIDX_GLIDE);
+		dxw.PushDLL("glide2x",	SYSLIBIDX_GLIDE2);
+		dxw.PushDLL("glide3x",	SYSLIBIDX_GLIDE3);
+	}
+	if(dxw.dwFlags7 & HOOKSMACKW32) {
+		dxw.PushDLL("smackw32",	SYSLIBIDX_SMACKW32);	// SMACKW32.DLL	
+	}
+
 	base=GetModuleHandle(NULL);
 	if (dxw.dwFlags3 & SINGLEPROCAFFINITY) SetSingleProcessAffinity(TRUE);
 	if (dxw.dwFlags5 & USELASTCORE) SetSingleProcessAffinity(FALSE);

dll/dxwcore.cpp

@@ -1054,6 +1054,11 @@ void dxwCore::ShowBanner(HWND hwnd)
 	Sleep(200);
 }
 
+void dxwCore::PushDLL(char *lpName, int idx)
+{
+	SysNames[idx] = lpName; // add entry
+}
+
 int dxwCore::GetDLLIndex(char *lpFileName)
 {
 	int idx;

dll/dxwcore.hpp

@@ -118,6 +118,7 @@ public: // methods
 	void HideDesktop(HWND);
 	POINT ScreenToClient(POINT);
 	int GetDLLIndex(char *);
+	void PushDLL(char *, int);
 	void FixStyle(char *, HWND, WPARAM, LPARAM);
 	void FixWindowFrame(HWND);
 	DWORD FixWinStyle(DWORD);
@@ -353,20 +354,16 @@ typedef enum {
 	SYSLIBIDX_COMDLG32,
 	SYSLIBIDX_COMCTL32,
 	SYSLIBIDX_AVIFIL32,
+	SYSLIBIDX_GLIDE,
+	SYSLIBIDX_GLIDE2,
+	SYSLIBIDX_GLIDE3,
+	SYSLIBIDX_SMACKW32,
+	FREE5,
+	FREE6,
 	SYSLIBIDX_MAX 
 } 
 enum_syslibraries;
 
-typedef enum {
-	HINT_HINT = 0,
-	HINT_DDRAW,		HINT_D3D8,		HINT_D3D9,		HINT_D3D10,
-	HINT_D3D11,		HINT_OPENGL,	HINT_DSOUND,	HINT_DINPUT,
-	HINT_DINPUT8,	HINT_MOVIES,	HINT_D3D,		HINT_IHLP,
-	HINT_FAKEOS,	HINT_OBFUSCATED,HINT_SAFEDISC,	HINT_SECUROM,
-	HINT_LIMITMEM,	HINT_HOOKUPDATE,
-	HINT_LAST
-} HintEnumIds;
-
 #ifdef SYSLIBNAMES_DEFINES
 char *SysNames[]={
 	"kernel32",
@@ -395,12 +392,23 @@ char *SysNames[]={
 	"comdlg32",
 	"comctl32",
 	"AVIFIL32",
+	"_", "_", "_", "_", "_", "_", // 6 free slots 
 	NULL
 };	
 #else
 extern char *SysNames[];
 #endif 
 
+typedef enum {
+	HINT_HINT = 0,
+	HINT_DDRAW,		HINT_D3D8,		HINT_D3D9,		HINT_D3D10,
+	HINT_D3D11,		HINT_OPENGL,	HINT_DSOUND,	HINT_DINPUT,
+	HINT_DINPUT8,	HINT_MOVIES,	HINT_D3D,		HINT_IHLP,
+	HINT_FAKEOS,	HINT_OBFUSCATED,HINT_SAFEDISC,	HINT_SECUROM,
+	HINT_LIMITMEM,	HINT_HOOKUPDATE,
+	HINT_LAST
+} HintEnumIds;
+
 typedef enum {
 	DXVK_NONE=0,
 	DXVK_CLIPTOGGLE,

dll/dxwnd.cpp

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

dll/kernel32.cpp

@@ -34,15 +34,27 @@ WinExec_Type pWinExec = NULL;
 SetPriorityClass_Type pSetPriorityClass = NULL;
 GlobalUnlock_Type pGlobalUnlock = NULL;
 
-#ifdef NOFREELIBRARY
 typedef BOOL (WINAPI *FreeLibrary_Type)(HMODULE);
 FreeLibrary_Type pFreeLibrary = NULL;
 BOOL WINAPI extFreeLibrary(HMODULE hModule)
 { 
-	OutTrace("FreeLibrary: hModule=%x SUPPRESS\n", hModule);
+	BOOL ret;
-	return TRUE; 
+	static HMODULE hLastModule;
+	OutTraceB("FreeLibrary: hModule=%x\n", hModule);
+	ret = (*pFreeLibrary)(hModule);
+	if(ret){
+		OutTrace("FreeLibrary: ret=%x\n", ret);
+		if((hModule == hLastModule) && (dxw.dwFlags7 & FIXFREELIBRARY)) {
+			OutTraceDW("FreeLibrary: FIXFREELIBRARY hack ret=0\n");
+			ret = 0;
+		}
+		hLastModule = hModule;
+	}
+	else {
+		OutTraceE("FreeLibrary ERROR: err=%d\n", GetLastError());
+	}
+	return ret; 
 }
-#endif
 
 // v2.02.96: the GetSystemInfo API is NOT hot patchable on Win7. This can cause problems because it can't be hooked by simply
 // enabling hot patch. A solution is making all LoadLibrary* calls hot patchable, so that when loading the module, the call
@@ -63,9 +75,7 @@ static HookEntryEx_Type Hooks[]={
 	//{HOOK_IAT_CANDIDATE, 0, "WinExec", (FARPROC)NULL, (FARPROC *)&pWinExec, (FARPROC)extWinExec},
 	{HOOK_HOT_CANDIDATE, 0, "SetPriorityClass", (FARPROC)SetPriorityClass, (FARPROC *)&pSetPriorityClass, (FARPROC)extSetPriorityClass},
 	{HOOK_HOT_CANDIDATE, 0, "GlobalUnlock", (FARPROC)GlobalUnlock, (FARPROC *)&pGlobalUnlock, (FARPROC)extGlobalUnlock},
-#ifdef NOFREELIBRARY
 	{HOOK_HOT_CANDIDATE, 0, "FreeLibrary", (FARPROC)FreeLibrary, (FARPROC *)&pFreeLibrary, (FARPROC)extFreeLibrary},
-#endif
 	{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
 };
 

dll/logall.h

@@ -13,4 +13,20 @@
 #ifdef OutTraceE
 #undef OutTraceE
 #define OutTraceE OutTrace
-#endif
+#endif
+#ifdef IsTraceB
+#undef IsTraceB
+#define IsTraceB TRUE
+#endif
+#ifdef IsTraceDW
+#undef IsTraceDW
+#define IsTraceDW TRUE
+#endif
+#ifdef IsTraceC
+#undef IsTraceC
+#define IsTraceC TRUE
+#endif
+#ifdef IsTraceE
+#undef IsTraceE
+#define IsTraceE TRUE
+#endif

dll/opengl.cpp

@@ -20,6 +20,8 @@
 #define COMPRESSED_RGBA_S3TC_DXT5_EXT                  0x83F3
 #endif
 
+//#include "logall.h"
+
 typedef void (WINAPI *glutFullScreen_Type)(void);
 glutFullScreen_Type pglutFullScreen;
 void WINAPI extglutFullScreen(void);
@@ -32,6 +34,15 @@ void extglutInitWindowPosition(int, int);
 typedef void (WINAPI *glutSetWindow_Type)(HWND);
 glutSetWindow_Type pglutSetWindow;
 void WINAPI extglutSetWindow(HWND);
+typedef const GLubyte* (WINAPI *glGetString_Type)(GLenum);
+glGetString_Type pglGetString;
+const GLubyte* WINAPI extglGetString(GLenum);
+typedef char* (WINAPI *wglGetExtensionsStringEXT_Type)(void);
+wglGetExtensionsStringEXT_Type pwglGetExtensionsStringEXT;
+char* WINAPI extwglGetExtensionsStringEXT(void);
+typedef const GLubyte* (WINAPI *gluGetString_Type)(GLenum);
+gluGetString_Type pgluGetString;
+const GLubyte* WINAPI extgluGetString(GLenum);
 
 //void WINAPI extglDrawPixels(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
 //typedef void (WINAPI *glDrawPixels_Type)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
@@ -46,9 +57,6 @@ static HookEntryEx_Type Hooks[]={
 	{HOOK_IAT_CANDIDATE, 0, "glPolygonMode", NULL, (FARPROC *)&pglPolygonMode, (FARPROC)extglPolygonMode},
 	{HOOK_IAT_CANDIDATE, 0, "glGetFloatv", NULL, (FARPROC *)&pglGetFloatv, (FARPROC)extglGetFloatv},
 	{HOOK_IAT_CANDIDATE, 0, "glClear", NULL, (FARPROC *)&pglClear, (FARPROC)extglClear},
-	{HOOK_IAT_CANDIDATE, 0, "wglCreateContext", NULL, (FARPROC *)&pwglCreateContext, (FARPROC)extwglCreateContext},
-	{HOOK_IAT_CANDIDATE, 0, "wglMakeCurrent", NULL, (FARPROC *)&pwglMakeCurrent, (FARPROC)extwglMakeCurrent},
-	{HOOK_IAT_CANDIDATE, 0, "wglGetProcAddress", NULL, (FARPROC *)&pwglGetProcAddress, (FARPROC)extwglGetProcAddress},
 	{HOOK_IAT_CANDIDATE, 0, "glTexImage2D", NULL, (FARPROC *)&pglTexImage2D, (FARPROC)extglTexImage2D},
 	//{HOOK_IAT_CANDIDATE, 0, "glDrawPixels", NULL, (FARPROC *)&pglDrawPixels, (FARPROC)extglDrawPixels},
 	{HOOK_IAT_CANDIDATE, 0, "glPixelZoom", NULL, (FARPROC *)&pglPixelZoom, (FARPROC)extglPixelZoom},
@@ -56,6 +64,11 @@ static HookEntryEx_Type Hooks[]={
 	{HOOK_IAT_CANDIDATE, 0, "glBindTexture", NULL, (FARPROC *)&pglBindTexture, (FARPROC)extglBindTexture},
 	//{HOOK_IAT_CANDIDATE, 0, "glCopyTexImage2D", NULL, (FARPROC *)&pglCopyTexImage2D, (FARPROC)extglCopyTexImage2D},
 	//{HOOK_IAT_CANDIDATE, 0, "glPixelStorei", NULL, (FARPROC *)&pglPixelStorei, (FARPROC)extglPixelStorei},
+	{HOOK_IAT_CANDIDATE, 0, "glGetString", NULL, (FARPROC *)&pglGetString, (FARPROC)extglGetString},
+	{HOOK_IAT_CANDIDATE, 0, "wglCreateContext", NULL, (FARPROC *)&pwglCreateContext, (FARPROC)extwglCreateContext},
+	{HOOK_IAT_CANDIDATE, 0, "wglMakeCurrent", NULL, (FARPROC *)&pwglMakeCurrent, (FARPROC)extwglMakeCurrent},
+	{HOOK_IAT_CANDIDATE, 0, "wglGetProcAddress", NULL, (FARPROC *)&pwglGetProcAddress, (FARPROC)extwglGetProcAddress},
+	{HOOK_IAT_CANDIDATE, 0, "wglGetExtensionsStringEXT", NULL, (FARPROC *)&pwglGetExtensionsStringEXT, (FARPROC)extwglGetExtensionsStringEXT},
 	{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
 };
 
@@ -70,6 +83,7 @@ static HookEntryEx_Type GlutHooks[]={
 	{HOOK_IAT_CANDIDATE, 0, "glutInitWindowSize", NULL, (FARPROC *)&pglutInitWindowSize, (FARPROC)extglutInitWindowSize},
 	{HOOK_IAT_CANDIDATE, 0, "glutInitWindowPosition", NULL, (FARPROC *)&pglutInitWindowPosition, (FARPROC)extglutInitWindowPosition},
 	{HOOK_IAT_CANDIDATE, 0, "glutSetWindow", NULL, (FARPROC *)&pglutSetWindow, (FARPROC)extglutSetWindow},
+	{HOOK_IAT_CANDIDATE, 0, "gluGetString", NULL, (FARPROC *)&pgluGetString, (FARPROC)extgluGetString},
 	{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
 };
 
@@ -608,11 +622,11 @@ char *ExplainDrawPixelsFormat(DWORD c)
 void WINAPI extglDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data)
 {
 	GLenum glerr;
-	OutTrace("glDrawPixels: size=(%dx%d) format=%x(%s) type=%d data=%x\n", 
+	OutTraceDW("glDrawPixels: size=(%dx%d) format=%x(%s) type=%d data=%x\n", 
 		width, height, format, ExplainDrawPixelsFormat(format), type, data);
 
 	(*pglDrawPixels)(width, height, format, type, data);
-	if ((glerr=extglGetError())!= GL_NO_ERROR) OutTrace("GLERR %d ad %d\n", glerr, __LINE__);
+	if ((glerr=extglGetError())!= GL_NO_ERROR) OutTraceE("GLERR %d ad %d\n", glerr, __LINE__);
 	return;
 }
 #endif
@@ -630,7 +644,7 @@ void WINAPI extglPixelZoom(GLfloat xfactor, GLfloat yfactor)
 		OutTraceDW("glPixelZoom: FIXED x,y factor=(%f,%f)\n", xfactor, yfactor);
 	}
 	(*pglPixelZoom)(xfactor, yfactor);
-	if ((glerr=extglGetError())!= GL_NO_ERROR) OutTrace("GLERR %d ad %d\n", glerr, __LINE__);
+	if ((glerr=extglGetError())!= GL_NO_ERROR) OutTraceE("GLERR %d ad %d\n", glerr, __LINE__);
 	return;
 }
 
@@ -674,7 +688,7 @@ void WINAPI extglPixelStorei(GLenum pname,  GLint param)
 void WINAPI extglutFullScreen(void)
 {
 	if(!dxw.Windowize) return (*pglutFullScreen)();
-	OutTrace("glutFullScreen BYPASS\n");
+	OutTraceDW("glutFullScreen BYPASS\n");
 	dxw.SetFullScreen(TRUE);
 }
 
@@ -684,9 +698,9 @@ void extglutInitWindowSize(int width, int height)
 	if(dxw.Windowize){
 		dummy1=0;
 		dummy2=0;
-		OutTrace("glutInitWindowSize: width=%d height=%d\n", width, height);
+		OutTraceDW("glutInitWindowSize: width=%d height=%d\n", width, height);
 		dxw.MapWindow(&dummy1, &dummy2, &width, &height);	
-		OutTrace("glutInitWindowSize: FIXED width=%d height=%d\n", width, height);
+		OutTraceDW("glutInitWindowSize: FIXED width=%d height=%d\n", width, height);
 	}
 	(*pglutInitWindowSize)(width, height);
 }
@@ -697,17 +711,91 @@ void extglutInitWindowPosition(int x, int y)
 	if(dxw.Windowize){
 		dummy1=0;
 		dummy2=0;
-		OutTrace("glutInitWindowPosition: x=%d y=%d\n", x, y);
+		OutTraceDW("glutInitWindowPosition: x=%d y=%d\n", x, y);
 		dxw.MapWindow(&x, &y, &dummy1, &dummy2);
-		OutTrace("glutInitWindowPosition: FIXED x=%d y=%d\n", x, y);
+		OutTraceDW("glutInitWindowPosition: FIXED x=%d y=%d\n", x, y);
 	}
 	(*pglutInitWindowPosition)(x, y);
 }
 
 void WINAPI extglutSetWindow(HWND win)
 {
-	OutTrace("glutSetWindow: win=%x\n", win);
+	OutTraceDW("glutSetWindow: win=%x\n", win);
 	if(dxw.Windowize && dxw.IsRealDesktop(win)) win=dxw.GethWnd();
 	(*pglutSetWindow)(win);
 }
 
+static char *glStringName(GLenum name)
+{
+	char *ret;
+	switch(name){
+		case GL_VENDOR: ret="GL_VENDOR"; break;
+		case GL_RENDERER: ret="GL_RENDERER"; break;
+		case GL_VERSION: ret="GL_VERSION"; break;
+		case GL_SHADING_LANGUAGE_VERSION: ret="GL_SHADING_LANGUAGE_VERSION"; break;
+		case GL_EXTENSIONS: ret="GL_EXTENSIONS"; break;
+		default: ret="unknown"; break;
+	}
+	return ret;
+}
+
+const  GLubyte* WINAPI extglGetString(GLenum name)
+{
+	const GLubyte* ret;
+	ret = (*pglGetString)(name);
+	if(IsTraceDW){
+		if(strlen((const char *)ret)<80)
+			OutTrace("glGetString: name=%x(%s) ret=\"%.80s\"\n", name, glStringName(name), ret);
+		else{
+			const GLubyte *p = ret;
+			OutTrace("glGetString: name=%x(%s) ret=(%d)\n", name, glStringName(name), strlen((const char *)ret));
+			while(strlen((const char *)p)>80){
+				OutTrace("glGetString: \"%.80s\" +\n", p);
+				p += 80;
+			}
+			OutTrace("glGetString: \"%.80s\"\n", p);
+		}
+	}
+	return ret;
+}
+
+char* WINAPI extwglGetExtensionsStringEXT(void)
+{
+	char *ret;
+	ret = (*pwglGetExtensionsStringEXT)();
+	if(IsTraceDW){
+		if(strlen((const char *)ret)<80)
+			OutTrace("wglGetExtensionsStringEXT: ret=\"%.80s\"\n", ret);
+		else{
+			const char *p = ret;
+			OutTrace("wglGetExtensionsStringEXT: ret=(%d)\n", strlen((const char *)ret));
+			while(strlen((const char *)p)>80){
+				OutTrace("wglGetExtensionsStringEXT: \"%.80s\" +\n", p);
+				p += 80;
+			}
+			OutTrace("wglGetExtensionsStringEXT: \"%.80s\"\n", p);
+		}
+	}
+	return ret;
+}
+
+const GLubyte* WINAPI extgluGetString(GLenum name)
+{
+	const GLubyte* ret;
+	ret = (*pgluGetString)(name);
+	if(IsTraceDW){
+		if(strlen((const char *)ret)<80)
+			OutTrace("gluGetString: name=%x(%s) ret=\"%.80s\"\n", name, glStringName(name), ret);
+		else{
+			const GLubyte *p = ret;
+			OutTrace("gluGetString: name=%x(%s) ret=(%d)\n", name, glStringName(name), strlen((const char *)ret));
+			while(strlen((const char *)p)>80){
+				OutTrace("gluGetString: \"%.80s\" +\n", p);
+				p += 80;
+			}
+			OutTrace("gluGetString: \"%.80s\"\n", p);
+		}
+	}
+	return ret;
+}
+                    

host/TabCompat.cpp

@@ -49,6 +49,7 @@ void CTabCompat::DoDataExchange(CDataExchange* pDX)
 	DDX_Check(pDX, IDC_BLOCKPRIORITYCLASS, cTarget->m_BlockPriorityClass);
 	DDX_Check(pDX, IDC_COLORFIX, cTarget->m_ColorFix);
 	DDX_Check(pDX, IDC_FIXGLOBALUNLOCK, cTarget->m_FixGlobalUnlock);
+	DDX_Check(pDX, IDC_FIXFREELIBRARY, cTarget->m_FixFreeLibrary);
 
 	// Registry management
 	DDX_Check(pDX, IDC_EMULATEREGISTRY, cTarget->m_EmulateRegistry);

host/TargetDlg.cpp

@@ -77,6 +77,7 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
 	m_ForcesSwapEffect = FALSE;
 	m_ColorFix = FALSE;
 	m_FixGlobalUnlock = FALSE;
+	m_FixFreeLibrary = FALSE;
 	m_NoPixelFormat = FALSE;
 	m_NoAlphaChannel = FALSE;
 	m_FixRefCounter = TRUE; // default true !!

host/TargetDlg.h

@@ -233,6 +233,7 @@ public:
 	BOOL	m_ForcesSwapEffect;
 	BOOL	m_ColorFix;
 	BOOL	m_FixGlobalUnlock;
+	BOOL	m_FixFreeLibrary;
 	BOOL	m_NoPixelFormat;
 	BOOL	m_NoAlphaChannel;
 	BOOL	m_FixRefCounter;

host/dxwndhostView.cpp

@@ -366,6 +366,7 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
 	if(dlg->m_ForcesSwapEffect) t->flags6 |= FORCESWAPEFFECT;
 	if(dlg->m_ColorFix) t->flags3 |= COLORFIX;
 	if(dlg->m_FixGlobalUnlock) t->flags7 |= FIXGLOBALUNLOCK;
+	if(dlg->m_FixFreeLibrary) t->flags7 |= FIXFREELIBRARY;
 	if(dlg->m_NoPixelFormat) t->flags3 |= NOPIXELFORMAT;
 	if(dlg->m_NoAlphaChannel) t->flags4 |= NOALPHACHANNEL;
 	if(dlg->m_FixRefCounter) t->flags4 |= FIXREFCOUNTER;
@@ -632,6 +633,7 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
 	dlg->m_ForcesSwapEffect = t->flags6 & FORCESWAPEFFECT ? 1 : 0;
 	dlg->m_ColorFix = t->flags3 & COLORFIX ? 1 : 0;
 	dlg->m_FixGlobalUnlock = t->flags7 & FIXGLOBALUNLOCK ? 1 : 0;
+	dlg->m_FixFreeLibrary = t->flags7 & FIXFREELIBRARY ? 1 : 0;
 	dlg->m_NoPixelFormat = t->flags3 & NOPIXELFORMAT ? 1 : 0;
 	dlg->m_NoAlphaChannel = t->flags4 & NOALPHACHANNEL ? 1 : 0;
 	dlg->m_FixRefCounter = t->flags4 & FIXREFCOUNTER ? 1 : 0;