v2_03_90_src

Former-commit-id: 6f0f833ad11c763cb5756435f4c5f0cc639185c6

Include/dxwnd.h

@@ -237,6 +237,10 @@
 #define ENUM16BITMODES		0x00080000 // Enumerates 16 bit video modes when using DirectDraw8/9::EnumAdapterModes on a Win10 OS
 #define SHAREDKEYBOARD		0x00100000 // Forces DirectInput cooperative level to NONEXCLUSIVE mode for the keyboard
 #define HOOKNOUPDATE		0x00200000 // Updates the original addresses when changed
+#define HOOKGLUT32			0x00400000 // Hook glut32.dll opengl extension library
+#define INITIALRES			0x00800000 // Set initial screen resolution accorting to sizw x sizh fields
+#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)
 
 // eighth flags DWORD dxw.dwFlags8:
 
@@ -288,6 +292,8 @@ typedef struct TARGETMAP
 	short posy;
 	short sizx;
 	short sizy;
+	short resw;
+	short resh;
 	short MaxFPS;
 	short InitTS;
 	short FakeVersionId;

build/dxwnd.dll

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9070435639bcf64aebc632f848af969aa24800cb40864ae90d5ce56a1d43b373
+oid sha256:2a2587c509901aafe87b3f75f29a007e231a916c99f1bf90a210e44fbb532a0a
-size 681472
+size 683520

build/dxwnd.exe

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:14ddc8f6eaa1eac7dc356e8824fb118e014fe5b5e8828432e2ffa0ac58f1f3c4
+oid sha256:90ce56d32db76f27a8364a6325927ff6ac7035303dd47f913baf2d430c49f6a7
-size 660992
+size 661504

build/readme-relnotes.txt

@@ -1273,3 +1273,10 @@ fix: fixed the logic for centering the main window for desktop with non-zero off
 fix: improved logic for window placement in CreateWindowEx call
 fix: added wrapper for winmm/GetJoyPos() virtual joystick referenced in "Jane's FA18"
 
+v2.03.90
+add: added flags/fields to define initial/maximum screen resolution
+add: "Lock color depth" ddraw flag. Fixes "Ahlgrens Bilspelet" color problems
+add: preliminary opengl/glut32 hook
+fix: ZBUFFER capabilities - allow "Galapagos" to run in hw accelerated mode
+fix: separated D3D FindDevice hookers for D3D version 1/2/3
+fix: some unused code cleanup

dll/cpulimit.cpp

@@ -21,7 +21,7 @@ DWORD WINAPI CpuSlow(LPVOID lpThreadParameter)
 	Sleep(100);
 	while(TRUE) SlowCpuSpeed(dwOwnerPID, dwOwnerThread, iSlowDownRatio);
 	return TRUE;
-}
+} 
 
 DWORD WINAPI CpuLimit(LPVOID lpThreadParameter) 
 {

dll/ddraw.cpp

@@ -2124,6 +2124,12 @@ HRESULT WINAPI extSetDisplayMode(int dxversion, LPDIRECTDRAW lpdd,
 	if((int)dwwidth < 0) dwwidth = dxw.GetScreenWidth();
 	if((int)dwheight < 0) dwheight = dxw.GetScreenHeight();
 
+	// v2.03.90: add LOCKCOLORDEPTH, easiest way to manage "Ahlgrens bisplet"!
+	if(dxw.dwFlags7 & LOCKCOLORDEPTH){
+		OutTraceDW("SetDisplayMode: LOCKCOLORDEPTH bpp=%d->%d\n", dwbpp, dxw.ActualPixelFormat.dwRGBBitCount);
+		dwbpp = dxw.ActualPixelFormat.dwRGBBitCount;
+	}
+
 	dxw.SetScreenSize(dwwidth, dwheight);
 	GetHookInfo()->Height=(short)dxw.GetScreenHeight();
 	GetHookInfo()->Width=(short)dxw.GetScreenWidth();
@@ -2198,9 +2204,9 @@ HRESULT WINAPI extSetDisplayMode(int dxversion, LPDIRECTDRAW lpdd,
 	if(res) OutTraceE("SetDisplayMode: error=%x(%s)\n", res, ExplainDDError(res));
 
 	SetVSyncDelays(dxversion, lpdd);
+
 	// set a default palette ???
-	if(dxw.VirtualPixelFormat.dwRGBBitCount == 8) 
+	if(dxw.VirtualPixelFormat.dwRGBBitCount == 8) mySetPalette(0, 256, DefaultSystemPalette);
-		mySetPalette(0, 256, DefaultSystemPalette);
 
 	if(dxw.bAutoScale) dxw.AutoScale();
 
@@ -4621,6 +4627,7 @@ static HRESULT WINAPI extUnlock(int dxversion, Unlock4_Type pUnlock, LPDIRECTDRA
 		// Texture Handling on Unlock
 		TextureHandling(lpdds, dxversion);
 	}
+
 	return res;
 }
 
@@ -4837,10 +4844,12 @@ HRESULT WINAPI extFlipToGDISurface4(LPDIRECTDRAW lpdd)
 HRESULT WINAPI extFlipToGDISurface7(LPDIRECTDRAW lpdd)
 { return extFlipToGDISurface(pFlipToGDISurface7, lpdd); }
 
-HRESULT WINAPI extGetGDISurface(GetGDISurface_Type pGetGDISurface, LPDIRECTDRAW lpdd, LPDIRECTDRAWSURFACE *w)
+HRESULT WINAPI extGetGDISurface(int dxversion, GetGDISurface_Type pGetGDISurface, LPDIRECTDRAW lpdd, LPDIRECTDRAWSURFACE *w)
 {
 	int res;
 
+	OutTraceDDRAW("GetGDISurface(%d): lpdd=%x\n", dxversion, lpdd);
+
 	// v2.02.31:
 	// in EMULATED mode, should not return the actual ddraw primary surface, but the virtual one.
 	if(dxw.dwFlags1 & EMULATESURFACE){
@@ -4861,15 +4870,15 @@ HRESULT WINAPI extGetGDISurface(GetGDISurface_Type pGetGDISurface, LPDIRECTDRAW
 }
 
 HRESULT WINAPI extGetGDISurface1(LPDIRECTDRAW lpdd, LPDIRECTDRAWSURFACE *w)
-{ return extGetGDISurface(pGetGDISurface1, lpdd, w); }
+{ return extGetGDISurface(1, pGetGDISurface1, lpdd, w); }
 HRESULT WINAPI extGetGDISurface2(LPDIRECTDRAW lpdd, LPDIRECTDRAWSURFACE *w)
-{ return extGetGDISurface(pGetGDISurface2, lpdd, w); }
+{ return extGetGDISurface(2, pGetGDISurface2, lpdd, w); }
 HRESULT WINAPI extGetGDISurface3(LPDIRECTDRAW lpdd, LPDIRECTDRAWSURFACE *w)
-{ return extGetGDISurface(pGetGDISurface3, lpdd, w); }
+{ return extGetGDISurface(3, pGetGDISurface3, lpdd, w); }
 HRESULT WINAPI extGetGDISurface4(LPDIRECTDRAW lpdd, LPDIRECTDRAWSURFACE *w)
-{ return extGetGDISurface(pGetGDISurface4, lpdd, w); }
+{ return extGetGDISurface(4, pGetGDISurface4, lpdd, w); }
 HRESULT WINAPI extGetGDISurface7(LPDIRECTDRAW lpdd, LPDIRECTDRAWSURFACE *w)
-{ return extGetGDISurface(pGetGDISurface7, lpdd, w); }
+{ return extGetGDISurface(7, pGetGDISurface7, lpdd, w); }
 
 // debug function to dump all video modes queried by the DirectDrav::EnumDisplayModes method
 
@@ -4907,20 +4916,30 @@ typedef struct {
 
 static BOOL CheckResolutionLimit(LPDDSURFACEDESC lpDDSurfaceDesc)
 {
-	#define HUGE 100000
+	if(dxw.dwFlags4 & LIMITSCREENRES) {
-	DWORD maxw, maxh;
+		#define HUGE 100000
-	maxw=HUGE; maxh=HUGE;
+		DWORD maxw, maxh;
-	switch(dxw.MaxScreenRes){
+		maxw=HUGE; maxh=HUGE;
-		case DXW_LIMIT_320x200: maxw=320; maxh=200; break;
+		switch(dxw.MaxScreenRes){
-		case DXW_LIMIT_640x480: maxw=640; maxh=480; break;
+			case DXW_LIMIT_320x200: maxw=320; maxh=200; break;
-		case DXW_LIMIT_800x600: maxw=800; maxh=600; break;
+			case DXW_LIMIT_640x480: maxw=640; maxh=480; break;
-		case DXW_LIMIT_1024x768: maxw=1024; maxh=768; break;
+			case DXW_LIMIT_800x600: maxw=800; maxh=600; break;
-		case DXW_LIMIT_1280x960: maxw=1280; maxh=960; break;
+			case DXW_LIMIT_1024x768: maxw=1024; maxh=768; break;
+			case DXW_LIMIT_1280x960: maxw=1280; maxh=960; break;
+		}
+		if((lpDDSurfaceDesc->dwWidth > maxw) || (lpDDSurfaceDesc->dwHeight > maxh)){
+			OutTraceDW("EnumDisplaySettings: hide device mode=(%d,%d)\n", maxw, maxh);
+			return TRUE;
+		}
 	}
-	if((lpDDSurfaceDesc->dwWidth > maxw) || (lpDDSurfaceDesc->dwHeight > maxh)){
+
-		OutTraceDW("EnumDisplaySettings: hide device mode=(%d,%d)\n", maxw, maxh);
+	if(dxw.dwFlags7 & MAXIMUMRES) {
-		return TRUE;
+		if((lpDDSurfaceDesc->dwWidth > (DWORD)dxw.iMaxW) || (lpDDSurfaceDesc->dwHeight > (DWORD)dxw.iMaxH)){
+			OutTraceDW("EnumDisplaySettings: hide device mode=(%d,%d)\n", dxw.iMaxW, dxw.iMaxH);
+			return TRUE;
+		}	
 	}
+
 	return FALSE;
 }
 
@@ -4942,7 +4961,7 @@ HRESULT WINAPI myEnumModesFilterDirect(LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID l
 	for (int ResIdx=0; SupportedRes[ResIdx].h; ResIdx++){
 		lpDDSurfaceDesc->dwHeight=SupportedRes[ResIdx].h;
 		lpDDSurfaceDesc->dwWidth=SupportedRes[ResIdx].w;
-		if((dxw.dwFlags4 & LIMITSCREENRES) && CheckResolutionLimit(lpDDSurfaceDesc)) return DDENUMRET_OK;
+		if(CheckResolutionLimit(lpDDSurfaceDesc)) return DDENUMRET_OK;
 		if (dxw.dwFlags1 & PREVENTMAXIMIZE){
 			// if PREVENTMAXIMIZE is set, don't let the caller know about forbidden screen settings.
 			if((lpDDSurfaceDesc->dwHeight > dxw.GetScreenHeight()) ||
@@ -4973,7 +4992,7 @@ HRESULT WINAPI myEnumModesFilterNative(LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID l
 		}
 	}
 
-	if((dxw.dwFlags4 & LIMITSCREENRES) && CheckResolutionLimit(lpDDSurfaceDesc)) return DDENUMRET_OK;
+	if(CheckResolutionLimit(lpDDSurfaceDesc)) return DDENUMRET_OK;
 	res=(*((NewContext_Type *)lpContext)->lpCallback)(lpDDSurfaceDesc, ((NewContext_Type *)lpContext)->lpContext);
 	OutTraceDW("EnumDisplayModes(D): native size=(%d,%d) res=%x\n", lpDDSurfaceDesc->dwWidth, lpDDSurfaceDesc->dwHeight, res);
 	return res;
@@ -5021,8 +5040,7 @@ HRESULT WINAPI extEnumDisplayModes(int dxversion, EnumDisplayModes1_Type pEnumDi
 		for (ResIdx=0; SupportedRes[ResIdx].h; ResIdx++){
 			EmuDesc.dwHeight=SupportedRes[ResIdx].h;
 			EmuDesc.dwWidth=SupportedRes[ResIdx].w;
-			if((dxw.dwFlags4 & LIMITSCREENRES) && 
+			if(CheckResolutionLimit((LPDDSURFACEDESC)&EmuDesc)) break;
-				CheckResolutionLimit((LPDDSURFACEDESC)&EmuDesc)) break;
 			EmuDesc.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT);
 			EmuDesc.ddpfPixelFormat.dwFlags=DDPF_RGB;
 			for (DepthIdx=0; SupportedDepths[DepthIdx]; DepthIdx++) {
@@ -5419,7 +5437,7 @@ static HRESULT WINAPI extGetCapsS(int dxInterface, GetCapsS_Type pGetCapsS, LPDI
 		caps->dwCaps |= DDSCAPS_PRIMARYSURFACE|DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER|DDSCAPS_VIDEOMEMORY|DDSCAPS_VISIBLE; // primary surfaces must be this way
 		caps->dwCaps &= ~(DDSCAPS_SYSTEMMEMORY|DDSCAPS_OFFSCREENPLAIN); // primary surfaces can't be this way
 		if(caps->dwCaps & DDSCAPS_3DDEVICE) caps->dwCaps |= DDSCAPS_LOCALVIDMEM;
-		}
+	}
 
 	if (IsBack) {
 		IsFixed=TRUE;
@@ -5431,7 +5449,8 @@ static HRESULT WINAPI extGetCapsS(int dxInterface, GetCapsS_Type pGetCapsS, LPDI
 	}
 
 	// v2.03.82: fixed logic for ZBUFFER capabilities: "The Creed" may have two, in SYSTEMMEMORY or in VIDEOMEMORY ...
-	if(caps->dwCaps & DDSCAPS_ZBUFFER) {
+	// v2.03.90: "Galapagos" fix - if there's a DDSCAPS_SYSTEMMEMORY or DDSCAPS_VIDEOMEMORY spec, let it be.
+	if ((caps->dwCaps & DDSCAPS_ZBUFFER) && !(caps->dwCaps & (DDSCAPS_SYSTEMMEMORY|DDSCAPS_VIDEOMEMORY))) {
 		DWORD dwCaps;
 		dwCaps = dxwcdb.GetCaps(lpdds);
 		// beware! the ZBUFFER surface could have never been registered!

dll/dxhook.cpp

@@ -134,8 +134,8 @@ static char *Flag7Names[32]={
 	"NOWINERRORS", "SUPPRESSOVERLAY", "INIT24BPP", "INIT32BPP",
 	"FIXGLOBALUNLOCK", "SHOWHINTS", "SKIPDEVTYPEHID", "INJECTSUSPENDED",
 	"SSUPPRESSDIERRORS", "HOOKNORUN", "FIXBINDTEXTURE", "ENUM16BITMODES",
-	"SHAREDKEYBOARD", "HOOKNOUPDATE", "", "",
+	"SHAREDKEYBOARD", "HOOKNOUPDATE", "HOOKGLUT32", "INITIALRES",
-	"", "", "", "",
+	"MAXIMUMRES", "LOCKCOLORDEPTH", "", "",
 	"", "", "", "",
 };
 
@@ -1405,6 +1405,7 @@ void HookInit(TARGETMAP *target, HWND hwnd)
 				osinfo.dwMajorVersion, osinfo.dwMinorVersion, osinfo.dwPlatformId, osinfo.dwPlatformId, osinfo.szCSDVersion);
 		}
 		if (dxw.dwFlags4 & LIMITSCREENRES) OutTrace("HookInit: max resolution=%s\n", (dxw.MaxScreenRes<6)?Resolutions[dxw.MaxScreenRes]:"unknown");
+		if (dxw.dwFlags7 & MAXIMUMRES) OutTrace("HookInit: max resolution=(%dx%d)\n", dxw.iMaxW, dxw.iMaxH);
 		if (dxw.dwFlags7 & LIMITDDRAW) OutTrace("HookInit: max supported IDidrectDrawInterface=%d\n", dxw.MaxDdrawInterface);
 		if (dxw.dwFlags7 & CPUSLOWDOWN) OutTrace("HookInit: CPU slowdown ratio 1:%d\n", dxw.SlowRatio);
 		if (dxw.dwFlags7 & CPUMAXUSAGE) OutTrace("HookInit: CPU maxusage ratio 1:%d\n", dxw.SlowRatio);

dll/dxwcore.cpp

@@ -130,6 +130,8 @@ void dxwCore::InitTarget(TARGETMAP *target)
 	iSizY = target->sizy;
 	iPosX = target->posx;
 	iPosY = target->posy;
+	iMaxW = target->resw;
+	iMaxH = target->resh;
 	// Aspect Ratio from window size, or traditional 4:3 by default
 	iRatioX = iSizX ? iSizX : 800;
 	iRatioY = iSizY ? iSizY : 600;
@@ -156,12 +158,19 @@ void dxwCore::InitTarget(TARGETMAP *target)
 	bHintActive = (dwFlags7 & SHOWHINTS) ? TRUE : FALSE;
 
 	MonitorId = target->monitorid;
+
+	// if specified, set the custom initial resolution
+	if(dxw.dwFlags7 & INITIALRES) SetScreenSize(target->resw, target->resh);
 }
 
 void dxwCore::SetScreenSize(void) 
 {
-	if(dxw.Windowize)
+	// if specified, use values registered in InitTarget
+	if(dxw.dwFlags7 & INITIALRES) return;
+
+	if(dxw.Windowize){
 		SetScreenSize(800, 600); // set to default screen resolution
+	}
 	else{
 		int sizx, sizy;
 		sizx = GetSystemMetrics(SM_CXSCREEN);
@@ -200,6 +209,14 @@ void dxwCore::SetScreenSize(int x, int y)
 			dwScreenHeight= p->Height = (short)maxh;
 		}
 	}
+	if(dxw.dwFlags7 & MAXIMUMRES){
+		if(((long)p->Width > dxw.iMaxW) || ((long)p->Height > dxw.iMaxH)){
+			OutTraceDW("DXWND: limit device size=(%d,%d)\n", dxw.iMaxW, dxw.iMaxH);
+			// v2.03.90 setting new virtual desktop size 
+			dwScreenWidth = p->Width = (short)dxw.iMaxW;
+			dwScreenHeight= p->Height = (short)dxw.iMaxH;
+		}
+	}
 }
 
 void dxwCore::DumpDesktopStatus()
@@ -1497,6 +1514,11 @@ BOOL dxwCore::CheckScreenResolution(unsigned int w, unsigned int h)
 		}
 		if((w > maxw) || (h > maxh)) return FALSE;
 	}
+
+	if(dxw.dwFlags7 & MAXIMUMRES){
+		if(((long)w > dxw.iMaxW) || ((long)h > dxw.iMaxH)) return FALSE;
+	}
+
 	return TRUE;
 }
 

dll/dxwcore.hpp

@@ -177,6 +177,8 @@ public: // simple data variables
 	long iPosY;
 	long iSizX;
 	long iSizY;
+	long iMaxW;
+	long iMaxH;
 	int iRatioX;
 	int iRatioY;
 	char *CustomOpenGLLib;

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.89"
+#define VERSION "2.03.90"
 
 #define DDTHREADLOCK 1
 //#define LOCKTHREADS

dll/gdi32.cpp

@@ -984,35 +984,6 @@ HDC WINAPI extGDICreateCompatibleDC(HDC hdc)
 	return RetHdc;
 }
 
-/*----------------------------------------*/
-HBITMAP VirtualPic;
-
-static HDC FillVirtualDC(HDC hdc)
-{
-	HDC VirtualHDC;
-	HBITMAP VirtualPic;
-
-	if(!(VirtualHDC=CreateCompatibleDC(hdc)))
-		OutTraceE("CreateCompatibleDC: ERROR err=%d at=%d\n", GetLastError(), __LINE__);
-
-	if(!(VirtualPic=CreateCompatibleBitmap(hdc, dxw.GetScreenWidth(), dxw.GetScreenHeight())))
-		OutTraceE("dxwSDC::GetPrimaryDC: CreateCompatibleBitmap ERROR err=%d at=%d\n", GetLastError(), __LINE__);
-
-	if(!SelectObject(VirtualHDC, VirtualPic))
-		OutTraceE("dxwSDC::GetPrimaryDC: SelectObject ERROR err=%d at=%d\n", GetLastError(), __LINE__);
-
-	if(!(*pGDIBitBlt)(VirtualHDC, 0, 0, dxw.GetScreenWidth(), dxw.GetScreenHeight(), hdc, 0, 0, SRCCOPY))
-		OutTraceE("dxwSDC::GetPrimaryDC: StretchBlt ERROR err=%d at=%d\n", GetLastError(), __LINE__);
-
-	return VirtualHDC;
-}
-
-static void FlushVirtualDC(HDC VirtualHDC)
-{
-	DeleteObject(VirtualHDC);
-	DeleteObject(VirtualPic);
-}
-
 /*-------------------------------------------*/
 
 BOOL WINAPI extGDIBitBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HDC hdcSrc, int nXSrc, int nYSrc, DWORD dwRop)
@@ -1038,12 +1009,12 @@ BOOL WINAPI extGDIBitBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nH
 	if(hdcDest == NULL){
 		// happens in Reah, hdc is NULL despite the fact that BeginPaint returns a valid DC. Too bad, we recover here ...
 		hdcDest = (*pGDIGetDC)(dxw.GethWnd());
-		OutTraceB("GDI.StretchBlt: DEBUG hdc dest=NULL->%x\n", hdcDest);
+		OutTraceB("GDI.BitBlt: DEBUG hdc dest=NULL->%x\n", hdcDest);
 		IsDCLeakageDest = TRUE;
 	}
 	if(hdcSrc == NULL){
 		hdcSrc = (*pGDIGetDC)(dxw.GethWnd());
-		OutTraceB("GDI.StretchBlt: DEBUG hdc src=NULL->%x\n", hdcSrc);
+		OutTraceB("GDI.BitBlt: DEBUG hdc src=NULL->%x\n", hdcSrc);
 		IsDCLeakageSrc = TRUE;
 	}
 

dll/hd3d7.cpp

@@ -64,7 +64,7 @@ CreateMaterial3_Type pCreateMaterial3 = NULL;
 CreateViewport1_Type pCreateViewport1 = NULL;
 CreateViewport2_Type pCreateViewport2 = NULL;
 CreateViewport3_Type pCreateViewport3 = NULL;
-FindDevice_Type pFindDevice = NULL;
+FindDevice_Type pFindDevice1, pFindDevice2, pFindDevice3;
 CreateDevice2_Type pCreateDevice2 = NULL;
 CreateDevice3_Type pCreateDevice3 = NULL;
 CreateDevice7_Type pCreateDevice7 = NULL;
@@ -196,7 +196,9 @@ HRESULT WINAPI extCreateMaterial3(void *, LPDIRECT3DMATERIAL3 *, IUnknown *);
 HRESULT WINAPI extCreateViewport1(void *, LPDIRECT3DVIEWPORT *, IUnknown *);
 HRESULT WINAPI extCreateViewport2(void *, LPDIRECT3DVIEWPORT2 *, IUnknown *);
 HRESULT WINAPI extCreateViewport3(void *, LPDIRECT3DVIEWPORT3 *, IUnknown *);
-HRESULT WINAPI extFindDevice(void *, LPD3DFINDDEVICESEARCH, LPD3DFINDDEVICERESULT);
+HRESULT WINAPI extFindDevice1(void *, LPD3DFINDDEVICESEARCH, LPD3DFINDDEVICERESULT);
+HRESULT WINAPI extFindDevice2(void *, LPD3DFINDDEVICESEARCH, LPD3DFINDDEVICERESULT);
+HRESULT WINAPI extFindDevice3(void *, LPD3DFINDDEVICESEARCH, LPD3DFINDDEVICERESULT);
 HRESULT WINAPI extCreateDevice2(void *, REFCLSID, LPDIRECTDRAWSURFACE, LPDIRECT3DDEVICE2 *);
 HRESULT WINAPI extCreateDevice3(void *, REFCLSID, LPDIRECTDRAWSURFACE4, LPDIRECT3DDEVICE3 *, LPUNKNOWN);
 HRESULT WINAPI extCreateDevice7(void *, REFCLSID, LPDIRECTDRAWSURFACE7, LPDIRECT3DDEVICE7 *);
@@ -447,7 +449,7 @@ void HookDirect3DSession(LPDIRECTDRAW *lplpdd, int d3dversion)
 		SetHook((void *)(**(DWORD **)lplpdd +  24), extCreateMaterial1, (void **)&pCreateMaterial1, "CreateMaterial(1)");
 #endif
 		SetHook((void *)(**(DWORD **)lplpdd +  28), extCreateViewport1, (void **)&pCreateViewport1, "CreateViewport(1)");
-		SetHook((void *)(**(DWORD **)lplpdd +  32), extFindDevice, (void **)&pFindDevice, "FindDevice");	
+		SetHook((void *)(**(DWORD **)lplpdd +  32), extFindDevice1, (void **)&pFindDevice1, "FindDevice(1)");	
 		break;
 	case 2:
 		SetHook((void *)(**(DWORD **)lplpdd +   0), extQueryInterfaceD32, (void **)&pQueryInterfaceD32, "QueryInterface(D3S2)");
@@ -457,7 +459,7 @@ void HookDirect3DSession(LPDIRECTDRAW *lplpdd, int d3dversion)
 		SetHook((void *)(**(DWORD **)lplpdd +  20), extCreateMaterial2, (void **)&pCreateMaterial2, "CreateMaterial(2)");
 #endif
 		SetHook((void *)(**(DWORD **)lplpdd +  24), extCreateViewport2, (void **)&pCreateViewport2, "CreateViewport(2)");
-		SetHook((void *)(**(DWORD **)lplpdd +  28), extFindDevice, (void **)&pFindDevice, "FindDevice");
+		SetHook((void *)(**(DWORD **)lplpdd +  28), extFindDevice2, (void **)&pFindDevice2, "FindDevice(2)");
 		SetHook((void *)(**(DWORD **)lplpdd +  32), extCreateDevice2, (void **)&pCreateDevice2, "CreateDevice(D3D2)");
 		break;
 	case 3:
@@ -468,7 +470,7 @@ void HookDirect3DSession(LPDIRECTDRAW *lplpdd, int d3dversion)
 		SetHook((void *)(**(DWORD **)lplpdd +  20), extCreateMaterial3, (void **)&pCreateMaterial3, "CreateMaterial(3)");
 #endif
 		SetHook((void *)(**(DWORD **)lplpdd +  24), extCreateViewport3, (void **)&pCreateViewport3, "CreateViewport(3)");
-		SetHook((void *)(**(DWORD **)lplpdd +  28), extFindDevice, (void **)&pFindDevice, "FindDevice");
+		SetHook((void *)(**(DWORD **)lplpdd +  28), extFindDevice3, (void **)&pFindDevice3, "FindDevice(3)");
 		SetHook((void *)(**(DWORD **)lplpdd +  32), extCreateDevice3, (void **)&pCreateDevice3, "CreateDevice(D3D3)");
 		SetHook((void *)(**(DWORD **)lplpdd +  40), extEnumZBufferFormats3, (void **)&pEnumZBufferFormats3, "EnumZBufferFormats(D3D3)");
 		break;
@@ -697,7 +699,7 @@ HRESULT WINAPI extQueryInterfaceD3(int d3dversion, QueryInterfaceD3_Type pQueryI
 		SetHook((void *)(**(DWORD **)ppvObj +  24), extCreateMaterial1, (void **)&pCreateMaterial1, "CreateMaterial(1)");
 #endif
 		SetHook((void *)(**(DWORD **)ppvObj +  28), extCreateViewport1, (void **)&pCreateViewport1, "CreateViewport(1)");
-		SetHook((void *)(**(DWORD **)ppvObj +  32), extFindDevice, (void **)&pFindDevice, "FindDevice");	
+		SetHook((void *)(**(DWORD **)ppvObj +  32), extFindDevice1, (void **)&pFindDevice1, "FindDevice(1)");	
 		break;
 	case 2:
 		SetHook((void *)(**(DWORD **)ppvObj +  12), extEnumDevices2, (void **)&pEnumDevices2, "EnumDevices(2)");
@@ -706,16 +708,16 @@ HRESULT WINAPI extQueryInterfaceD3(int d3dversion, QueryInterfaceD3_Type pQueryI
 		SetHook((void *)(**(DWORD **)ppvObj +  20), extCreateMaterial2, (void **)&pCreateMaterial2, "CreateMaterial(2)");
 #endif
 		SetHook((void *)(**(DWORD **)ppvObj +  24), extCreateViewport2, (void **)&pCreateViewport2, "CreateViewport(2)"); 
-		SetHook((void *)(**(DWORD **)ppvObj +  28), extFindDevice, (void **)&pFindDevice, "FindDevice");
+		SetHook((void *)(**(DWORD **)ppvObj +  28), extFindDevice2, (void **)&pFindDevice2, "FindDevice(2)");
 		break;
 	case 3:
-		SetHook((void *)(**(DWORD **)ppvObj +  12), extEnumDevices3, (void **)&pEnumDevices3, "EnumDevices");
+		SetHook((void *)(**(DWORD **)ppvObj +  12), extEnumDevices3, (void **)&pEnumDevices3, "EnumDevices(3)");
 		SetHook((void *)(**(DWORD **)ppvObj +  16), extCreateLight3, (void **)&pCreateLight3, "CreateLight(3)");
 #ifdef TRACEMATERIAL
 		SetHook((void *)(**(DWORD **)ppvObj +  20), extCreateMaterial3, (void **)&pCreateMaterial3, "CreateMaterial(3)");
 #endif
 		SetHook((void *)(**(DWORD **)ppvObj +  24), extCreateViewport3, (void **)&pCreateViewport3, "CreateViewport(3)"); 
-		SetHook((void *)(**(DWORD **)ppvObj +  28), extFindDevice, (void **)&pFindDevice, "FindDevice");
+		SetHook((void *)(**(DWORD **)ppvObj +  28), extFindDevice3, (void **)&pFindDevice3, "FindDevice(3)");
 		break;
 	case 7:
 		SetHook((void *)(**(DWORD **)ppvObj +  12), extEnumDevices7, (void **)&pEnumDevices7, "EnumDevices(7)");
@@ -986,12 +988,12 @@ HRESULT WINAPI extCreateViewport3(void *lpd3d, LPDIRECT3DVIEWPORT3 *lpViewport,
 	return res;
 }
 
-HRESULT WINAPI extFindDevice(void *lpd3d, LPD3DFINDDEVICESEARCH p1, LPD3DFINDDEVICERESULT p2)
+static HRESULT WINAPI extFindDevice(int d3dversion, FindDevice_Type pFindDevice, void *lpd3d, LPD3DFINDDEVICESEARCH p1, LPD3DFINDDEVICERESULT p2)
 {
 	HRESULT res;
 
-	OutTraceD3D("FindDevice: d3d=%x devsearch=%x (size=%d flags=%x caps=%x primcaps=%x colormodel=%x hw=%x guid=%x) p2=%x\n", 
+	OutTraceD3D("FindDevice(%d): d3d=%x devsearch=%x (size=%d flags=%x caps=%x primcaps=%x colormodel=%x hw=%x guid=%x) p2=%x\n", 
-		lpd3d, p1, p1->dwSize, p1->dwFlags, p1->dwCaps, p1->dpcPrimCaps, p1->dcmColorModel, p1->bHardware, p1->guid, p2);
+		d3dversion, lpd3d, p1, p1->dwSize, p1->dwFlags, p1->dwCaps, p1->dpcPrimCaps, p1->dcmColorModel, p1->bHardware, p1->guid, p2);
 	res=(*pFindDevice)(lpd3d, p1, p2);
 	if(res) OutTraceE("FindDevice ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
 	else {
@@ -1002,6 +1004,13 @@ HRESULT WINAPI extFindDevice(void *lpd3d, LPD3DFINDDEVICESEARCH p1, LPD3DFINDDEV
 	return res;
 }
 
+HRESULT WINAPI extFindDevice1(void *lpd3d, LPD3DFINDDEVICESEARCH p1, LPD3DFINDDEVICERESULT p2)
+{ return extFindDevice(1, pFindDevice1, lpd3d, p1, p2); }
+HRESULT WINAPI extFindDevice2(void *lpd3d, LPD3DFINDDEVICESEARCH p1, LPD3DFINDDEVICERESULT p2)
+{ return extFindDevice(2, pFindDevice2, lpd3d, p1, p2); }
+HRESULT WINAPI extFindDevice3(void *lpd3d, LPD3DFINDDEVICESEARCH p1, LPD3DFINDDEVICERESULT p2)
+{ return extFindDevice(3, pFindDevice3, lpd3d, p1, p2); }
+
 HRESULT WINAPI extSetViewport(int dxversion, SetViewport_Type pSetViewport, void *lpvp, LPD3DVIEWPORT vpd)
 {
 	HRESULT res;

dll/opengl.cpp

@@ -20,6 +20,19 @@
 #define COMPRESSED_RGBA_S3TC_DXT5_EXT                  0x83F3
 #endif
 
+typedef void (WINAPI *glutFullScreen_Type)(void);
+glutFullScreen_Type pglutFullScreen;
+void WINAPI extglutFullScreen(void);
+typedef void (WINAPI *glutInitWindowSize_Type)(int, int);
+glutInitWindowSize_Type pglutInitWindowSize;
+void extglutInitWindowSize(int, int);
+typedef void (WINAPI *glutInitWindowPosition_Type)(int, int);
+glutInitWindowPosition_Type pglutInitWindowPosition;
+void extglutInitWindowPosition(int, int);
+typedef void (WINAPI *glutSetWindow_Type)(HWND);
+glutSetWindow_Type pglutSetWindow;
+void WINAPI extglutSetWindow(HWND);
+
 //void WINAPI extglDrawPixels(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
 //typedef void (WINAPI *glDrawPixels_Type)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
 //glDrawPixels_Type pglDrawPixels = NULL;
@@ -45,11 +58,20 @@ static HookEntryEx_Type Hooks[]={
 	{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
 };
 
+static HookEntryEx_Type GlutHooks[]={
+	{HOOK_IAT_CANDIDATE, 0, "glutFullScreen", NULL, (FARPROC *)&pglutFullScreen, (FARPROC)extglutFullScreen},
+	{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, 0, NULL, 0, 0} // terminator
+};
+
 FARPROC Remap_gl_ProcAddress(LPCSTR proc, HMODULE hModule)
 {
 	FARPROC addr;
 	if(!(dxw.dwFlags2 & HOOKOPENGL)) return NULL; 
 	if (addr=RemapLibraryEx(proc, hModule, Hooks)) return addr;
+	if (dxw.dwFlags7 & HOOKGLUT32) if(addr=RemapLibraryEx(proc, hModule, GlutHooks)) return addr;
 	// NULL -> keep the original call address
 	return NULL;
 }
@@ -115,6 +137,8 @@ void HookOpenGL(HMODULE module, char *customlib)
 	else
 		HookLibraryEx(module, Hooks, customlib);
 
+	if(dxw.dwFlags7 & HOOKGLUT32) HookLibraryEx(module, GlutHooks, "glut32.dll");
+
 	return;
 }
 
@@ -130,7 +154,6 @@ void WINAPI extglViewport(GLint  x,  GLint  y,  GLsizei  width,  GLsizei  height
 	RECT client;
 	POINT p={0,0};
 	HWND hwnd;
-	//if (dxw.dwFlags2 & HANDLEFPS) if(dxw.HandleFPS()) return;
 	hwnd=dxw.GethWnd();
 	(*pGetClientRect)(hwnd, &client);
 	OutTraceDW("glViewport: declared pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
@@ -570,4 +593,45 @@ void WINAPI extglPixelStorei(GLenum pname,  GLint param)
 	(*pglPixelStorei)(pname, param);
 	if ((glerr=extglGetError())!= GL_NO_ERROR) OutTrace("GLERR %d ad %d\n", glerr, __LINE__);
 	return;
-}
+}
+
+void WINAPI extglutFullScreen(void)
+{
+	if(!dxw.Windowize) return (*pglutFullScreen)();
+	OutTrace("glutFullScreen BYPASS\n");
+	dxw.SetFullScreen(TRUE);
+}
+
+void extglutInitWindowSize(int width, int height)
+{
+	int dummy1, dummy2;
+	if(dxw.Windowize){
+		dummy1=0;
+		dummy2=0;
+		OutTrace("glutInitWindowSize: width=%d height=%d\n", width, height);
+		dxw.MapWindow(&dummy1, &dummy2, &width, &height);	
+		OutTrace("glutInitWindowSize: FIXED width=%d height=%d\n", width, height);
+	}
+	(*pglutInitWindowSize)(width, height);
+}
+
+void extglutInitWindowPosition(int x, int y)
+{
+	int dummy1, dummy2;
+	if(dxw.Windowize){
+		dummy1=0;
+		dummy2=0;
+		OutTrace("glutInitWindowPosition: x=%d y=%d\n", x, y);
+		dxw.MapWindow(&x, &y, &dummy1, &dummy2);
+		OutTrace("glutInitWindowPosition: FIXED x=%d y=%d\n", x, y);
+	}
+	(*pglutInitWindowPosition)(x, y);
+}
+
+void WINAPI extglutSetWindow(HWND win)
+{
+	OutTrace("glutSetWindow: win=%x\n", win);
+	if(dxw.Windowize && dxw.IsRealDesktop(win)) win=dxw.GethWnd();
+	(*pglutSetWindow)(win);
+}
+

dll/syslibs.h

@@ -503,7 +503,6 @@ extern BOOL WINAPI extImmGetOpenStatus(HIMC);
 // GDI32.dll:
 extern BOOL WINAPI extGDIBitBlt(HDC, int, int, int, int, HDC, int, int, DWORD);
 extern HDC WINAPI extGDICreateCompatibleDC(HDC);
-extern HDC WINAPI extEMUCreateCompatibleDC(HDC);
 extern HDC WINAPI extGDICreateDCA(LPSTR, LPSTR, LPSTR, CONST DEVMODE *);
 extern HDC WINAPI extGDICreateDCW(LPWSTR, LPWSTR, LPWSTR, CONST DEVMODE *);
 extern HFONT WINAPI extCreateFont(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPCTSTR);

dll/user32.cpp

@@ -1166,6 +1166,7 @@ BOOL WINAPI extScreenToClient(HWND hwnd, LPPOINT lppoint)
 	else {
 		res=(*pScreenToClient)(hwnd, lppoint);
 	}
+	OutTraceB("ScreenToClient: returned point=(%d,%d)\n", lppoint->x, lppoint->y);
 	return res;
 }
 
@@ -1564,7 +1565,8 @@ static HWND WINAPI CreateWindowCommon(
 		}
 		nWidth=dxw.GetScreenWidth();
 		nHeight=dxw.GetScreenHeight();
-		OutTraceDW("%s: fixed client pos=(%d,%d) size=(%d,%d)\n", ApiName, x, y, nWidth, nHeight);
+		OutTraceDW("%s: fixed client pos=(%d,%d) size=(%d,%d) valid=%x\n", 
+			ApiName, x, y, nWidth, nHeight, isValidHandle);
 		dxw.SetFullScreen(TRUE);
 	}
 
@@ -2095,6 +2097,13 @@ LONG WINAPI extEnumDisplaySettings(LPCTSTR lpszDeviceName, DWORD iModeNum, DEVMO
 			lpDevMode->dmPelsHeight = maxh;
 		}
 	}
+	if(dxw.dwFlags7 & MAXIMUMRES){
+		if((lpDevMode->dmPelsWidth > (DWORD)dxw.iMaxW) || (lpDevMode->dmPelsHeight > (DWORD)dxw.iMaxH)){
+			OutTraceDW("EnumDisplaySettings: limit device size=(%d,%d)\n", dxw.iMaxW, dxw.iMaxH);
+			lpDevMode->dmPelsWidth = dxw.iMaxW;
+			lpDevMode->dmPelsHeight = dxw.iMaxH;
+		}
+	}
 
 	OutTraceDW("EnumDisplaySettings: color=%dBPP size=(%dx%d) refresh=%dHz\n", 
 		lpDevMode->dmBitsPerPel, lpDevMode->dmPelsWidth, lpDevMode->dmPelsHeight, lpDevMode->dmDisplayFrequency);

host/TabDirectX.cpp

@@ -38,7 +38,6 @@ void CTabDirectX::DoDataExchange(CDataExchange* pDX)
 	DDX_Check(pDX, IDC_SUPPRESSRELEASE, cTarget->m_SuppressRelease);
 	DDX_Check(pDX, IDC_VIDEOTOSYSTEMMEM, cTarget->m_VideoToSystemMem);
 	DDX_Check(pDX, IDC_SUPPRESSDXERRORS, cTarget->m_SuppressDXErrors);
-	DDX_Check(pDX, IDC_BACKBUFATTACH, cTarget->m_BackBufAttach);
 	DDX_Check(pDX, IDC_NOPALETTEUPDATE, cTarget->m_NoPaletteUpdate);
 	DDX_Check(pDX, IDC_NOPIXELFORMAT, cTarget->m_NoPixelFormat);
 	DDX_Check(pDX, IDC_NOALPHACHANNEL, cTarget->m_NoAlphaChannel);
@@ -46,6 +45,7 @@ void CTabDirectX::DoDataExchange(CDataExchange* pDX)
 	DDX_Check(pDX, IDC_FLIPEMULATION, cTarget->m_FlipEmulation);
 	DDX_Check(pDX, IDC_SETCOMPATIBILITY, cTarget->m_SetCompatibility);
 	DDX_Check(pDX, IDC_AEROBOOST, cTarget->m_AEROBoost);
+	DDX_Check(pDX, IDC_LOCKCOLORDEPTH, cTarget->m_LockColorDepth);
 }
 
 BEGIN_MESSAGE_MAP(CTabDirectX, CDialog)

host/TabDirectX2.cpp

@@ -40,7 +40,10 @@ void CTabDirectX2::DoDataExchange(CDataExchange* pDX)
 	DDX_Check(pDX, IDC_DEINTERLACE, cTarget->m_Deinterlace);
 	DDX_Check(pDX, IDC_LIMITDDRAW, cTarget->m_LimitDdraw);
 	DDX_Check(pDX, IDC_SUPPRESSOVERLAY, cTarget->m_SuppressOverlay);
+	DDX_Check(pDX, IDC_BLACKWHITE, cTarget->m_BlackWhite);
+	DDX_Check(pDX, IDC_USERGB565, cTarget->m_UseRGB565);
 	DDX_CBIndex(pDX, IDC_DDWAWLIMITCOMBO, cTarget->m_MaxDdrawInterface);
+	DDX_Check(pDX, IDC_BACKBUFATTACH, cTarget->m_BackBufAttach);
 }
 
 BEGIN_MESSAGE_MAP(CTabDirectX2, CDialog)

host/TabSysLibs.cpp

@@ -41,6 +41,7 @@ void CTabSysLibs::DoDataExchange(CDataExchange* pDX)
 	DDX_Check(pDX, IDC_FORCEHOOKOPENGL, cTarget->m_ForceHookOpenGL);
 	DDX_Check(pDX, IDC_FIXPIXELZOOM, cTarget->m_FixPixelZoom);
 	DDX_Check(pDX, IDC_FIXBINDTEXTURE, cTarget->m_FixBindTexture);
+	DDX_Check(pDX, IDC_HOOKGLUT32, cTarget->m_HookGlut32);
 	DDX_Text(pDX, IDC_OPENGLLIB, cTarget->m_OpenGLLib);
 
 	// Glide

host/TabWindow.cpp

@@ -52,8 +52,6 @@ void CTabWindow::DoDataExchange(CDataExchange* pDX)
 	DDX_Radio(pDX, IDC_COLORCURRENT, cTarget->m_InitColorDepth);
 	DDX_Check(pDX, IDC_DISABLEGAMMARAMP, cTarget->m_DisableGammaRamp);
 	DDX_Check(pDX, IDC_FORCE16BPP, cTarget->m_Force16BPP);
-	DDX_Check(pDX, IDC_BLACKWHITE, cTarget->m_BlackWhite);
-	DDX_Check(pDX, IDC_USERGB565, cTarget->m_UseRGB565);
 	DDX_Check(pDX, IDC_LOCKSYSCOLORS, cTarget->m_LockSysColors);
 	DDX_Check(pDX, IDC_LOCKRESERVEDPALETTE, cTarget->m_LockReservedPalette);
 
@@ -61,6 +59,10 @@ void CTabWindow::DoDataExchange(CDataExchange* pDX)
 	DDX_Check(pDX, IDC_LIMITSCREENRES, cTarget->m_LimitScreenRes);
 	DDX_LBIndex(pDX, IDC_LISTRES, cTarget->m_MaxScreenRes);
 	DDX_Radio(pDX, IDC_SUPPORTSVGA, cTarget->m_ResTypes);
+	DDX_Check(pDX, IDC_INITIALRES, cTarget->m_InitialRes);
+	DDX_Check(pDX, IDC_MAXIMUMRES, cTarget->m_MaximumRes);
+	DDX_Text(pDX, IDC_INITW, cTarget->m_InitResW);
+	DDX_Text(pDX, IDC_INITH, cTarget->m_InitResH);
 }
 
 static char *Resolutions[]={

host/TargetDlg.cpp

@@ -137,6 +137,7 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
 	m_SlowDown = FALSE;
 	m_BlitFromBackBuffer = FALSE;
 	m_NoFlipEmulation = FALSE;
+	m_LockColorDepth = FALSE;
 	m_SuppressClipping = FALSE;
 	m_ForceClipper = FALSE;
 	m_DisableGammaRamp = FALSE;
@@ -212,6 +213,7 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
 	m_ForceHookOpenGL = FALSE;
 	m_FixPixelZoom = FALSE;
 	m_FixBindTexture = FALSE;
+	m_HookGlut32 = FALSE;
 	m_FakeVersion = FALSE;
 	m_FullRectBlt = FALSE;
 	m_CenterToWin = FALSE;
@@ -234,10 +236,14 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
 	m_NoTextures = FALSE;
 	m_BlackWhite = FALSE;
 	m_AssertDialog = FALSE;
+	m_InitialRes = FALSE;
+	m_MaximumRes = FALSE;
 	m_PosX = 50;
 	m_PosY = 50;
 	m_SizX = 800;
 	m_SizY = 600;
+	m_InitResW = 800;
+	m_InitResH = 600;
 	m_MaxFPS = 0;
 	m_InitTS = 8;
 	m_SwapEffect = 0;

host/TargetDlg.h

@@ -100,6 +100,7 @@ public:
 	BOOL	m_SlowDown;
 	BOOL	m_BlitFromBackBuffer;
 	BOOL	m_NoFlipEmulation;
+	BOOL	m_LockColorDepth;
 	BOOL	m_SuppressClipping;
 	BOOL	m_ForceClipper;
 	BOOL	m_DisableGammaRamp;
@@ -175,6 +176,7 @@ public:
 	BOOL	m_ForceHookOpenGL;
 	BOOL	m_FixPixelZoom;
 	BOOL	m_FixBindTexture;
+	BOOL	m_HookGlut32;
 	BOOL	m_FakeVersion;
 	BOOL	m_FullRectBlt;
 	BOOL	m_CenterToWin;
@@ -251,10 +253,14 @@ public:
 	BOOL	m_Enum16bitModes;
 	BOOL	m_Force16BPP;
 	BOOL	m_LimitScreenRes;
+	BOOL	m_InitialRes;
+	BOOL	m_MaximumRes;
 	int		m_PosX;
 	int		m_PosY;
 	int		m_SizX;
 	int		m_SizY;
+	int		m_InitResW;
+	int		m_InitResH;
 	int		m_MaxFPS;
 	int		m_InitTS;
 	int		m_FakeVersionId;

host/dxwndhostView.cpp

@@ -384,6 +384,7 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
 	if(dlg->m_SlowDown) t->flags |= SLOWDOWN;
 	if(dlg->m_BlitFromBackBuffer) t->flags |= BLITFROMBACKBUFFER;
 	if(dlg->m_NoFlipEmulation) t->flags4 |= NOFLIPEMULATION;
+	if(dlg->m_LockColorDepth) t->flags7 |= LOCKCOLORDEPTH;
 	if(dlg->m_SuppressClipping) t->flags |= SUPPRESSCLIPPING;
 	if(dlg->m_ForceClipper) t->flags3 |= FORCECLIPPER;
 	if(dlg->m_DisableGammaRamp) t->flags2 |= DISABLEGAMMARAMP;
@@ -457,6 +458,7 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
 	if(dlg->m_ForceHookOpenGL) t->flags3 |= FORCEHOOKOPENGL;
 	if(dlg->m_FixPixelZoom) t->flags6 |= FIXPIXELZOOM;
 	if(dlg->m_FixBindTexture) t->flags7 |= FIXBINDTEXTURE;
+	if(dlg->m_HookGlut32) t->flags7 |= HOOKGLUT32;
 	if(dlg->m_WireFrame) t->flags2 |= WIREFRAME;
 	if(dlg->m_NoTextures) t->flags4 |= NOTEXTURES;
 	if(dlg->m_BlackWhite) t->flags3 |= BLACKWHITE;
@@ -479,6 +481,8 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
 	if(dlg->m_NoWinErrors) t->flags7 |= NOWINERRORS;
 	if(dlg->m_AnalyticMode) t->flags3 |= ANALYTICMODE;
 	if(dlg->m_ReplacePrivOps) t->flags5 |= REPLACEPRIVOPS;
+	if(dlg->m_InitialRes) t->flags7 |= INITIALRES;
+	if(dlg->m_MaximumRes) t->flags7 |= MAXIMUMRES;
 	t->posx = dlg->m_PosX;
 	t->posy = dlg->m_PosY;
 	t->sizx = dlg->m_SizX;
@@ -488,6 +492,8 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
 	t->FakeVersionId = dlg->m_FakeVersionId;
 	t->MaxScreenRes = dlg->m_MaxScreenRes;
 	t->SwapEffect = dlg->m_SwapEffect;
+	t->resw = dlg->m_InitResW;
+	t->resh = dlg->m_InitResH;
 	strcpy_s(t->module, sizeof(t->module), dlg->m_Module);
 	strcpy_s(t->OpenGLLib, sizeof(t->OpenGLLib), dlg->m_OpenGLLib);
 }
@@ -662,6 +668,7 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
 	dlg->m_SlowDown = t->flags & SLOWDOWN ? 1 : 0;
 	dlg->m_BlitFromBackBuffer = t->flags & BLITFROMBACKBUFFER ? 1 : 0;
 	dlg->m_NoFlipEmulation = t->flags4 & NOFLIPEMULATION ? 1 : 0;
+	dlg->m_LockColorDepth = t->flags7 & LOCKCOLORDEPTH ? 1 : 0;
 	dlg->m_SuppressClipping = t->flags & SUPPRESSCLIPPING ? 1 : 0;
 	dlg->m_ForceClipper = t->flags3 & FORCECLIPPER ? 1 : 0;
 	dlg->m_DisableGammaRamp = t->flags2 & DISABLEGAMMARAMP ? 1 : 0;
@@ -733,6 +740,7 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
 	dlg->m_ForceHookOpenGL = t->flags3 & FORCEHOOKOPENGL ? 1 : 0;
 	dlg->m_FixPixelZoom = t->flags6 & FIXPIXELZOOM ? 1 : 0;
 	dlg->m_FixBindTexture = t->flags7 & FIXBINDTEXTURE ? 1 : 0;
+	dlg->m_HookGlut32 = t->flags7 & HOOKGLUT32 ? 1 : 0;
 	dlg->m_WireFrame = t->flags2 & WIREFRAME ? 1 : 0;
 	dlg->m_NoTextures = t->flags4 & NOTEXTURES ? 1 : 0;
 	dlg->m_BlackWhite = t->flags3 & BLACKWHITE ? 1 : 0;
@@ -755,6 +763,8 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
 	dlg->m_NoWinErrors = t->flags7 & NOWINERRORS ? 1 : 0;
 	dlg->m_AnalyticMode = t->flags3 & ANALYTICMODE ? 1 : 0;
 	dlg->m_ReplacePrivOps = t->flags5 & REPLACEPRIVOPS ? 1 : 0;
+	dlg->m_InitialRes = t->flags7 & INITIALRES ? 1 : 0;
+	dlg->m_MaximumRes = t->flags7 & MAXIMUMRES ? 1 : 0;
 	dlg->m_PosX = t->posx;
 	dlg->m_PosY = t->posy;
 	dlg->m_SizX = t->sizx;
@@ -763,6 +773,8 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
 	dlg->m_InitTS = t->InitTS+8;
 	dlg->m_FakeVersionId = t->FakeVersionId;
 	dlg->m_MaxScreenRes = t->MaxScreenRes;
+	dlg->m_InitResW = t->resw;
+	dlg->m_InitResH = t->resh;
 	dlg->m_SwapEffect = t->SwapEffect;
 }
 
@@ -897,6 +909,14 @@ static void SaveConfigItem(TARGETMAP *TargetMap, PRIVATEMAP *PrivateMap, int i,
 	sprintf_s(key, sizeof(key), "slowratio%i", i);
 	sprintf_s(val, sizeof(val), "%i", TargetMap->SlowRatio);
 	WritePrivateProfileString("target", key, val, InitPath);
+	// -------
+	sprintf_s(key, sizeof(key), "initresw%i", i);
+	sprintf_s(val, sizeof(val), "%i", TargetMap->resw);
+	WritePrivateProfileString("target", key, val, InitPath);
+	// -------
+	sprintf_s(key, sizeof(key), "initresh%i", i);
+	sprintf_s(val, sizeof(val), "%i", TargetMap->resh);
+	WritePrivateProfileString("target", key, val, InitPath);
 
 	free(EscBuf);
 	EscBuf = NULL;
@@ -1085,6 +1105,12 @@ static int LoadConfigItem(TARGETMAP *TargetMap, PRIVATEMAP *PrivateMap, int i, c
 	// -------
 	sprintf_s(key, sizeof(key), "slowratio%i", i);
 	TargetMap->SlowRatio = GetPrivateProfileInt("target", key, 1, InitPath);
+	// -------
+	sprintf_s(key, sizeof(key), "initresw%i", i);
+	TargetMap->resw = GetPrivateProfileInt("target", key, 0, InitPath);
+	// -------
+	sprintf_s(key, sizeof(key), "initresh%i", i);
+	TargetMap->resh = GetPrivateProfileInt("target", key, 0, InitPath);
 	
 	if (!gbDebug){
 		// clear debug flags