backup/DxWnd.reloaded
1
0
Fork 0
mirror of https://github.com/DxWnd/DxWnd.reloaded synced 2024-12-30 09:25:35 +01:00
Code Issues Projects Releases Activity

v2_04_05_src

Browse Source 
Former-commit-id: 6498153d12a021f914308229b6eb9f93469eacf3
This commit is contained in:
gho tik 2017-01-15 11:49:23 -05:00 committed by Refael ACkermann
parent ab27610145
commit 9a53a5014c
31 changed files with 628 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Include/dxwnd.h
View File

@ -265,6 +265,9 @@
#define HOOKWING32 0x00002000 // Hook WinG32.dll
#define SEQUENCEDIAT 0x00004000 // IFT has sequential format, DLL entries before and API next
#define D3D8BACK16 0x00008000 // D3D8 emulate 16 bpp backbuffer on a 32 bpp desktop (Win8-10 needed feature)
#define MARKWING32 0x00010000 // Marks (highlights with colored frames) all WinG32 operations
#define DYNAMICZCLEAN 0x00020000 // Performs ZBUFFER cleaning also every time the ZBUFFER is activated
#define MARKGDI32 0x00040000 // Marks (highlights with colored frames) the main GDI32 operations
// logging Tflags DWORD:
#define OUTTRACE 0x00000001 // enables tracing to dxwnd.log in general
@ -280,6 +283,8 @@
#define TRACEHOOKS 0x00000400 // log hook operations
#define OUTD3DTRACE 0x00000800 // traces DxWnd direct3d screen handling
#define OUTDXWINTRACE 0x00001000 // traces DxWnd internal operations
#define OUTWINGTRACE 0x00002000 // traces WinG32 hooked calls
#define OUTOGLTRACE 0x00004000 // traces OpenGL hooked calls
#define ADDRELATIVETIME 0x08000000 // log timestamp is relative to previous line
//#define NOLOGCLOSE 0x10000000 // avoid closing the log file handle ("Riven, during CD changes ...)
#define ADDTIMESTAMP 0x20000000 // add timestamp (GetTickCount) to log file
@ -385,6 +390,8 @@ LRESULT CALLBACK dw_Hider_Message_Handler(HWND, UINT, WPARAM, LPARAM);
#define OutTraceH if(dxw.dwTFlags & TRACEHOOKS) OutTrace
#define OutTraceP OutTrace
#define OutTraceE OutTrace
#define OutTraceWG if(dxw.dwTFlags & OUTWINGTRACE) OutTrace
#define OutTraceOGL if(dxw.dwTFlags & OUTOGLTRACE) OutTrace
#define IsTraceW (dxw.dwTFlags & OUTWINMESSAGES)
//#define IsTraceX (dxw.dwTFlags & OUTPROXYTRACE)
@ -396,6 +403,8 @@ LRESULT CALLBACK dw_Hider_Message_Handler(HWND, UINT, WPARAM, LPARAM);
#define IsTraceH (dxw.dwTFlags & TRACEHOOKS)
#define IsTraceP (TRUE)
#define IsTraceE (TRUE)
#define IsTraceWG (dxw.dwTFlags & OUTWINGTRACE)
#define IsTraceOGL (dxw.dwTFlags & OUTOGLTRACE)
#define IsDebug (dxw.dwTFlags & OUTDEBUG)
#define IsAssertEnabled (dxw.dwTFlags & ASSERTDIALOG)
#define STEP OutTrace("STEP at %s:%d\n", __FILE__, __LINE__)

4
build/dxwnd.dll
View File

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:a5cf1c69e785fd49a000d8d45799f9cc319a62bbade9c8fece0a48fc1860c4c1
size 774656
oid sha256:614dc453abbfbc0659502a136e3cd3b2dbb7e794dc3c964ffd2f53a784c6f429
size 779264

4
build/dxwnd.exe
View File

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:faa2086fcb25e8c4f488ce6c9a216819960a29cc365be1debe325635fef886e8
size 669696
oid sha256:f5c8f132cd8013ecb60b7bd0b0a17727fc0e4ffbc2c17756dcb835897d511427
size 671232

36
build/exports/RHEM.dxw Normal file
View File

@ -0,0 +1,36 @@
[target]
title0=RHEM
path0=F:\RhemE\RhemE\RHEM.noshim.exe
startfolder0=
launchpath0=
module0=
opengllib0=
notes0=
registry0=
ver0=0
monitorid0=-1
coord0=0
flag0=681574434
flagg0=1207959552
flagh0=20
flagi0=205520900
flagj0=4224
flagk0=98304
flagl0=0
flagm0=0
tflag0=0
dflag0=0
posx0=50
posy0=50
sizx0=640
sizy0=480
maxfps0=0
initts0=0
winver0=0
maxres0=0
swapeffect0=0
maxddinterface0=7
slowratio0=2
scanline0=0
initresw0=800
initresh0=600

6
build/exports/Tonic Trouble.dxw
View File

@ -2,7 +2,7 @@
title0=Tonic Trouble
path0=F:\Games\Tonic Trouble\TonicTrouble.exe
startfolder0=
launchpath0=F:\Games\Tonic Trouble\TonicTrouble.exe -cdrom:H
launchpath0=F:\Games\Tonic Trouble\TonicTrouble.exe -cdrom:I
module0=
opengllib0=
notes0=
@ -13,11 +13,11 @@ coord0=0
flag0=673185830
flagg0=1207959552
flagh0=65556
flagi0=138412036
flagi0=138412068
flagj0=4224
flagk0=65536
flagl0=536870912
flagm0=36
flagm0=131108
tflag0=0
dflag0=0
posx0=50

20
build/readme-relnotes.txt
View File

@ -1434,3 +1434,23 @@ fix: crashing condition on "hide desktop background" option - fixes M&MVI crash
fix: mouse loop coordinate fix when main window is not set
fix: eliminated log of dmDeviceName field in ChangeDisplaySettings* calls because the field may be not initialized
fix: NOMOVIES option now stops also SmackW32 movies (making movie length only 1 photogram).
v2.04.05
GUI:
add: preliminary implementation of Dummy/Expert GUI modes
fix: "Explore" command implementation for WinXP
DLL:
add: preliminary implementation of virtual registry tokens to make configuration relocable
fix: capability fix on surface creation. DDSCAPS_TEXTURE is replaced by DDSCAPS_OFFSCREENPLAIN. Fixes "Dominant Species" on certain situations where the surface creatuion returns DDERR_UNSUPPORTED code.
add: preliminary hook for GDI32 RemoveFontResources and EnumFonts
fix: CreateRectRgnIndirect wrapper altered input RECT* coordinates
fix: separated D3D QueryInterface pointers and wrappers, added wrapping for QueryInterface D3D v7
fix: log cleanup
add: "Dynamic ZBUFFER fix" flag (DYNAMICZCLEAN): needed to fix some of "Tonic Trouble" rendering problems.
add: OpenGL dedicated logging
add: WinG32 dedicated logging
fix?: bypass for WM_FONTCHANGE: avoids "Warhammer: Shadow of the Horned Rat" crash when entering battle
add: WinG32 debug highlighting of blitted rects on screen
add: GDI32 debug highlighting of blitted rects on screen
add: hooks for GDI32 GetTextExtentPointA and GetTextExtentPoint32A: needed for proper string rendering on "Warhammer: Shadow of the Horned Rat"
add: hook for GDI32 GdiAlphaBlend, very rare call that appeared in "RHEM" during savegame load.

68
dll/advapi.cpp
View File

@ -56,6 +56,61 @@ static FILE *OpenFakeRegistry();
static char *hKey2String(HKEY);
static LONG myRegOpenKeyEx(HKEY, LPCTSTR, PHKEY);
// int ReplaceVar(pData, lplpData, lpcbData):
// extract the token name from pData beginning up to '}' delimiter
// calculates the value of the token. If the token is unknown, the value is null string.
// if *lplpData, copies the token value string to *lplpData and increments *lplpData
// if lpcbData, increments the key length of the token value length
// returns the length of token label to advance the parsing loop
typedef enum {
LABEL_PATH = 0,
LABEL_WORKDIR,
LABEL_VOID,
LABEL_END
};
static char *sTokenLabels[LABEL_END+1]={
"path}",
"work}",
"}",
NULL
};
static int ReplaceVar(char *pData, LPBYTE *lplpData, LPDWORD lpcbData)
{
int iTokenLength;
int iLabelLength;
int iTokenIndex;
char sTokenValue[MAX_PATH];
// search for a matching token
for(iTokenIndex=0; sTokenLabels[iTokenIndex]; iTokenIndex++){
if(!strncmp(pData, sTokenLabels[iTokenIndex], strlen(sTokenLabels[iTokenIndex]))) break;
}
// set token label length
iLabelLength = strlen(sTokenLabels[iTokenIndex]);
// do replacement
switch(iTokenIndex){
case LABEL_PATH:
case LABEL_WORKDIR:
GetCurrentDirectory(MAX_PATH, sTokenValue);
break;
case LABEL_VOID:
case LABEL_END:
strcpy(sTokenValue, "");
break;
}
// set output vars if not NULL
iTokenLength = strlen(sTokenValue);
OutTrace("REPLACED token=%d val=\"%s\" len=%d\n", iTokenIndex, sTokenValue, iTokenLength);
if(lplpData) {
strcpy((char *)*lplpData, sTokenValue);
*lplpData += iTokenLength;
}
if(lpcbData) *lpcbData += iTokenLength;
// return label length to advance parsing
return iLabelLength;
}
static char *hKey2String(HKEY hKey)
{
char *skey;
@ -280,7 +335,18 @@ static DWORD GetKeyValue(
if(lpType) *lpType=REG_SZ;
pData++;
while(*pData && (*pData != '"')){
if(*pData=='\\') pData++;
if(*pData=='\\') {
pData++;
switch(*pData){
case '{':{
pData++; // skip '{'
pData += ReplaceVar(pData, &lpb, lpcbData);
}
break;
default:
break; // skip first '\'
}
}
if(lpData && lpcbData) if(*lpcbData < cbData) *lpb++=*pData;
pData++;
if(lpcbData) (*lpcbData)++;

6
dll/ddcreates.cpp
View File

@ -714,6 +714,12 @@ static HRESULT BuildGenericEmu(LPDIRECTDRAW lpdd, CreateSurface_Type pCreateSurf
}
res=(*pCreateSurface)(lpdd, &ddsd, lplpdds, pu);
// v2.04.05: error condition found & fixed on certain platforms for "Dominant Species" only (so far).
if ((res == DDERR_UNSUPPORTED) && (ddsd.ddsCaps.dwCaps == (DDSCAPS_SYSTEMMEMORY|DDSCAPS_TEXTURE))){
OutTraceDW("BuildGenericEmu: CreateSurface ERROR res=%x(%s) at %d, TEXTURE->OFFSCREENPLAIN retry\n", res, ExplainDDError(res), __LINE__);
ddsd.ddsCaps.dwCaps = (DDSCAPS_SYSTEMMEMORY|DDSCAPS_OFFSCREENPLAIN);
res=(*pCreateSurface)(lpdd, &ddsd, lplpdds, pu);
}
if ((dxw.dwFlags1 & SWITCHVIDEOMEMORY) && (res!=DD_OK)){
OutTraceDW("BuildGenericEmu: CreateSurface ERROR res=%x(%s) at %d, retry\n", res, ExplainDDError(res), __LINE__);
ddsd.ddsCaps.dwCaps &= ~DDSCAPS_VIDEOMEMORY;

4
dll/dxhook.cpp
View File

@ -152,8 +152,8 @@ static char *Flag8Names[32]={
"FORCEWAIT", "FORCENOWAIT", "FORCEVSYNC", "FORCENOVSYNC",
"VSYNCSCANLINES", "TRIMTEXTUREFORMATS", "NOHALDEVICE", "CLIPLOCK",
"PRETENDVISIBLE", "RAWFORMAT", "WININSULATION", "FIXMOUSEHOOK",
"DDSFORMAT", "HOOKWING32", "SEQUENCEDIAT", "",
"", "", "", "",
"DDSFORMAT", "HOOKWING32", "SEQUENCEDIAT", "D3D8BACK16",
"MARKWING32", "DYNAMICZCLEAN", "", "",
"", "", "", "",
"", "", "", "",
"", "", "", "",

19
dll/dxwcore.cpp
View File

@ -1471,3 +1471,22 @@ void dxwCore::MessagePump()
DispatchMessage(&msg);
}
}
void dxwCore::Mark(HDC hdc, BOOL scale, COLORREF color, int x, int y, int cx, int cy)
{
RECT frame;
HBRUSH brush = CreateSolidBrush(color);
frame.left = x; frame.top = y;
frame.right = x+cx; frame.bottom = y+cy;
if(scale) dxw.MapClient(&frame);
(*pFrameRect)(hdc, &frame, brush);
DeleteObject(brush);
}
void dxwCore::Mark(HDC hdc, BOOL scale, COLORREF color, RECT frame)
{
HBRUSH brush = CreateSolidBrush(color);
if(scale) dxw.MapClient(&frame);
(*pFrameRect)(hdc, &frame, brush);
DeleteObject(brush);
}

2
dll/dxwcore.hpp
View File

@ -146,6 +146,8 @@ public: // methods
void GetMonitorWorkarea(LPRECT, BOOL);
void CalculateWindowPos(HWND, DWORD, DWORD, LPWINDOWPOS);
void MessagePump(void);
void Mark(HDC, BOOL, COLORREF, int, int, int, int);
void Mark(HDC, BOOL, COLORREF, RECT);
public: // simple data variables
int MonitorId;

2
dll/dxwnd.cpp
View File

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

BIN
dll/dxwnd.vs2008.suo
View File

Binary file not shown.

206
dll/gdi32.cpp
View File

@ -47,6 +47,15 @@ COLORREF WINAPI extSetBkColor(HDC, COLORREF);
COLORREF WINAPI extSetTextColor(HDC hdc, COLORREF crColor);
int WINAPI extSetBkMode(HDC, int);
*/
typedef int (WINAPI *EnumFontsA_Type)(HDC, LPCSTR, FONTENUMPROC, LPARAM);
EnumFontsA_Type pEnumFontsA;
int WINAPI extEnumFontsA(HDC, LPCSTR, FONTENUMPROC, LPARAM);
typedef BOOL (WINAPI *GetTextExtentPointA_Type)(HDC, LPCTSTR, int, LPSIZE);
GetTextExtentPointA_Type pGetTextExtentPointA;
BOOL WINAPI extGetTextExtentPointA(HDC, LPCTSTR, int, LPSIZE);
typedef BOOL (WINAPI *GetTextExtentPoint32A_Type)(HDC, LPCTSTR, int, LPSIZE);
GetTextExtentPoint32A_Type pGetTextExtentPoint32A;
BOOL WINAPI extGetTextExtentPoint32A(HDC, LPCTSTR, int, LPSIZE);
static HookEntryEx_Type Hooks[]={
@ -74,6 +83,7 @@ static HookEntryEx_Type Hooks[]={
#ifdef TRACEPALETTE
{HOOK_IAT_CANDIDATE, 0, "ResizePalette", (FARPROC)ResizePalette, (FARPROC *)&pResizePalette, (FARPROC)extResizePalette},
#endif
{HOOK_HOT_CANDIDATE, 0, "EnumFontsA", (FARPROC)EnumFontsA, (FARPROC *)&pEnumFontsA, (FARPROC)extEnumFontsA}, // Titanic
{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
};
@ -150,6 +160,8 @@ static HookEntryEx_Type SyscallHooks[]={
{HOOK_IAT_CANDIDATE, 0, "CreateDCW", (FARPROC)CreateDCW, (FARPROC *)&pGDICreateDCW, (FARPROC)extGDICreateDCW},
{HOOK_IAT_CANDIDATE, 0, "PlayEnhMetaFile", (FARPROC)PlayEnhMetaFile, (FARPROC *)&pPlayEnhMetaFile, (FARPROC)extPlayEnhMetaFile},
{HOOK_IAT_CANDIDATE, 0, "GetTextExtentPointA", (FARPROC)NULL, (FARPROC *)&pGetTextExtentPointA, (FARPROC)extGetTextExtentPointA},
{HOOK_IAT_CANDIDATE, 0, "GetTextExtentPoint32A", (FARPROC)NULL, (FARPROC *)&pGetTextExtentPoint32A, (FARPROC)extGetTextExtentPoint32A},
// CreateDCW .....
{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
@ -192,6 +204,9 @@ static HookEntryEx_Type FontHooks[]={
{HOOK_IAT_CANDIDATE, 0, "CreateScalableFontResourceW", (FARPROC)CreateScalableFontResourceW, (FARPROC *)&pCreateScalableFontResourceW, (FARPROC)extCreateScalableFontResourceW},
{HOOK_IAT_CANDIDATE, 0, "AddFontResourceA", (FARPROC)AddFontResourceA, (FARPROC *)&pAddFontResourceA, (FARPROC)extAddFontResourceA},
{HOOK_IAT_CANDIDATE, 0, "AddFontResourceW", (FARPROC)AddFontResourceW, (FARPROC *)&pAddFontResourceW, (FARPROC)extAddFontResourceW},
// v2.04.05: Used by "Warhammer: Shadow of the Horned Rat"
{HOOK_IAT_CANDIDATE, 0, "RemoveFontResourceA", (FARPROC)RemoveFontResourceA, (FARPROC *)&pRemoveFontResourceA, (FARPROC)extRemoveFontResourceA},
{HOOK_IAT_CANDIDATE, 0, "RemoveFontResourceW", (FARPROC)RemoveFontResourceW, (FARPROC *)&pRemoveFontResourceW, (FARPROC)extRemoveFontResourceW},
{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
};
@ -1022,7 +1037,10 @@ BOOL WINAPI extGDIBitBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nH
if(IsDCLeakageSrc) (*pGDIReleaseDC)(dxw.GethWnd(), hdcSrc);
if(IsDCLeakageDest) (*pGDIReleaseDC)(dxw.GethWnd(), hdcDest);
if(res && IsToScreen) dxw.ShowOverlay(hdcDest);
if(res && IsToScreen) {
dxw.ShowOverlay(hdcDest);
if(dxw.dwFlags8 & MARKGDI32) dxw.Mark(hdcDest, FALSE, RGB(0, 0, 255), nXDest, nYDest, nWidth, nHeight);
}
if(!res) OutTraceE("GDI.BitBlt: ERROR err=%d at %d\n", GetLastError(), __LINE__);
return res;
}
@ -1115,7 +1133,10 @@ BOOL WINAPI extGDIStretchBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, in
if(IsDCLeakageSrc) (*pGDIReleaseDC)(dxw.GethWnd(), hdcSrc);
if(IsDCLeakageDest) (*pGDIReleaseDC)(dxw.GethWnd(), hdcDest);
if(res && IsToScreen) dxw.ShowOverlay(hdcDest);
if(res && IsToScreen) {
dxw.ShowOverlay(hdcDest);
if(dxw.dwFlags8 & MARKGDI32) dxw.Mark(hdcDest, FALSE, RGB(0, 250, 250), nXDest, nYDest, nWidth, nHeight);
}
if(!res) OutTraceE("GDI.StretchBlt: ERROR err=%d at %d\n", GetLastError(), __LINE__);
return res;
}
@ -1177,7 +1198,10 @@ BOOL WINAPI extGDIPatBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nH
}
if(IsDCLeakageDest) (*pGDIReleaseDC)(dxw.GethWnd(), hdcDest);
if(res && IsToScreen) dxw.ShowOverlay(hdcDest);
if(res && IsToScreen) {
dxw.ShowOverlay(hdcDest);
if(dxw.dwFlags8 & MARKGDI32) dxw.Mark(hdcDest, FALSE, RGB(255, 255, 0), nXDest, nYDest, nWidth, nHeight);
}
if(!res) OutTraceE("GDI.PatBlt: ERROR err=%d at %d\n", GetLastError(), __LINE__);
return res;
}
@ -1698,6 +1722,7 @@ int WINAPI extStretchDIBits(HDC hdc, int XDest, int YDest, int nDestWidth, int n
}
ret=(*pStretchDIBits)(hdc, XDest, YDest, nDestWidth, nDestHeight, XSrc, YSrc, nSrcWidth, nSrcHeight, lpBits, lpBitsInfo, iUsage, dwRop);
if(dxw.dwFlags8 & MARKGDI32) dxw.Mark(hdc, FALSE, RGB(255, 0, 255), XDest, YDest, nDestWidth, nDestHeight);
if(!ret || (ret==GDI_ERROR)) OutTraceE("StretchDIBits: ERROR ret=%x err=%d\n", ret, GetLastError());
return ret;
}
@ -1857,6 +1882,7 @@ int WINAPI extSetDIBitsToDevice(HDC hdc, int XDest, int YDest, DWORD dwWidth, DW
OutTraceE("DeleteObject: ERROR err=%d at=%d\n", GetLastError(), __LINE__);
if(!(DeleteDC(hTempDc)))
OutTraceE("DeleteDC: ERROR err=%d at=%d\n", GetLastError(), __LINE__);
if(dxw.dwFlags8 & MARKGDI32) dxw.Mark(hdc, FALSE, RGB(255, 255, 255), XDest, YDest, dwWidth, dwHeight);
return ret;
break;
case GDIMODE_EMULATED:
@ -1868,6 +1894,7 @@ int WINAPI extSetDIBitsToDevice(HDC hdc, int XDest, int YDest, DWORD dwWidth, DW
ret=(*pSetDIBitsToDevice)(hdc, X, Y, dwWidth, dwHeight, XSrc, YSrc, uStartScan, cScanLines, lpvBits, lpbmi, fuColorUse);
bGDIRecursionFlag = FALSE;
if(!ret || (ret==GDI_ERROR)) OutTraceE("SetDIBitsToDevice: ERROR ret=%x err=%d\n", ret, GetLastError());
if(dxw.dwFlags8 & MARKGDI32) dxw.Mark(hdc, FALSE, RGB(255, 255, 255), XDest, YDest, dwWidth, dwHeight);
return ret;
default:
break;
@ -1877,6 +1904,7 @@ int WINAPI extSetDIBitsToDevice(HDC hdc, int XDest, int YDest, DWORD dwWidth, DW
ret=(*pSetDIBitsToDevice)(hdc, XDest, YDest, dwWidth, dwHeight, XSrc, YSrc, uStartScan, cScanLines, lpvBits, lpbmi, fuColorUse);
bGDIRecursionFlag = FALSE;
if(!ret || (ret==GDI_ERROR)) OutTraceE("SetDIBitsToDevice: ERROR ret=%x err=%d\n", ret, GetLastError());
if(dxw.dwFlags8 & MARKGDI32) dxw.Mark(hdc, FALSE, RGB(255, 255, 255), XDest, YDest, dwWidth, dwHeight);
return ret;
}
@ -2105,14 +2133,17 @@ HRGN WINAPI extCreateRectRgn(int nLeftRect, int nTopRect, int nRightRect, int nB
HRGN WINAPI extCreateRectRgnIndirect(const RECT *lprc)
{
HRGN ret;
RECT rc;
OutTraceDW("CreateRectRgnIndirect: rect=(%d,%d)-(%d,%d)\n", lprc->left, lprc->top, lprc->right, lprc->bottom);
// v2.04.05: copy the RECT, do not alter the values!
rc = *lprc;
if (dxw.IsFullScreen()){
dxw.MapClient((RECT *)lprc);
OutTraceDW("CreateRectRgnIndirect: fixed rect=(%d,%d)-(%d,%d)\n", lprc->left, lprc->top, lprc->right, lprc->bottom);
dxw.MapClient(&rc);
OutTraceDW("CreateRectRgnIndirect: fixed rect=(%d,%d)-(%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom);
}
ret=(*pCreateRectRgnIndirect)(lprc);
ret=(*pCreateRectRgnIndirect)(&rc);
if(!ret) OutTraceE("CreateRectRgnIndirect: ERROR ret=%x err=%d\n", ret, GetLastError());
return ret;
}
@ -2463,6 +2494,19 @@ int WINAPI extAddFontResourceA(LPCTSTR lpszFontFile)
return res;
}
int WINAPI extRemoveFontResourceA(LPCTSTR lpszFontFile)
{
BOOL res;
OutTraceDW("RemoveFontResource: FontFile=\"%s\"\n", lpszFontFile);
if(dxw.dwFlags3 & FONTBYPASS) {
OutTraceDW("RemoveFontResource: SUPPRESS FontFile=\"%s\"\n", lpszFontFile);
return TRUE;
}
res=(*pRemoveFontResourceA)(lpszFontFile);
if(!res) OutTraceE("RemoveFontResource: ERROR err=%d at=%d\n", GetLastError(), __LINE__);
return res;
}
int WINAPI extAddFontResourceW(LPCWSTR lpszFontFile)
{
BOOL res;
@ -2476,6 +2520,28 @@ int WINAPI extAddFontResourceW(LPCWSTR lpszFontFile)
return res;
}
int WINAPI extRemoveFontResourceW(LPCWSTR lpszFontFile)
{
BOOL res;
OutTraceDW("RemoveFontResource: FontFile=\"%ls\"\n", lpszFontFile);
if(dxw.dwFlags3 & FONTBYPASS) {
OutTraceDW("RemoveFontResource: SUPPRESS FontFile=\"%ls\"\n", lpszFontFile);
return TRUE;
}
res=(*pRemoveFontResourceW)(lpszFontFile);
if(!res) OutTraceE("RemoveFontResource: ERROR err=%d at=%d\n", GetLastError(), __LINE__);
return res;
}
int WINAPI extEnumFontsA(HDC hdc, LPCSTR lpFaceName, FONTENUMPROC lpFontFunc, LPARAM lParam)
{
int res;
OutTraceDW("EnumFonts: hdc=%x facename=\"%s\" fontfunc=%x lparam=%x\n", hdc, lpFaceName, lpFontFunc, lParam);
res = (*pEnumFontsA)(hdc, lpFaceName, lpFontFunc, lParam);
OutTraceDW("EnumFonts: res=0x%x\n", res);
return res;
}
//BEWARE: SetPixelFormat must be issued on the same hdc used by OpenGL wglCreateContext, otherwise
// a failure err=2000 ERROR INVALID PIXEL FORMAT occurs!!
//
@ -2997,9 +3063,75 @@ BOOL WINAPI extExtFloodFill(HDC hdc, int nXStart, int nYStart, COLORREF crColor,
BOOL WINAPI extGdiAlphaBlend(HDC hdcDest, int xoriginDest, int yoriginDest, int wDest, int hDest, HDC hdcSrc, int xoriginSrc, int yoriginSrc, int wSrc, int hSrc, BLENDFUNCTION ftn)
{
// to be handled the 4 flux cases .....
_Warn("GdiAlphaBlend");
return TRUE;
BOOL ret;
int Flux;
BOOL IsToScreen, IsFromScreen;
BOOL IsDCLeakageSrc = FALSE;
BOOL IsDCLeakageDest = FALSE;
// v2.04.05: call found in Rhem during savegame load
OutTraceDW("GdiAlphaBlend: dest {hdc=%x pos=(%d,%d) size=(%dx%d)} source {hdc=%x pos=(%d,%d) size=(%dx%d)} ftn=%x\n",
hdcDest, xoriginDest, yoriginDest, wDest, hDest, hdcSrc, xoriginSrc, yoriginSrc, wSrc, hSrc, ftn);
if(hdcDest == NULL){
hdcDest = (*pGDIGetDC)(dxw.GethWnd());
OutTraceB("GdiAlphaBlend: DEBUG hdc dest=NULL->%x\n", hdcDest);
IsDCLeakageDest = TRUE;
}
if(hdcSrc == NULL){
hdcSrc = (*pGDIGetDC)(dxw.GethWnd());
OutTraceB("GdiAlphaBlend: DEBUG hdc src=NULL->%x\n", hdcSrc);
IsDCLeakageSrc = TRUE;
}
IsToScreen=(OBJ_DC == (*pGetObjectType)(hdcDest));
IsFromScreen=(OBJ_DC == (*pGetObjectType)(hdcSrc));
Flux = (IsToScreen ? 1 : 0) + (IsFromScreen ? 2 : 0);
if (IsToScreen && (dxw.dwFlags3 & NOGDIBLT)) return TRUE;
//_Warn("GdiAlphaBlend");
switch(dxw.GDIEmulationMode){
case GDIMODE_SHAREDDC:
switch(Flux){
case 0: // memory to memory
ret=(*pGdiAlphaBlend)(hdcSrc, xoriginDest, yoriginDest, wDest, hDest, hdcSrc, xoriginSrc, yoriginSrc, wSrc, hSrc, ftn);
break;
case 1: // memory to screen
case 3: // screen to screen
sdc.GetPrimaryDC(hdcDest);
ret=(*pGdiAlphaBlend)(sdc.GetHdc(), xoriginDest, yoriginDest, wDest, hDest, hdcSrc, xoriginSrc, yoriginSrc, wSrc, hSrc, ftn);
sdc.PutPrimaryDC(hdcDest, TRUE, xoriginDest, yoriginDest, wDest, hDest);
break;
case 2: // screen to memory using virtual screen
sdc.GetPrimaryDC(hdcSrc);
ret=(*pGdiAlphaBlend)(hdcDest, xoriginDest, yoriginDest, wDest, hDest, sdc.GetHdc(), xoriginSrc, yoriginSrc, wSrc, hSrc, ftn);
sdc.PutPrimaryDC(hdcSrc, FALSE, xoriginSrc, yoriginSrc, wSrc, hSrc);
break;
}
break;
case GDIMODE_STRETCHED:
switch(Flux){
case 1: // memory to screen
dxw.MapClient(&xoriginDest, &yoriginDest, &wDest, &hDest);
break;
case 2: // screen to memory
dxw.MapClient(&xoriginSrc, &yoriginSrc, &wSrc, &hSrc);
break;
default:
break;
}
// fallthrough ....
case GDIMODE_EMULATED:
default:
ret=(*pGdiAlphaBlend)(hdcDest, xoriginDest, yoriginDest, wDest, hDest, hdcSrc, xoriginSrc, yoriginSrc, wSrc, hSrc, ftn);
break;
}
if(IsDCLeakageSrc) (*pGDIReleaseDC)(dxw.GethWnd(), hdcSrc);
if(IsDCLeakageDest) (*pGDIReleaseDC)(dxw.GethWnd(), hdcDest);
if(ret && IsToScreen) dxw.ShowOverlay(hdcDest);
if(!ret) OutTraceE("GdiAlphaBlend ERROR: err=%d\n", GetLastError());
return ret;
}
BOOL WINAPI extGdiGradientFill(HDC hdc, PTRIVERTEX pVertex, ULONG nVertex, PVOID pMesh, ULONG nMesh, ULONG ulMode)
@ -3297,12 +3429,66 @@ int WINAPI extSetROP2(HDC hdc, int fnDrawMode)
// N.b. Titanic calls SetTextColor, SetBkColor and SetROP2 in sequence, it might be possible that the
// API to hook for refreshing is another, or even them all!
int ret;
OutTrace("SetROP2: hdc=%x drawmode=%d\n", hdc, fnDrawMode);
OutTraceDW("SetROP2: hdc=%x drawmode=%d\n", hdc, fnDrawMode);
ret = (*pSetROP2)(hdc, fnDrawMode);
(*pInvalidateRect)(WindowFromDC(hdc), NULL, 0);
return ret;
}
// v2.04.05: GetTextExtentPointA hooker for "Warhammer Shadow of the Horned Rat"
BOOL WINAPI extGetTextExtentPointA(HDC hdc, LPCTSTR lpString, int cbString, LPSIZE lpSize)
{
BOOL ret;
OutTraceDW("GetTextExtentPointA: hdc=%x string=\"%s\"(%d)\n", hdc, lpString, cbString);
ret = (*pGetTextExtentPointA)(hdc, lpString, cbString, lpSize);
if(!ret){
OutTraceDW("GetTextExtentPointA ERROR: err=%d\n", GetLastError);
return ret;
}
OutTraceDW("GetTextExtentPointA: size=(%dx%d)\n", lpSize->cx, lpSize->cy);
// beware: size scaling is appropriate only when referred to video DC
switch(dxw.GDIEmulationMode){
case GDIMODE_STRETCHED:
if(dxw.Windowize && dxw.IsToRemap(hdc)){
dxw.UnmapClient((LPRECT)lpSize);
OutTraceDW("GetTextExtentPointA: remapped size=(%dx%d)\n", lpSize->cx, lpSize->cy);
}
break;
default:
break;
}
return ret;
}
// v2.04.05: GetTextExtentPoint32A hooker for "Warhammer Shadow of the Horned Rat"
BOOL WINAPI extGetTextExtentPoint32A(HDC hdc, LPCTSTR lpString, int cbString, LPSIZE lpSize)
{
BOOL ret;
OutTraceDW("GetTextExtentPoint32A: hdc=%x string=\"%s\"(%d)\n", hdc, lpString, cbString);
ret = (*pGetTextExtentPoint32A)(hdc, lpString, cbString, lpSize);
if(!ret){
OutTraceDW("GetTextExtentPoint32A ERROR: err=%d\n", GetLastError);
return ret;
}
OutTraceDW("GetTextExtentPoint32A: size=(%dx%d)\n", lpSize->cx, lpSize->cy);
// beware: size scaling is appropriate only when referred to video DC
switch(dxw.GDIEmulationMode){
case GDIMODE_STRETCHED:
if(dxw.Windowize && dxw.IsToRemap(hdc)){
dxw.UnmapClient((LPRECT)lpSize);
OutTraceDW("GetTextExtentPoint32A: remapped size=(%dx%d)\n", lpSize->cx, lpSize->cy);
}
break;
default:
break;
}
return ret;
}
#if 0
LONG WINAPI extSetBitmapBits(HBITMAP hbmp, DWORD cBytes, VOID *lpBits)
{

327
dll/hd3d7.cpp
View File

@ -106,7 +106,7 @@ 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);
typedef HRESULT (WINAPI *Scene3_Type)(void *); // BeginScene, EndScene
typedef HRESULT (WINAPI *Scene_Type)(void *); // BeginScene, EndScene
typedef HRESULT (WINAPI *SetRenderState3_Type)(void *, D3DRENDERSTATETYPE, DWORD);
typedef HRESULT (WINAPI *GetViewport7_Type)(void *, LPD3DVIEWPORT7);
typedef HRESULT (WINAPI *SetViewport7_Type)(void *, LPD3DVIEWPORT7);
@ -121,7 +121,7 @@ typedef HRESULT (WINAPI *SwapTextureHandles_Type)(void *, LPDIRECT3DTEXTURE, LPD
typedef HRESULT (WINAPI *SwapTextureHandles2_Type)(void *, LPDIRECT3DTEXTURE2, LPDIRECT3DTEXTURE2);
typedef HRESULT (WINAPI *SetTransform_Type)(void *, D3DTRANSFORMSTATETYPE, LPD3DMATRIX);
QueryInterfaceD3_Type pQueryInterfaceD3D = NULL;
QueryInterfaceD3_Type pQueryInterfaceD3D1, pQueryInterfaceD3D2, pQueryInterfaceD3D3, pQueryInterfaceD3D7;
ReleaseD3D_Type pReleaseD3D1, pReleaseD3D2, pReleaseD3D3, pReleaseD3D7;
D3DInitialize_Type pD3DInitialize = NULL;
D3DGetCaps_Type pD3DGetCaps1, pD3DGetCaps2, pD3DGetCaps3;
@ -129,14 +129,14 @@ D3DGetCaps7_Type pD3DGetCaps7;
AddViewport1_Type pAddViewport1 = NULL;
AddViewport2_Type pAddViewport2 = NULL;
AddViewport3_Type pAddViewport3 = NULL;
Scene3_Type pBeginScene1 = NULL;
Scene3_Type pBeginScene2 = NULL;
Scene3_Type pBeginScene3 = NULL;
Scene3_Type pBeginScene7 = NULL;
Scene3_Type pEndScene1 = NULL;
Scene3_Type pEndScene2 = NULL;
Scene3_Type pEndScene3 = NULL;
Scene3_Type pEndScene7 = NULL;
Scene_Type pBeginScene1 = NULL;
Scene_Type pBeginScene2 = NULL;
Scene_Type pBeginScene3 = NULL;
Scene_Type pBeginScene7 = NULL;
Scene_Type pEndScene1 = NULL;
Scene_Type pEndScene2 = NULL;
Scene_Type pEndScene3 = NULL;
Scene_Type pEndScene7 = NULL;
SetRenderState3_Type pSetRenderState2 = NULL;
SetRenderState3_Type pSetRenderState3 = NULL;
SetRenderState3_Type pSetRenderState7 = NULL;
@ -232,9 +232,10 @@ HRESULT WINAPI extSetMaterial(void *, LPD3DMATERIAL);
HRESULT WINAPI extGetMaterial(void *, LPD3DMATERIAL);
#endif
HRESULT WINAPI extQueryInterfaceD3(void *, REFIID, LPVOID *);
HRESULT WINAPI extQueryInterfaceD3D(void *, REFIID, LPVOID *);
HRESULT WINAPI extD3DInitialize(void *, LPDIRECT3D , LPGUID, LPD3DDEVICEDESC);
HRESULT WINAPI extQueryInterfaceD3D1(void *, REFIID, LPVOID *);
HRESULT WINAPI extQueryInterfaceD3D2(void *, REFIID, LPVOID *);
HRESULT WINAPI extQueryInterfaceD3D3(void *, REFIID, LPVOID *);
HRESULT WINAPI extQueryInterfaceD3D7(void *, REFIID, LPVOID *);
ULONG WINAPI extReleaseD3D1(LPDIRECT3DDEVICE);
ULONG WINAPI extReleaseD3D2(LPDIRECT3DDEVICE);
@ -507,7 +508,7 @@ void HookDirect3DDevice(void **lpd3ddev, int d3dversion)
switch(d3dversion){
case 1:
SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D, (void **)&pQueryInterfaceD3D, "QueryInterface(D3D)");
SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D1, (void **)&pQueryInterfaceD3D1, "QueryInterface(D3DD1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 8), extReleaseD3D1, (void **)&pReleaseD3D1, "ReleaseD3D(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 16), extD3DGetCaps1, (void **)&pD3DGetCaps1, "GetCaps(1)");
SetHook((void *)(**(DWORD **)lpd3ddev + 20), extSwapTextureHandles, (void **)&pSwapTextureHandles, "SwapTextureHandles(1)");
@ -521,7 +522,7 @@ void HookDirect3DDevice(void **lpd3ddev, int d3dversion)
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 + 0), extQueryInterfaceD3D2, (void **)&pQueryInterfaceD3D2, "QueryInterface(D3DD2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 8), extReleaseD3D2, (void **)&pReleaseD3D2, "ReleaseD3D(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 12), extD3DGetCaps2, (void **)&pD3DGetCaps2, "GetCaps(2)");
SetHook((void *)(**(DWORD **)lpd3ddev + 16), extSwapTextureHandles, (void **)&pSwapTextureHandles, "SwapTextureHandles(2)");
@ -542,7 +543,7 @@ void HookDirect3DDevice(void **lpd3ddev, int d3dversion)
}
break;
case 3:
SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D, (void **)&pQueryInterfaceD3D, "QueryInterface(D3D)");
SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D3, (void **)&pQueryInterfaceD3D3, "QueryInterface(D3DD3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 8), extReleaseD3D3, (void **)&pReleaseD3D3, "ReleaseD3D(3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 12), extD3DGetCaps3, (void **)&pD3DGetCaps3, "GetCaps(3)");
SetHook((void *)(**(DWORD **)lpd3ddev + 20), extAddViewport3, (void **)&pAddViewport3, "AddViewport(3)");
@ -562,7 +563,7 @@ void HookDirect3DDevice(void **lpd3ddev, int d3dversion)
}
break;
case 7:
//SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D, (void **)&pQueryInterfaceD3D, "QueryInterface(D3D)");
SetHook((void *)(**(DWORD **)lpd3ddev + 0), extQueryInterfaceD3D7, (void **)&pQueryInterfaceD3D7, "QueryInterface(D3DD7)");
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)");
@ -587,7 +588,12 @@ HRESULT WINAPI extDirect3DCreate(UINT SDKVersion, LPDIRECT3D *lplpd3d, LPUNKNOWN
HRESULT res;
UINT d3dversion;
OutTraceD3D("Direct3DCreate: SDKVersion=%x UnkOuter=%x\n", SDKVersion, pUnkOuter);
d3dversion = 1;
if(SDKVersion >= 0x0500) d3dversion = 2;
if(SDKVersion >= 0x0600) d3dversion = 3;
if(SDKVersion >= 0x0700) d3dversion = 7;
OutTraceD3D("Direct3DCreate(D3D%d): SDKVersion=%x UnkOuter=%x\n", d3dversion, SDKVersion, pUnkOuter);
res=(*pDirect3DCreate)(SDKVersion, lplpd3d, pUnkOuter);
if(res) {
@ -595,11 +601,6 @@ HRESULT WINAPI extDirect3DCreate(UINT SDKVersion, LPDIRECT3D *lplpd3d, LPUNKNOWN
return res;
}
d3dversion = 1;
if(SDKVersion >= 0x0500) d3dversion = 2;
if(SDKVersion >= 0x0600) d3dversion = 3;
if(SDKVersion >= 0x0700) d3dversion = 7;
HookDirect3DSession((LPDIRECTDRAW *)lplpd3d, d3dversion);
OutTraceD3D("Direct3DCreate: d3d=%x\n", *lplpd3d);
return res;
@ -608,26 +609,26 @@ HRESULT WINAPI extDirect3DCreate(UINT SDKVersion, LPDIRECT3D *lplpd3d, LPUNKNOWN
HRESULT WINAPI extDirect3DCreateDevice(GUID FAR *lpGUID, LPDIRECT3D lpd3ddevice, LPDIRECTDRAWSURFACE surf, LPDIRECT3D *lplpd3ddevice, LPUNKNOWN pUnkOuter)
{
HRESULT res;
OutTraceD3D("Direct3DCreateDevice: guid=%x d3ddevice=%x dds=%x%s UnkOuter=%x\n",
lpGUID, lpd3ddevice, surf, dxwss.ExplainSurfaceRole(surf), pUnkOuter);
res=(*pDirect3DCreateDevice)(lpGUID, lpd3ddevice, surf, lplpd3ddevice, pUnkOuter);
if(res) OutTraceE("Direct3DCreateDevice ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("Direct3DCreateDevice: d3ddevice=%x\n", *lplpd3ddevice);
int d3dversion = 0;
switch(lpGUID->Data1){
case 0x64108800: // IID_IDirect3DDevice
HookDirect3DDevice((void **)lplpd3ddevice, 1);
break;
d3dversion = 1; break;
case 0x93281501: // IID_IDirect3DDevice2
HookDirect3DDevice((void **)lplpd3ddevice, 2);
break;
d3dversion = 2; break;
case 0xb0ab3b60: // IID_IDirect3DDevice3
HookDirect3DDevice((void **)lplpd3ddevice, 3);
break;
d3dversion = 3; break;
case 0xf5049e79: // IID_IDirect3DDevice7
HookDirect3DDevice((void **)lplpd3ddevice, 7);
break;
d3dversion = 7; break;
}
OutTraceD3D("Direct3DCreateDevice: guid=%x(%s) d3ddevice=%x dds=%x%s UnkOuter=%x\n",
lpGUID, ExplainGUID(lpGUID), lpd3ddevice, surf, dxwss.ExplainSurfaceRole(surf), pUnkOuter);
res=(*pDirect3DCreateDevice)(lpGUID, lpd3ddevice, surf, lplpd3ddevice, pUnkOuter);
if(res) OutTraceE("Direct3DCreateDevice ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else {
OutTraceD3D("Direct3DCreateDevice: d3ddevice=%x\n", *lplpd3ddevice);
if(d3dversion) HookDirect3DDevice((void **)lplpd3ddevice, d3dversion);
}
return res;
}
@ -705,16 +706,12 @@ HRESULT WINAPI extQueryInterfaceD3(int d3dversion, QueryInterfaceD3_Type pQueryI
{
HRESULT res;
OutTraceD3D("QueryInterfaceD3(%d): d3d=%x REFIID=%x obj=%x\n", d3dversion, lpd3d, riid.Data1, ppvObj);
//d3dversion=0;
OutTraceD3D("QueryInterface(D3D%d): d3d=%x REFIID=%x obj=%x\n", d3dversion, lpd3d, riid.Data1, ppvObj);
res=(*pQueryInterfaceD3)(lpd3d, riid, ppvObj);
//switch(riid.Data1){
// case 0x3BBA0080: d3dversion=1; break;
// case 0x6aae1ec1: d3dversion=2; break;
// case 0xbb223240: d3dversion=3; break;
// case 0xf5049e77: d3dversion=7; break;
//}
if(d3dversion) OutTraceD3D("QueryInterface(D3): hooking version=%d\n", d3dversion);
if(res){
OutTraceE("QueryInterface(D3D) ERROR: err=%x(%s)\n", res, ExplainDDError(res));
return res;
}
switch(d3dversion){
case 1:
SetHook((void *)(**(DWORD **)ppvObj + 12), extInitialize, (void **)&pInitialize, "Initialize");
@ -761,20 +758,29 @@ HRESULT WINAPI extQueryInterfaceD33(void *lpd3d, REFIID riid, LPVOID *ppvObj)
HRESULT WINAPI extQueryInterfaceD37(void *lpd3d, REFIID riid, LPVOID *ppvObj)
{ return extQueryInterfaceD3(7, pQueryInterfaceD37, lpd3d, riid, ppvObj); }
HRESULT WINAPI extQueryInterfaceD3D(void *lpd3ddev, REFIID riid, LPVOID *ppvObj)
HRESULT WINAPI extQueryInterfaceD3D(int d3dversion, QueryInterfaceD3D_Type pQueryInterface, void *lpd3ddev, REFIID riid, LPVOID *ppvObj)
{
HRESULT res;
OutTraceD3D("QueryInterface(D3D): d3ddev=%x REFIID=%x obj=%x\n", lpd3ddev, riid.Data1, ppvObj);
res=(*pQueryInterfaceD3D)(lpd3ddev, riid, ppvObj);
OutTraceD3D("QueryInterface(D3DD%d): d3ddev=%x REFIID=%x obj=%x\n", d3dversion, lpd3ddev, riid.Data1, ppvObj);
res=(*pQueryInterface)(lpd3ddev, riid, ppvObj);
return res;
}
HRESULT WINAPI extQueryInterfaceD3D1(void *lpd3ddev, REFIID riid, LPVOID *ppvObj)
{ return extQueryInterfaceD3D(1, pQueryInterfaceD3D1, lpd3ddev, riid, ppvObj); }
HRESULT WINAPI extQueryInterfaceD3D2(void *lpd3ddev, REFIID riid, LPVOID *ppvObj)
{ return extQueryInterfaceD3D(2, pQueryInterfaceD3D2, lpd3ddev, riid, ppvObj); }
HRESULT WINAPI extQueryInterfaceD3D3(void *lpd3ddev, REFIID riid, LPVOID *ppvObj)
{ return extQueryInterfaceD3D(3, pQueryInterfaceD3D3, lpd3ddev, riid, ppvObj); }
HRESULT WINAPI extQueryInterfaceD3D7(void *lpd3ddev, REFIID riid, LPVOID *ppvObj)
{ return extQueryInterfaceD3D(7, pQueryInterfaceD3D7, lpd3ddev, riid, ppvObj); }
ULONG WINAPI extReleaseD3D(int d3dversion, ReleaseD3D_Type pReleaseD3D, LPDIRECT3DDEVICE lpd3dd)
{
ULONG ref;
OutTraceD3D("Release(D3D%d): d3ddev=%x \n", d3dversion, lpd3dd);
OutTraceD3D("Release(D3DD%d): d3ddev=%x \n", d3dversion, lpd3dd);
ref = (*pReleaseD3D)(lpd3dd);
OutTraceD3D("Release(D3D%d): ref=%d\n", ref);
OutTraceD3D("Release(D3DD): ref=%d\n", ref);
return ref;
}
@ -791,7 +797,8 @@ HRESULT WINAPI extInitialize(void *lpd3d)
{
HRESULT res;
OutTraceD3D("Initialize: d3d=%x\n", lpd3d);
// the Initialize method is present in D3D interface version 1 only...
OutTraceD3D("Initialize(D3D1): d3d=%x\n", lpd3d);
res=(*pInitialize)(lpd3d);
if(res) OutTraceE("Initialize ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("Initialize: OK\n");
@ -912,12 +919,12 @@ HRESULT WINAPI extDeviceProxy7(LPSTR lpDeviceDescription, LPSTR lpDeviceName, LP
return res;
}
HRESULT WINAPI extEnumDevices(int version, EnumDevices_Type pEnumDevices, void *lpd3d, LPD3DENUMDEVICESCALLBACK cb, LPVOID arg)
HRESULT WINAPI extEnumDevices(int d3dversion, EnumDevices_Type pEnumDevices, void *lpd3d, LPD3DENUMDEVICESCALLBACK cb, LPVOID arg)
{
HRESULT res;
CallbackArg Arg;
OutTraceD3D("EnumDevices(%d): d3d=%x arg=%x\n", version, lpd3d, arg);
OutTraceD3D("EnumDevices(D#D%d): d3d=%x arg=%x\n", d3dversion, lpd3d, arg);
Arg.cb= &cb;
Arg.arg=arg;
res=(*pEnumDevices)(lpd3d, (LPD3DENUMDEVICESCALLBACK)extDeviceProxy, (LPVOID)&Arg);
@ -933,13 +940,12 @@ HRESULT WINAPI extEnumDevices2(void *lpd3d, LPD3DENUMDEVICESCALLBACK cb, LPVOID
HRESULT WINAPI extEnumDevices3(void *lpd3d, LPD3DENUMDEVICESCALLBACK cb, LPVOID arg)
{ return extEnumDevices(3, pEnumDevices3, lpd3d, cb, arg); }
HRESULT WINAPI extEnumDevices7(void *lpd3d, LPD3DENUMDEVICESCALLBACK7 cb, LPVOID arg)
{
HRESULT res;
CallbackArg7 Arg;
OutTraceD3D("EnumDevices(7): d3d=%x arg=%x\n", lpd3d, arg);
OutTraceD3D("EnumDevices(D3D7): d3d=%x arg=%x\n", lpd3d, arg);
Arg.cb= &cb;
Arg.arg=arg;
res=(*pEnumDevices7)(lpd3d, (LPD3DENUMDEVICESCALLBACK7)extDeviceProxy7, (LPVOID)&Arg);
@ -948,11 +954,11 @@ HRESULT WINAPI extEnumDevices7(void *lpd3d, LPD3DENUMDEVICESCALLBACK7 cb, LPVOID
return res;
}
HRESULT WINAPI extCreateLight(CreateLight_Type pCreateLight, void *lpd3d, LPDIRECT3DLIGHT *lpLight, IUnknown *p0)
HRESULT WINAPI extCreateLight(int d3dversion, CreateLight_Type pCreateLight, void *lpd3d, LPDIRECT3DLIGHT *lpLight, IUnknown *p0)
{
HRESULT res;
OutTraceD3D("CreateLight: d3d=%x\n", lpd3d);
OutTraceD3D("CreateLight(D3D%d): d3d=%x\n", d3dversion, lpd3d);
res=(*pCreateLight)(lpd3d, lpLight, p0);
if(res) OutTraceE("CreateLight ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("CreateLight: OK\n");
@ -960,18 +966,18 @@ HRESULT WINAPI extCreateLight(CreateLight_Type pCreateLight, void *lpd3d, LPDIRE
}
HRESULT WINAPI extCreateLight1(void *lpd3d, LPDIRECT3DLIGHT *lpLight, IUnknown *p0)
{ return extCreateLight(pCreateLight1, lpd3d, lpLight, p0); }
{ return extCreateLight(1, pCreateLight1, lpd3d, lpLight, p0); }
HRESULT WINAPI extCreateLight2(void *lpd3d, LPDIRECT3DLIGHT *lpLight, IUnknown *p0)
{ return extCreateLight(pCreateLight2, lpd3d, lpLight, p0); }
{ return extCreateLight(2, pCreateLight2, lpd3d, lpLight, p0); }
HRESULT WINAPI extCreateLight3(void *lpd3d, LPDIRECT3DLIGHT *lpLight, IUnknown *p0)
{ return extCreateLight(pCreateLight3, lpd3d, lpLight, p0); }
{ return extCreateLight(3, pCreateLight3, lpd3d, lpLight, p0); }
#ifdef TRACEMATERIAL
HRESULT WINAPI extCreateMaterial1(void *lpd3d, LPDIRECT3DMATERIAL *lpMaterial, IUnknown *p0)
{
HRESULT res;
OutTraceD3D("CreateMaterial(1): d3d=%x\n", lpd3d);
OutTraceD3D("CreateMaterial(D3D1): d3d=%x\n", lpd3d);
res=(*pCreateMaterial1)(lpd3d, lpMaterial, p0);
if(res) OutTraceE("CreateMaterial ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("CreateMaterial: OK\n");
@ -983,7 +989,7 @@ HRESULT WINAPI extCreateMaterial2(void *lpd3d, LPDIRECT3DMATERIAL2 *lpMaterial,
{
HRESULT res;
OutTraceD3D("CreateMaterial(2): d3d=%x\n", lpd3d);
OutTraceD3D("CreateMaterial(D3D2): d3d=%x\n", lpd3d);
res=(*pCreateMaterial2)(lpd3d, lpMaterial, p0);
if(res) OutTraceE("CreateMaterial ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("CreateMaterial: OK\n");
@ -995,7 +1001,7 @@ HRESULT WINAPI extCreateMaterial3(void *lpd3d, LPDIRECT3DMATERIAL3 *lpMaterial,
{
HRESULT res;
OutTraceD3D("CreateMaterial(1): d3d=%x\n", lpd3d);
OutTraceD3D("CreateMaterial(D3D3): d3d=%x\n", lpd3d);
res=(*pCreateMaterial3)(lpd3d, lpMaterial, p0);
if(res) OutTraceE("CreateMaterial ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("CreateMaterial: OK\n");
@ -1008,7 +1014,7 @@ HRESULT WINAPI extCreateViewport1(void *lpd3d, LPDIRECT3DVIEWPORT *lpViewport, I
{
HRESULT res;
OutTraceD3D("CreateViewport(1): d3d=%x\n", lpd3d);
OutTraceD3D("CreateViewport(D3D1): d3d=%x\n", lpd3d);
res=(*pCreateViewport1)(lpd3d, lpViewport, p0);
if(res) OutTraceE("CreateViewport ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("CreateViewport: Viewport=%x\n", *lpViewport);
@ -1020,10 +1026,10 @@ HRESULT WINAPI extCreateViewport2(void *lpd3d, LPDIRECT3DVIEWPORT2 *lpViewport,
{
HRESULT res;
OutTraceD3D("CreateViewport(2): d3d=%x\n", lpd3d);
OutTraceD3D("CreateViewport(D3D2): d3d=%x\n", lpd3d);
res=(*pCreateViewport2)(lpd3d, lpViewport, p0);
if(res) OutTraceE("CreateViewport(2) ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("CreateViewport(2): Viewport=%x\n", *lpViewport);
if(res) OutTraceE("CreateViewport ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("CreateViewport: Viewport=%x\n", *lpViewport);
HookViewport((LPDIRECT3DVIEWPORT *)lpViewport, 2);
return res;
}
@ -1032,10 +1038,10 @@ HRESULT WINAPI extCreateViewport3(void *lpd3d, LPDIRECT3DVIEWPORT3 *lpViewport,
{
HRESULT res;
OutTraceD3D("CreateViewport(3): d3d=%x\n", lpd3d);
OutTraceD3D("CreateViewport(D3D3): d3d=%x\n", lpd3d);
res=(*pCreateViewport3)(lpd3d, lpViewport, p0);
if(res) OutTraceE("CreateViewport(3) ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("CreateViewport(3): Viewport=%x\n", *lpViewport);
if(res) OutTraceE("CreateViewport ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD3D("CreateViewport: Viewport=%x\n", *lpViewport);
HookViewport((LPDIRECT3DVIEWPORT *)lpViewport, 3);
if(IsDebug){
HRESULT res2;
@ -1043,9 +1049,9 @@ HRESULT WINAPI extCreateViewport3(void *lpd3d, LPDIRECT3DVIEWPORT3 *lpViewport,
vpdesc.dwSize = sizeof(D3DVIEWPORT2);
res2=(*pGetViewport2_3)(*lpViewport, &vpdesc);
if(res)
OutTraceE("CreateViewport(3) ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
OutTraceE("CreateViewport ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else
OutTraceD3D("CreateViewport(3): size=%d pos=(%d,%d) dim=(%dx%d)\n",
OutTraceD3D("CreateViewport: size=%d pos=(%d,%d) dim=(%dx%d)\n",
vpdesc.dwSize, vpdesc.dwX, vpdesc.dwY, vpdesc.dwWidth, vpdesc.dwHeight);
}
return res;
@ -1055,7 +1061,7 @@ static HRESULT WINAPI extFindDevice(int d3dversion, FindDevice_Type pFindDevice,
{
HRESULT res;
OutTraceD3D("FindDevice(%d): d3d=%x devsearch=%x (size=%d flags=%x caps=%x primcaps=%x colormodel=%x hw=%x guid=%x) p2=%x\n",
OutTraceD3D("FindDevice(D3D%d): d3d=%x devsearch=%x (size=%d flags=%x caps=%x primcaps=%x colormodel=%x hw=%x guid=%x) p2=%x\n",
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__);
@ -1078,7 +1084,7 @@ HRESULT WINAPI extSetViewport(int dxversion, SetViewport_Type pSetViewport, void
{
HRESULT res;
OutTraceD3D("SetViewport(%d): viewport=%x viewportd=%x size=%d pos=(%d,%d) dim=(%dx%d) scale=(%fx%f) maxXYZ=(%f,%f,%f) minZ=%f\n",
OutTraceD3D("SetViewport(D3D%d): viewport=%x viewportd=%x size=%d pos=(%d,%d) dim=(%dx%d) scale=(%fx%f) maxXYZ=(%f,%f,%f) minZ=%f\n",
dxversion, lpvp, vpd, vpd->dwSize, vpd->dwX, vpd->dwY, vpd->dwWidth, vpd->dwHeight, vpd->dvScaleX, vpd->dvScaleY,
vpd->dvMaxX, vpd->dvMaxY, vpd->dvMaxZ, vpd->dvMinZ);
@ -1100,11 +1106,11 @@ HRESULT WINAPI extSetViewport2(void *lpvp, LPD3DVIEWPORT vpd)
HRESULT WINAPI extSetViewport3(void *lpvp, LPD3DVIEWPORT vpd)
{ return extSetViewport(3, pSetViewport3, lpvp, vpd); }
HRESULT WINAPI extGetViewport(int dxversion, GetViewport_Type pGetViewport, void *lpvp, LPD3DVIEWPORT vpd)
HRESULT WINAPI extGetViewport(int d3dversion, GetViewport_Type pGetViewport, void *lpvp, LPD3DVIEWPORT vpd)
{
HRESULT res;
OutTraceD3D("GetViewport(%d): viewport=%x viewportd=%x\n", dxversion, lpvp, vpd);
OutTraceD3D("GetViewport(D3D%d): viewport=%x viewportd=%x\n", d3dversion, lpvp, vpd);
res=(*pGetViewport)(lpvp, vpd);
// v2.03.48: should the dvScaleX/Y fields be unscaled?
if(res) OutTraceE("GetViewport ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
@ -1137,7 +1143,6 @@ HRESULT WINAPI extInitializeVP(void *lpvp, LPDIRECT3D lpd3d)
#define D3DERR_NOTAVAILABLE MAKE_HRESULT(1, _FACD3D, 2154)
#endif
HRESULT WINAPI extCreateDevice2(void *lpd3d, REFCLSID Guid, LPDIRECTDRAWSURFACE lpdds, LPDIRECT3DDEVICE2 *lplpd3dd)
{
HRESULT res;
@ -1208,20 +1213,10 @@ HRESULT WINAPI extCreateDevice7(void *lpd3d, REFCLSID Guid, LPDIRECTDRAWSURFACE7
return res;
}
HRESULT WINAPI extD3DInitialize(void *d3dd, LPDIRECT3D lpd3d, LPGUID lpGuid, LPD3DDEVICEDESC lpd3dd)
HRESULT WINAPI extSetRenderState(int version, SetRenderState3_Type pSetRenderState, void *d3dd, D3DRENDERSTATETYPE State, DWORD Value)
{
HRESULT res;
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__);
DumpD3DDeviceDesc(lpd3dd, "INIT");
return res;
}
HRESULT WINAPI extSetRenderState(SetRenderState3_Type pSetRenderState, int version, void *d3dd, D3DRENDERSTATETYPE State, DWORD Value)
{
HRESULT res;
OutTraceB("SetRenderState(%d): d3dd=%x State=%x(%s) Value=%x\n", version, d3dd, State, ExplainD3DRenderState(State), Value);
OutTraceB("SetRenderState(D3D%d): d3dd=%x State=%x(%s) Value=%x\n", version, d3dd, State, ExplainD3DRenderState(State), Value);
if((dxw.dwFlags4 & ZBUFFERALWAYS) && (State == D3DRENDERSTATE_ZFUNC)) {
OutTraceD3D("SetRenderState: FIXED State=ZFUNC Value=%s->D3DCMP_ALWAYS\n", ExplainRenderstateValue(Value));
@ -1236,17 +1231,40 @@ HRESULT WINAPI extSetRenderState(SetRenderState3_Type pSetRenderState, int versi
Value = FALSE;
}
// beware!!! likely this code would work for interface version 3 only !!!
if((State==D3DRENDERSTATE_ZWRITEENABLE) && (Value==TRUE) && (dxw.dwFlags8 & DYNAMICZCLEAN)){
//if((State==D3DRENDERSTATE_ZWRITEENABLE) && (Value==FALSE) && (dxw.dwFlags8 & DYNAMICZCLEAN)){
//if((State==D3DRENDERSTATE_ZWRITEENABLE) && (dxw.dwFlags8 & DYNAMICZCLEAN)){
HRESULT res2;
LPDIRECT3DVIEWPORT3 vp;
D3DVIEWPORT vpd;
res2=((LPDIRECT3DDEVICE3)d3dd)->GetCurrentViewport(&vp);
if(!res2){
D3DRECT d3dRect;
vpd.dwSize=sizeof(D3DVIEWPORT);
vp->GetViewport(&vpd);
d3dRect.x1 = vpd.dwX;
d3dRect.y1 = vpd.dwY;
d3dRect.x2 = vpd.dwX + vpd.dwWidth;
d3dRect.y2 = vpd.dwY + vpd.dwHeight;
OutTraceD3D("d3dRect=(%d,%d)-(%d,%d)\n", d3dRect.x1, d3dRect.y1, d3dRect.x2, d3dRect.y2);
if(dxw.dwFlags4 & ZBUFFERCLEAN )vp->Clear2(1, &d3dRect, D3DCLEAR_ZBUFFER, 0, 1.0, 0);
if(dxw.dwFlags4 & ZBUFFER0CLEAN)vp->Clear2(1, &d3dRect, D3DCLEAR_ZBUFFER, 0, 0.0, 0);
if(dxw.dwFlags5 & CLEARTARGET) vp->Clear(1, &d3dRect, D3DCLEAR_TARGET);
}
}
res=(*pSetRenderState)(d3dd, State, Value);
if(res) OutTraceE("SetRenderState: res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
HRESULT WINAPI extSetRenderState2(void *d3dd, D3DRENDERSTATETYPE State, DWORD Value)
{ return extSetRenderState(pSetRenderState2, 2, d3dd, State, Value); }
{ return extSetRenderState(2, pSetRenderState2, d3dd, State, Value); }
HRESULT WINAPI extSetRenderState3(void *d3dd, D3DRENDERSTATETYPE State, DWORD Value)
{ return extSetRenderState(pSetRenderState3, 3, d3dd, State, Value); }
{ return extSetRenderState(3, pSetRenderState3, d3dd, State, Value); }
HRESULT WINAPI extSetRenderState7(void *d3dd, D3DRENDERSTATETYPE State, DWORD Value)
{ return extSetRenderState(pSetRenderState7, 7, d3dd, State, Value); }
{ return extSetRenderState(7, pSetRenderState7, d3dd, State, Value); }
static HRESULT WINAPI dxwRestoreCallback(LPDIRECTDRAWSURFACE lpDDSurface, LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext)
{
@ -1265,14 +1283,14 @@ static HRESULT WINAPI dxwRestoreCallback(LPDIRECTDRAWSURFACE lpDDSurface, LPDDSU
HRESULT WINAPI extBeginScene1(void *d3dd)
{
HRESULT res;
OutTraceD3D("BeginScene(1): d3dd=%x\n", d3dd);
OutTraceD3D("BeginScene(D3D1): d3dd=%x\n", d3dd);
res=(*pBeginScene1)(d3dd);
if(res == DDERR_SURFACELOST){
OutTraceDW("BeginScene: recovering from DDERR_SURFACELOST\n");
lpPrimaryDD->EnumSurfaces(DDENUMSURFACES_DOESEXIST|DDENUMSURFACES_ALL, NULL, NULL, (LPDDENUMSURFACESCALLBACK)dxwRestoreCallback);
res=(*pBeginScene1)(d3dd);
}
if(res) OutTraceE("BeginScene(1): res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTraceE("BeginScene: res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
@ -1293,7 +1311,7 @@ static HRESULT WINAPI dxwRestoreCallback2(LPDIRECTDRAWSURFACE4 lpDDSurface, LPDD
HRESULT WINAPI extBeginScene2(void *d3dd)
{
HRESULT res;
OutTraceD3D("BeginScene(2): d3dd=%x\n", d3dd);
OutTraceD3D("BeginScene(D3D2): d3dd=%x\n", d3dd);
if((dxw.dwFlags4 & (ZBUFFERCLEAN|ZBUFFER0CLEAN)) || (dxw.dwFlags5 & CLEARTARGET)){
HRESULT res2;
LPDIRECT3DVIEWPORT2 vp;
@ -1318,14 +1336,14 @@ HRESULT WINAPI extBeginScene2(void *d3dd)
lpPrimaryDD->EnumSurfaces(DDENUMSURFACES_DOESEXIST|DDENUMSURFACES_ALL, NULL, NULL, (LPDDENUMSURFACESCALLBACK)dxwRestoreCallback2);
res=(*pBeginScene2)(d3dd);
}
if(res) OutTraceE("BeginScene(2): res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTraceE("BeginScene: res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
HRESULT WINAPI extBeginScene3(void *d3dd)
{
HRESULT res;
OutTraceD3D("BeginScene(3): d3dd=%x\n", d3dd);
OutTraceD3D("BeginScene(D3D3): d3dd=%x\n", d3dd);
if((dxw.dwFlags4 & (ZBUFFERCLEAN|ZBUFFER0CLEAN)) || (dxw.dwFlags5 & CLEARTARGET)){
HRESULT res2;
LPDIRECT3DVIEWPORT3 vp;
@ -1351,7 +1369,7 @@ HRESULT WINAPI extBeginScene3(void *d3dd)
lpPrimaryDD->EnumSurfaces(DDENUMSURFACES_DOESEXIST|DDENUMSURFACES_ALL, NULL, NULL, (LPDDENUMSURFACESCALLBACK)dxwRestoreCallback2);
res=(*pBeginScene3)(d3dd);
}
if(res) OutTraceE("BeginScene(3): res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTraceE("BeginScene: res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
@ -1372,7 +1390,7 @@ static HRESULT WINAPI dxwRestoreCallback7(LPDIRECTDRAWSURFACE7 lpDDSurface, LPDD
HRESULT WINAPI extBeginScene7(void *d3dd)
{
HRESULT res;
OutTraceD3D("BeginScene(7): d3dd=%x\n", d3dd);
OutTraceD3D("BeginScene(D3D7): d3dd=%x\n", d3dd);
// there is no Clear method for Viewport object in D3D7 !!!
@ -1382,49 +1400,28 @@ HRESULT WINAPI extBeginScene7(void *d3dd)
lpPrimaryDD->EnumSurfaces(DDENUMSURFACES_DOESEXIST|DDENUMSURFACES_ALL, NULL, NULL, (LPDDENUMSURFACESCALLBACK)dxwRestoreCallback7);
res=(*pBeginScene7)(d3dd);
}
if(res) OutTraceE("BeginScene(7): res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTraceE("BeginScene: res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
static HRESULT WINAPI extEndScene(int d3dversion, Scene_Type pEndScene, void *d3dd)
{
HRESULT res;
OutTraceD3D("EndScene(D3D%d): d3dd=%x\n", d3dversion, d3dd);
res=(*pEndScene)(d3dd);
//dxw.ShowOverlay();
if(res) OutTraceE("EndScene: res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
HRESULT WINAPI extEndScene1(void *d3dd)
{
HRESULT res;
OutTraceD3D("EndScene(1): d3dd=%x\n", d3dd);
res=(*pEndScene1)(d3dd);
//dxw.ShowOverlay();
if(res) OutTraceE("EndScene(1): res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
{ return extEndScene(1, pEndScene1, d3dd); }
HRESULT WINAPI extEndScene2(void *d3dd)
{
HRESULT res;
OutTraceD3D("EndScene(2): d3dd=%x\n", d3dd);
res=(*pEndScene2)(d3dd);
//dxw.ShowOverlay();
if(res) OutTraceE("EndScene(2): res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
{ return extEndScene(2, pEndScene2, d3dd); }
HRESULT WINAPI extEndScene3(void *d3dd)
{
HRESULT res;
OutTraceD3D("EndScene(3): d3dd=%x\n", d3dd);
res=(*pEndScene3)(d3dd);
//dxw.ShowOverlay();
if(res) OutTraceE("EndScene(3): res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
{ return extEndScene(3, pEndScene3, d3dd); }
HRESULT WINAPI extEndScene7(void *d3dd)
{
HRESULT res;
OutTraceD3D("EndScene(7): d3dd=%x\n", d3dd);
res=(*pEndScene7)(d3dd);
//dxw.ShowOverlay();
if(res) OutTraceE("EndScene(7): res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
{ return extEndScene(7, pEndScene7, d3dd); }
HRESULT WINAPI extD3DGetCaps(int d3dversion, D3DGetCaps_Type pD3DGetCaps, void *d3dd, LPD3DDEVICEDESC hd, LPD3DDEVICEDESC sd)
{
@ -1486,27 +1483,27 @@ HRESULT WINAPI extD3DGetCaps7(void *d3dd, LPD3DDEVICEDESC7 lpd3ddd)
HRESULT WINAPI extSetLightState3(void *d3dd, D3DLIGHTSTATETYPE d3dls, DWORD t)
{
HRESULT res;
OutTraceD3D("SetLightState(3): d3d=%x lightstate=%x t=%x\n", d3dd, d3dls, t);
OutTraceD3D("SetLightState(D3D3): d3d=%x lightstate=%x t=%x\n", d3dd, d3dls, t);
res=(*pSetLightState3)(d3dd, d3dls, t);
if(res) OutTraceE("SetLightState(3): ERROR res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTraceE("SetLightState: ERROR res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
HRESULT WINAPI extSetViewport7(void *d3dd, LPD3DVIEWPORT7 lpd3dvp)
{
HRESULT res;
OutTraceD3D("SetViewport(7): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
OutTraceD3D("SetViewport(D3D7): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
res=(*pSetViewport7)(d3dd, lpd3dvp);
if(res) OutTraceE("SetViewport(7): ERROR res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTraceE("SetViewport: ERROR res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
HRESULT WINAPI extGetViewport7(void *d3dd, LPD3DVIEWPORT7 lpd3dvp)
{
HRESULT res;
OutTraceD3D("GetViewport(7): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
OutTraceD3D("GetViewport(D3D7): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
res=(*pGetViewport7)(d3dd, lpd3dvp);
if(res) OutTraceE("GetViewport(7): ERROR res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTraceE("GetViewport: ERROR res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
@ -1514,17 +1511,17 @@ HRESULT WINAPI extAddViewport1(void *d3dd, LPDIRECT3DVIEWPORT lpd3dvp)
{
HRESULT res;
static VOID *LastDevice = 0;
OutTraceD3D("AddViewport(1): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
OutTraceD3D("AddViewport(D3D1): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
res=(*pAddViewport1)(d3dd, lpd3dvp);
if((res == DDERR_INVALIDPARAMS) && LastDevice) {
// going through here fixes "Die hard trilogy" "DirectX error 15" caused by an AddViewport failure
OutTraceE("AddViewport(1) DDERR_INVALIDPARAMS; try to unlink from d3dd=%x\n", LastDevice);
OutTraceE("AddViewport DDERR_INVALIDPARAMS: try to unlink from d3dd=%x\n", LastDevice);
res=((LPDIRECT3DDEVICE)LastDevice)->DeleteViewport(lpd3dvp);
if(res) OutTrace("DeleteViewport(1): ERROR res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTrace("DeleteViewport: ERROR res=%x(%s)\n", res, ExplainDDError(res));
res=(*pAddViewport1)(d3dd, lpd3dvp);
}
if(res){
OutTraceE("AddViewport(1): ERROR res=%x(%s)\n", res, ExplainDDError(res));
OutTraceE("AddViewport: ERROR res=%x(%s)\n", res, ExplainDDError(res));
if(dxw.dwFlags1 & SUPPRESSDXERRORS) res=DD_OK;
}
else
@ -1536,16 +1533,16 @@ HRESULT WINAPI extAddViewport2(void *d3dd, LPDIRECT3DVIEWPORT2 lpd3dvp)
{
HRESULT res;
static VOID *LastDevice = 0;
OutTraceD3D("AddViewport(2): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
OutTraceD3D("AddViewport(D3D2): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
res=(*pAddViewport2)(d3dd, lpd3dvp);
if((res == DDERR_INVALIDPARAMS) && LastDevice) {
OutTraceE("AddViewport(2) DDERR_INVALIDPARAMS; try to unlink from d3dd=%x\n", LastDevice);
OutTraceE("AddViewport DDERR_INVALIDPARAMS: try to unlink from d3dd=%x\n", LastDevice);
res=((LPDIRECT3DDEVICE2)LastDevice)->DeleteViewport(lpd3dvp);
if(res) OutTrace("DeleteViewport(2): ERROR res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTrace("DeleteViewport: ERROR res=%x(%s)\n", res, ExplainDDError(res));
res=(*pAddViewport2)(d3dd, lpd3dvp);
}
if(res) {
OutTraceE("AddViewport(2): ERROR res=%x(%s)\n", res, ExplainDDError(res));
OutTraceE("AddViewport ERROR: res=%x(%s)\n", res, ExplainDDError(res));
if(dxw.dwFlags1 & SUPPRESSDXERRORS) res=DD_OK;
}
else
@ -1557,16 +1554,16 @@ HRESULT WINAPI extAddViewport3(void *d3dd, LPDIRECT3DVIEWPORT3 lpd3dvp)
{
HRESULT res;
static VOID *LastDevice = 0;
OutTraceD3D("AddViewport(3): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
OutTraceD3D("AddViewport(D3D3): d3d=%x d3dvp=%x\n", d3dd, lpd3dvp);
res=(*pAddViewport3)(d3dd, lpd3dvp);
if((res == DDERR_INVALIDPARAMS) && LastDevice) {
OutTraceE("AddViewport(3) DDERR_INVALIDPARAMS; try to unlink from d3dd=%x\n", LastDevice);
OutTraceE("AddViewport DDERR_INVALIDPARAMS: try to unlink from d3dd=%x\n", LastDevice);
res=((LPDIRECT3DDEVICE3)LastDevice)->DeleteViewport(lpd3dvp);
if(res) OutTrace("DeleteViewport(3): ERROR res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTrace("DeleteViewport ERROR: res=%x(%s)\n", res, ExplainDDError(res));
res=(*pAddViewport3)(d3dd, lpd3dvp);
}
if(res) {
OutTraceE("AddViewport(3): ERROR res=%x(%s)\n", res, ExplainDDError(res));
OutTraceE("AddViewport ERROR: res=%x(%s)\n", res, ExplainDDError(res));
if(dxw.dwFlags1 & SUPPRESSDXERRORS) res=DD_OK;
}
else
@ -1735,22 +1732,22 @@ HRESULT WINAPI extNextViewport2(void *d3dd, LPDIRECT3DVIEWPORT2 lpd3dvp, LPDIREC
HRESULT WINAPI extSetTexture3(void *d3dd, DWORD flags, LPDIRECT3DTEXTURE2 lptex)
{
HRESULT res;
OutTraceD3D("SetTexture(3): d3dd=%x flags=%x tex=%x\n", d3dd, flags, lptex);
OutTraceD3D("SetTexture(D3D3): d3dd=%x flags=%x tex=%x\n", d3dd, flags, lptex);
if (dxw.dwFlags4 & NOTEXTURES) return DD_OK;
res=(*pSetTexture3)(d3dd, flags, lptex);
if(res) OutTraceD3D("SetTexture(3): ERROR res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTraceD3D("SetTexture: ERROR res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
HRESULT WINAPI extSetTexture7(void *d3dd, DWORD flags, LPDIRECTDRAWSURFACE7 lptex)
{
HRESULT res;
OutTraceD3D("SetTexture(7): d3dd=%x, flags=%x, tex=%x\n", d3dd, flags, lptex);
OutTraceD3D("SetTexture(D3D7): d3dd=%x, flags=%x, tex=%x\n", d3dd, flags, lptex);
if (dxw.dwFlags4 & NOTEXTURES) return DD_OK;
res=(*pSetTexture7)(d3dd, flags, lptex);
if(res) OutTraceD3D("SetTexture(7): ERROR res=%x(%s)\n", res, ExplainDDError(res));
if(res) OutTraceD3D("SetTexture: ERROR res=%x(%s)\n", res, ExplainDDError(res));
return res;
}
@ -1799,11 +1796,11 @@ HRESULT WINAPI extSwapTextureHandles(void *d3dd, LPDIRECT3DTEXTURE t1, LPDIRECT3
{
HRESULT res;
OutTraceD3D("SwapTextureHandles(1): d3dd=%x t1=%x t2=%x\n", d3dd, t1, t2);
OutTraceD3D("SwapTextureHandles(D3D1): d3dd=%x t1=%x t2=%x\n", d3dd, t1, t2);
if (dxw.dwFlags4 & NOTEXTURES) return DD_OK;
res=(*pSwapTextureHandles)(d3dd, t1, t2);
if(res) OutTraceD3D("SwapTextureHandles(1): ERROR res=%x\n", res);
if(res) OutTraceD3D("SwapTextureHandles: ERROR res=%x\n", res);
return res;
}
@ -1811,11 +1808,11 @@ HRESULT WINAPI extSwapTextureHandles2(void *d3dd, LPDIRECT3DTEXTURE2 t1, LPDIREC
{
HRESULT res;
OutTraceD3D("SwapTextureHandles(2): d3dd=%x t1=%x t2=%x\n", d3dd, t1, t2);
OutTraceD3D("SwapTextureHandles(D3D2): d3dd=%x t1=%x t2=%x\n", d3dd, t1, t2);
if (dxw.dwFlags4 & NOTEXTURES) return DD_OK;
res=(*pSwapTextureHandles2)(d3dd, t1, t2);
if(res) OutTraceD3D("SwapTextureHandles(2): ERROR res=%x\n", res);
if(res) OutTraceD3D("SwapTextureHandles: ERROR res=%x\n", res);
return res;
}
@ -1915,7 +1912,7 @@ HRESULT WINAPI FillPixelFormatTable(LPDDPIXELFORMAT lpDDPixFmt, LPVOID Arg)
static HRESULT WINAPI extEnumZBufferFormats(int d3dversion, EnumZBufferFormats_Type pEnumZBufferFormats, void *lpd3d, REFCLSID riidDevice, LPD3DENUMPIXELFORMATSCALLBACK lpEnumCallback, LPVOID lpContext)
{
HRESULT ret;
OutTraceD3D("Direct3D::EnumZBufferFormats(%d) d3d=%x clsid=%x context=%x\n", d3dversion, lpd3d, riidDevice.Data1, lpContext);
OutTraceD3D("Direct3D::EnumZBufferFormats(D3D%d) d3d=%x clsid=%x context=%x\n", d3dversion, lpd3d, riidDevice.Data1, lpContext);
if(dxw.dwFlags8 & TRIMTEXTUREFORMATS){
int iIndex;
@ -1943,7 +1940,7 @@ static HRESULT WINAPI extEnumZBufferFormats(int d3dversion, EnumZBufferFormats_T
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]));
OutTraceD3D("Direct3D::EnumZBufferFormats: CALLBACK entry=%d ret=%x %s\n", iIndex, ret, ExplainPixelFormat(&PixelFormatTable.lpPixelFormatEntries[iIndex]));
if(!ret) break;
iEnumerated++;
}
@ -2068,7 +2065,7 @@ static HRESULT WINAPI SetTransform(int d3dversion, SetTransform_Type pSetTransfo
{
HRESULT res;
OutTrace("SetTransform(%d): lpd3dd=%x tstype=%x(%s) matrix={\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
OutTrace("SetTransform(D3D%d): lpd3dd=%x tstype=%x(%s) matrix={\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
d3dversion, lpd3dd, tstype, sTransformType(tstype),
matrix->_11, matrix->_12, matrix->_13, matrix->_14,
matrix->_21, matrix->_22, matrix->_23, matrix->_24,

47
dll/opengl.cpp
View File

@ -199,9 +199,9 @@ void WINAPI extglViewport(GLint x, GLint y, GLsizei width, GLsizei height
RECT client;
POINT p={0,0};
HWND hwnd;
OutTraceOGL("glViewport: pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
hwnd=dxw.GethWnd();
(*pGetClientRect)(hwnd, &client);
OutTraceDW("glViewport: declared pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
if(IsDebug) OutTrace("glViewport: DEBUG hwnd=%x win=(%d,%d) screen=(%d,%d)\n",
hwnd, client.right, client.bottom, dxw.GetScreenWidth(), dxw.GetScreenHeight());
if(x==CW_USEDEFAULT) x=0;
@ -220,7 +220,7 @@ void WINAPI extglScissor(GLint x, GLint y, GLsizei width, GLsizei height)
POINT p={0,0};
//if (dxw.dwFlags2 & HANDLEFPS) if(dxw.HandleFPS()) return;
(*pGetClientRect)(dxw.GethWnd(), &client);
OutTraceDW("glScissor: declared pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
OutTraceOGL("glScissor: pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
x = (x * (GLint)client.right) / (GLint)dxw.GetScreenWidth();
y = (y * (GLint)client.bottom) / (GLint)dxw.GetScreenHeight();
width = (width * (GLint)client.right) / (GLint)dxw.GetScreenWidth();
@ -268,16 +268,19 @@ void WINAPI extglDrawBuffer(GLenum mode)
void WINAPI extglPolygonMode(GLenum face, GLenum mode)
{
OutTraceDW("glPolygonMode: face=%x mode=%x\n", face, mode);
OutTraceOGL("glPolygonMode: face=%x mode=%x\n", face, mode);
//OutTraceDW("glPolygonMode: extglPolygonMode=%x pglPolygonMode=%x\n", extglPolygonMode, pglPolygonMode);
if(dxw.dwFlags2 & WIREFRAME) mode = GL_LINE; // trick to set wireframe mode....
if(dxw.dwFlags2 & WIREFRAME) {
OutTraceDW("glPolygonMode: WIREFRAME forcind mode=GL_LINE\n");
mode = GL_LINE; // trick to set wireframe mode....
}
(*pglPolygonMode)(face, mode);
return;
}
void WINAPI extglGetFloatv(GLenum pname, GLboolean *params)
{
OutTraceDW("glGetFloatv: pname=%x\n", pname);
OutTraceOGL("glGetFloatv: pname=%x\n", pname);
(*pglGetFloatv)(pname, params);
return;
}
@ -294,7 +297,7 @@ void WINAPI extglClear(GLbitfield mask)
HGLRC WINAPI extwglCreateContext(HDC hdc)
{
HGLRC ret;
OutTraceDW("wglCreateContext: hdc=%x\n", hdc);
OutTraceOGL("wglCreateContext: hdc=%x\n", hdc);
// v2.02.31: don't let it use desktop hdc
if(dxw.IsRealDesktop(WindowFromDC(hdc))){
HDC oldhdc = hdc;
@ -318,7 +321,7 @@ PROC WINAPI extwglGetProcAddress(LPCSTR proc)
{
PROC procaddr;
OutTraceDW("wglGetProcAddress: proc=%s\n", proc);
OutTraceOGL("wglGetProcAddress: proc=%s\n", proc);
procaddr=Remap_wgl_ProcAddress(proc);
if (!procaddr) procaddr=(*pwglGetProcAddress)(proc);
return procaddr;
@ -328,7 +331,7 @@ BOOL WINAPI extwglMakeCurrent(HDC hdc, HGLRC hglrc)
{
BOOL ret;
OutTraceDW("wglMakeCurrent: hdc=%x hglrc=%x\n", hdc, hglrc);
OutTraceOGL("wglMakeCurrent: hdc=%x hglrc=%x\n", hdc, hglrc);
// v2.02.31: don't let it use desktop hdc
if(dxw.IsDesktop(WindowFromDC(hdc))){
HDC oldhdc = hdc;
@ -523,7 +526,7 @@ void WINAPI extglTexImage2D(
GLenum type,
const GLvoid * data)
{
OutTraceDW("glTexImage2D: TEXTURE target=%x(%s) level=%x internalformat=%x format=%x type=%x size=(%dx%d)\n",
OutTraceOGL("glTexImage2D: TEXTURE target=%x(%s) level=%x internalformat=%x format=%x type=%x size=(%dx%d)\n",
target, ExplainTarget(target), level, internalFormat, format, type, width, height);
switch(target){
@ -564,7 +567,7 @@ void WINAPI extglCopyTexImage2D(
GLsizei height,
GLint border)
{
OutTraceDW("glCopyTexImage2D: TEXTURE target=%x(%s) level=%x internalformat=%x pos=(%d,%d) size=(%dx%d) border=%d\n",
OutTraceOGL("glCopyTexImage2D: TEXTURE target=%x(%s) level=%x internalformat=%x pos=(%d,%d) size=(%dx%d) border=%d\n",
target, ExplainTarget(target), level, internalFormat, x, y, width, height, border);
switch(target){
@ -634,7 +637,7 @@ void WINAPI extglDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum
void WINAPI extglPixelZoom(GLfloat xfactor, GLfloat yfactor)
{
GLenum glerr;
OutTraceDW("glPixelZoom: x,y factor=(%f,%f)\n", xfactor, yfactor);
OutTraceOGL("glPixelZoom: x,y factor=(%f,%f)\n", xfactor, yfactor);
if(dxw.dwFlags6 & FIXPIXELZOOM){
RECT desktop;
@ -651,18 +654,18 @@ void WINAPI extglPixelZoom(GLfloat xfactor, GLfloat yfactor)
void WINAPI extglBegin(GLenum mode)
{
GLenum glerr;
OutTraceDW("glBegin: mode=%x\n", mode);
OutTraceOGL("glBegin: mode=%x\n", mode);
//if(mode == GL_QUADS) mode = GL_TRIANGLES;
(*pglBegin)(mode);
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;
}
void WINAPI extglBindTexture(GLenum target, GLuint texture)
{
GLenum glerr;
OutTraceDW("glBindTexture: target=%x(%s) texture=%x\n", target, ExplainTarget(target), texture);
OutTraceOGL("glBindTexture: target=%x(%s) texture=%x\n", target, ExplainTarget(target), texture);
if(dxw.dwFlags7 & FIXBINDTEXTURE) {
static GLuint uiLastTex = 0;
@ -671,14 +674,14 @@ void WINAPI extglBindTexture(GLenum target, GLuint texture)
}
(*pglBindTexture)(target, texture);
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;
}
void WINAPI extglPixelStorei(GLenum pname, GLint param)
{
GLenum glerr;
OutTraceDW("glPixelStorei: pname=%x param=%x\n", pname, param);
OutTraceOGL("glPixelStorei: pname=%x param=%x\n", pname, param);
(*pglPixelStorei)(pname, param);
if ((glerr=extglGetError())!= GL_NO_ERROR) OutTrace("GLERR %d ad %d\n", glerr, __LINE__);
@ -687,6 +690,7 @@ void WINAPI extglPixelStorei(GLenum pname, GLint param)
void WINAPI extglutFullScreen(void)
{
OutTraceOGL("glutFullScreen: void\n");
if(!dxw.Windowize) return (*pglutFullScreen)();
OutTraceDW("glutFullScreen BYPASS\n");
dxw.SetFullScreen(TRUE);
@ -695,10 +699,10 @@ void WINAPI extglutFullScreen(void)
void extglutInitWindowSize(int width, int height)
{
int dummy1, dummy2;
OutTraceOGL("glutInitWindowSize: size=(%dx%d)\n", width, height);
if(dxw.Windowize){
dummy1=0;
dummy2=0;
OutTraceDW("glutInitWindowSize: width=%d height=%d\n", width, height);
dxw.MapWindow(&dummy1, &dummy2, &width, &height);
OutTraceDW("glutInitWindowSize: FIXED width=%d height=%d\n", width, height);
}
@ -708,19 +712,19 @@ void extglutInitWindowSize(int width, int height)
void extglutInitWindowPosition(int x, int y)
{
int dummy1, dummy2;
OutTraceOGL("glutInitWindowPosition: pos=(%d,%d)\n", x, y);
if(dxw.Windowize){
dummy1=0;
dummy2=0;
OutTraceDW("glutInitWindowPosition: x=%d y=%d\n", x, y);
dxw.MapWindow(&x, &y, &dummy1, &dummy2);
OutTraceDW("glutInitWindowPosition: FIXED x=%d y=%d\n", x, y);
OutTraceDW("glutInitWindowPosition: FIXED pos=(%d,%d)\n", x, y);
}
(*pglutInitWindowPosition)(x, y);
}
void WINAPI extglutSetWindow(HWND win)
{
OutTraceDW("glutSetWindow: win=%x\n", win);
OutTraceOGL("glutSetWindow: win=%x\n", win);
if(dxw.Windowize && dxw.IsRealDesktop(win)) win=dxw.GethWnd();
(*pglutSetWindow)(win);
}
@ -742,6 +746,7 @@ static char *glStringName(GLenum name)
const GLubyte* WINAPI extglGetString(GLenum name)
{
const GLubyte* ret;
OutTraceOGL("glGetString: name=%s\n", name);
ret = (*pglGetString)(name);
if(IsTraceDW){
if(strlen((const char *)ret)<80)
@ -762,6 +767,7 @@ const GLubyte* WINAPI extglGetString(GLenum name)
char* WINAPI extwglGetExtensionsStringEXT(void)
{
char *ret;
OutTraceOGL("wglGetExtensionsStringEXT: void\n");
ret = (*pwglGetExtensionsStringEXT)();
if(IsTraceDW){
if(strlen((const char *)ret)<80)
@ -782,6 +788,7 @@ char* WINAPI extwglGetExtensionsStringEXT(void)
const GLubyte* WINAPI extgluGetString(GLenum name)
{
const GLubyte* ret;
OutTraceOGL("gluGetString: name=%s\n", name);
ret = (*pgluGetString)(name);
if(IsTraceDW){
if(strlen((const char *)ret)<80)

10
dll/syslibs.h
View File

@ -164,8 +164,8 @@ typedef LPTOP_LEVEL_EXCEPTION_FILTER
typedef void (WINAPI *Sleep_Type)(DWORD);
typedef DWORD (WINAPI *SleepEx_Type)(DWORD, BOOL);
typedef BOOL (WINAPI *CreateScalableFontResourceA_Type)(DWORD, LPCTSTR, LPCTSTR, LPCTSTR);
typedef int (WINAPI *AddFontResourceA_Type)(LPCTSTR);
typedef BOOL (WINAPI *CreateScalableFontResourceW_Type)(DWORD, LPCWSTR, LPCWSTR, LPCWSTR);
typedef int (WINAPI *AddFontResourceA_Type)(LPCTSTR);
typedef int (WINAPI *AddFontResourceW_Type)(LPCWSTR);
typedef HANDLE (WINAPI *CreateFile_Type)(LPCTSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
typedef DWORD (WINAPI *SetFilePointer_Type)(HANDLE, LONG, PLONG, DWORD);
@ -368,9 +368,11 @@ DXWEXTERN GetWindowOrgEx_Type pGetWindowOrgEx DXWINITIALIZED;
DXWEXTERN SetWindowOrgEx_Type pSetWindowOrgEx DXWINITIALIZED;
DXWEXTERN GetCurrentPositionEx_Type pGetCurrentPositionEx DXWINITIALIZED;
DXWEXTERN CreateScalableFontResourceA_Type pCreateScalableFontResourceA DXWINITIALIZED;
DXWEXTERN AddFontResourceA_Type pAddFontResourceA DXWINITIALIZED;
DXWEXTERN CreateScalableFontResourceW_Type pCreateScalableFontResourceW DXWINITIALIZED;
DXWEXTERN AddFontResourceA_Type pAddFontResourceA DXWINITIALIZED;
DXWEXTERN AddFontResourceW_Type pAddFontResourceW DXWINITIALIZED;
DXWEXTERN AddFontResourceA_Type pRemoveFontResourceA DXWINITIALIZED;
DXWEXTERN AddFontResourceW_Type pRemoveFontResourceW DXWINITIALIZED;
DXWEXTERN AnimatePalette_Type pAnimatePalette DXWINITIALIZED;
DXWEXTERN SetSystemPaletteUse_Type pSetSystemPaletteUse DXWINITIALIZED;
DXWEXTERN GDISetPixelFormat_Type pGDISetPixelFormat DXWINITIALIZED;
@ -628,8 +630,10 @@ extern BOOL WINAPI extSetWindowOrgEx(HDC, int, int, LPPOINT);
extern BOOL WINAPI extGetCurrentPositionEx(HDC, LPPOINT);
extern BOOL WINAPI extCreateScalableFontResourceA(DWORD, LPCTSTR, LPCTSTR, LPCTSTR);
extern int WINAPI extAddFontResourceA(LPCTSTR);
extern BOOL WINAPI extCreateScalableFontResourceW(DWORD, LPCWSTR, LPCWSTR, LPCWSTR);
extern int WINAPI extAddFontResourceW(LPCWSTR);
extern int WINAPI extRemoveFontResourceA(LPCTSTR);
extern int WINAPI extRemoveFontResourceW(LPCWSTR);
extern BOOL WINAPI extCreateScalableFontResourceW(DWORD, LPCWSTR, LPCWSTR, LPCWSTR);
extern BOOL WINAPI extAnimatePalette(HPALETTE, UINT, UINT, const PALETTEENTRY *);
extern UINT WINAPI extSetSystemPaletteUse(HDC, UINT);
extern BOOL WINAPI extGDISetPixelFormat(HDC, int, const PIXELFORMATDESCRIPTOR *);

15
dll/user32.cpp
View File

@ -1134,6 +1134,13 @@ LRESULT WINAPI extSendMessage(char *apiname, SendMessage_Type pSendMessage, HWND
lParam = MAKELPARAM(curr.x, curr.y);
OutTraceC("%s: hwnd=%x pos XY=(%d,%d)->(%d,%d)\n", apiname, hwnd, prev.x, prev.y, curr.x, curr.y);
break;
#if 1
// unnecessaty: set "Bypass font unsupported api" ??
case WM_FONTCHANGE:
// suppress WM_FONTCHANGE avoids "Warhammer: Shadow of the Horned Rat" crash when entering battle
return 0;
break;
#endif
default:
break;
}
@ -1815,12 +1822,14 @@ static HWND WINAPI CreateWindowCommon(
// v2.04.02: InMainWinCreation semaphore, signals to the CreateWin callback that the window to be created will be a main window,
// so rules about LOCKWINPOS etc. must be applied. Fixes "Civil War 2 Generals" main window displacement.
InMainWinCreation = TRUE;
// v2.04.05: the semaphore must be a counter, since within the CreateWin callback there could be other CreateWin calls.
// happens in "Warhammer: Shadow of the Horned Rat" !
InMainWinCreation++;
if(WideChar)
hwnd= (*pCreateWindowExW)(dwExStyle, (LPCWSTR)lpClassName, (LPCWSTR)lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam);
else
hwnd= (*pCreateWindowExA)(dwExStyle, (LPCSTR)lpClassName, (LPCSTR)lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam);
InMainWinCreation = FALSE;
InMainWinCreation--;
if (hwnd==(HWND)NULL){
OutTraceE("%s: ERROR err=%d Style=%x(%s) ExStyle=%x\n",
@ -2660,7 +2669,7 @@ BOOL WINAPI extMoveWindow(HWND hwnd, int X, int Y, int nWidth, int nHeight, BOOL
OutTraceDW("MoveWindow: hwnd=%x xy=(%d,%d) size=(%d,%d) repaint=%x fullscreen=%x\n",
hwnd, X, Y, nWidth, nHeight, bRepaint, dxw.IsFullScreen());
if(dxw.Windowize){
if(dxw.Windowize && !InMainWinCreation){
if(dxw.IsDesktop(hwnd)){
// v2.1.93: happens in "Emergency Fighters for Life" ...
// what is the meaning of this? is it related to video stretching?

31
dll/wing32.cpp
View File

@ -30,6 +30,8 @@
#include "stdio.h"
extern int WINAPI extFrameRect(HDC, const RECT *, HBRUSH);
typedef BOOL (WINAPI *WinGBitBlt_Type)(HDC, INT, INT, INT, INT, HDC, INT, INT);
typedef BOOL (WINAPI *WinGStretchBlt_Type)(HDC, INT, INT, INT, INT, HDC, INT, INT, INT, INT);
typedef HBITMAP (WINAPI *WinGCreateBitmap_Type)(HDC, BITMAPINFO *, void **);
@ -96,28 +98,27 @@ FARPROC Remap_WinG32_ProcAddress(LPCSTR proc, HMODULE hModule)
HDC WINAPI extWinGCreateDC(void)
{
OutTrace("WinGCreateDC\n");
OutTraceWG("WinGCreateDC\n");
return extGDICreateCompatibleDC(0);
}
HBITMAP WINAPI extWinGCreateBitmap(HDC hdc, BITMAPINFO *bmi, void **bits)
{
HBITMAP ret;
OutTrace("WinGCreateBitmap: hdc=%x bmi=%x\n", hdc, bmi);
OutTraceWG("WinGCreateBitmap: hdc=%x bmi=%x\n", hdc, bmi);
ret = extCreateDIBSection(hdc, bmi, 0, bits, 0, 0);
OutTrace("WinGCreateBitmap: ret=%x\n", ret);
//return (*pCreateDIBSection)(hdc, bmi, 0, bits, 0, 0);
//(*pInvalidateRect)(dxw.GethWnd(), NULL, FALSE);
OutTraceWG("WinGCreateBitmap: ret=%x\n", ret);
return ret;
}
BOOL WINAPI extWinGBitBlt(HDC hdcDst, INT xDst, INT yDst, INT width, INT height, HDC hdcSrc, INT xSrc, INT ySrc )
{
BOOL ret;
OutTrace("WinGBitBlt: hdcdest=%x pos=(%d,%d) size=(%dx%d) hdcsrc=%x pos=(%d,%d)\n",
OutTraceWG("WinGBitBlt: hdcdest=%x pos=(%d,%d) size=(%dx%d) hdcsrc=%x pos=(%d,%d)\n",
hdcDst, xDst, yDst, width, height, hdcSrc, xSrc, ySrc);
ret = extGDIBitBlt(hdcDst, xDst, yDst, width, height, hdcSrc, xSrc, ySrc, SRCCOPY);
//(*pInvalidateRect)(dxw.GethWnd(), NULL, FALSE);
if(dxw.dwFlags8 & MARKWING32) dxw.Mark(hdcDst, TRUE, RGB(0, 255, 0), xDst, yDst, width, height);
return ret;
}
@ -127,20 +128,21 @@ BOOL WINAPI extWinGStretchBlt(HDC hdcDst, INT xDst, INT yDst, INT widthDst, INT
INT old_blt_mode;
BOOL ret;
OutTrace("WinGStretchBlt: hdcdest=%x pos=(%d,%d) size=(%dx%d) hdcsrc=%x pos=(%d,%d) size=(%dx%d)\n",
OutTraceWG("WinGStretchBlt: hdcdest=%x pos=(%d,%d) size=(%dx%d) hdcsrc=%x pos=(%d,%d) size=(%dx%d)\n",
hdcDst, xDst, yDst, widthDst, heightDst, hdcSrc, xSrc, ySrc, widthSrc, heightSrc);
// wing hdc is always a screen DC.
old_blt_mode = SetStretchBltMode( hdcDst, COLORONCOLOR );
ret = extGDIStretchBlt( hdcDst, xDst, yDst, widthDst, heightDst,
hdcSrc, xSrc, ySrc, widthSrc, heightSrc, SRCCOPY );
SetStretchBltMode( hdcDst, old_blt_mode );
//(*pInvalidateRect)(dxw.GethWnd(), NULL, FALSE);
if(dxw.dwFlags8 & MARKWING32) dxw.Mark(hdcDst, TRUE, RGB(255, 0, 0), xDst, yDst, widthDst, heightDst);
return ret;
}
BOOL WINAPI extWinGRecommendDIBFormat(BITMAPINFO *bmi)
{
OutTrace("WinGRecommendDIBFormat\n");
OutTraceWG("WinGRecommendDIBFormat\n");
if (!bmi) return FALSE;
bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
@ -162,7 +164,7 @@ void * WINAPI extWinGGetDIBPointer(HBITMAP hbmp, BITMAPINFO *bmi)
{
DIBSECTION ds;
OutTrace("WinGGetDIBPointer\n");
OutTraceWG("WinGGetDIBPointer\n");
if (GetObjectW( hbmp, sizeof(ds), &ds ) == sizeof(ds)) {
memcpy( &bmi->bmiHeader, &ds.dsBmih, sizeof(*bmi) );
return ds.dsBm.bmBits;
@ -172,14 +174,14 @@ void * WINAPI extWinGGetDIBPointer(HBITMAP hbmp, BITMAPINFO *bmi)
UINT WINAPI extWinGSetDIBColorTable(HDC hdc, UINT start, UINT end, RGBQUAD *colors)
{
OutTrace("WinGSetDIBColorTable: hdc=%x start=%d end=%d\n", hdc, start, end);
OutTraceWG("WinGSetDIBColorTable: hdc=%x start=%d end=%d\n", hdc, start, end);
(*pInvalidateRect)(dxw.GethWnd(), NULL, FALSE);
return SetDIBColorTable( hdc, start, end, colors );
}
UINT WINAPI extWinGGetDIBColorTable(HDC hdc, UINT start, UINT end, RGBQUAD *colors)
{
OutTrace("WinGGetDIBColorTable: hdc=%x start=%d end=%d\n", hdc, start, end);
OutTraceWG("WinGGetDIBColorTable: hdc=%x start=%d end=%d\n", hdc, start, end);
(*pInvalidateRect)(dxw.GethWnd(), NULL, FALSE);
return GetDIBColorTable( hdc, start, end, colors );
}
@ -189,6 +191,7 @@ HPALETTE WINAPI extWinGCreateHalfTonePalette(void)
HDC hdc;
HPALETTE hpal;
OutTraceWG("WinGCreateHalfTonePalette: void\n");
hdc = GetDC(0);
hpal = CreateHalftonePalette(hdc);
ReleaseDC(0, hdc);
@ -199,6 +202,6 @@ HPALETTE WINAPI extWinGCreateHalfTonePalette(void)
HBRUSH WINAPI extWinGCreateHalfToneBrush(HDC hdc, COLORREF color, INT type)
{
OutTrace("WinGCreateHalfToneBrush: hdc=%x color=%x type=%d\n", hdc, color, type);
OutTraceWG("WinGCreateHalfToneBrush: hdc=%x color=%x type=%d\n", hdc, color, type);
return CreateSolidBrush(color);
}

2
host/TabDebug.cpp
View File

@ -30,6 +30,8 @@ void CTabDebug::DoDataExchange(CDataExchange* pDX)
DDX_Check(pDX, IDC_ASSERT, cTarget->m_AssertDialog);
DDX_Check(pDX, IDC_MARKBLIT, cTarget->m_MarkBlit);
DDX_Check(pDX, IDC_MARKLOCK, cTarget->m_MarkLock);
DDX_Check(pDX, IDC_MARKWING32, cTarget->m_MarkWinG32);
DDX_Check(pDX, IDC_MARKGDI32, cTarget->m_MarkGDI32);
DDX_Check(pDX, IDC_NOBLT, cTarget->m_NoBlt);
DDX_Check(pDX, IDC_FASTBLT, cTarget->m_FastBlt);
DDX_Check(pDX, IDC_GDICOLORCONV, cTarget->m_GDIColorConv);

1
host/TabDirect3D.cpp
View File

@ -30,6 +30,7 @@ void CTabDirect3D::DoDataExchange(CDataExchange* pDX)
// Direct3D tweaks
DDX_Check(pDX, IDC_ZBUFFERCLEAN, cTarget->m_ZBufferClean);
DDX_Check(pDX, IDC_ZBUFFER0CLEAN, cTarget->m_ZBuffer0Clean);
DDX_Check(pDX, IDC_DYNAMICZCLEAN, cTarget->m_DynamicZClean);
DDX_Check(pDX, IDC_NOPOWER2FIX, cTarget->m_NoPower2Fix);
DDX_Check(pDX, IDC_NOD3DRESET, cTarget->m_NoD3DReset);
DDX_Check(pDX, IDC_SUPPRESSD3DEXT, cTarget->m_SuppressD3DExt);

2
host/TabLogs.cpp
View File

@ -51,6 +51,8 @@ void CTabLogs::DoDataExchange(CDataExchange* pDX)
DDX_Check(pDX, IDC_IMPORTTABLE, cTarget->m_ImportTable);
DDX_Check(pDX, IDC_OUTREGISTRY, cTarget->m_RegistryOp);
DDX_Check(pDX, IDC_TRACEHOOKS, cTarget->m_TraceHooks);
DDX_Check(pDX, IDC_OUTOGLTRACE, cTarget->m_OutOGLTrace);
DDX_Check(pDX, IDC_OUTWGTRACE, cTarget->m_OutWGTrace);
}
BEGIN_MESSAGE_MAP(CTabLogs, CDialog)

2
host/TabProgram.cpp
View File

@ -137,7 +137,7 @@ END_MESSAGE_MAP()
extern void GetFolderFromPath(char *);
static BOOL IsWinXP()
BOOL IsWinXP()
{
OSVERSIONINFO osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));

5
host/TargetDlg.cpp
View File

@ -47,6 +47,8 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
m_CursorTrace = FALSE;
m_OutWinMessages = FALSE;
m_OutDWTrace = FALSE;
m_OutOGLTrace = FALSE;
m_OutWGTrace = FALSE;
m_OutD3DTrace = FALSE;
m_OutDDRAWTrace = FALSE;
m_OutDebugString = FALSE;
@ -109,6 +111,7 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
m_BufferedIOFix = FALSE;
m_ZBufferClean = FALSE;
m_ZBuffer0Clean = FALSE;
m_DynamicZClean = FALSE;
m_ZBufferAlways = FALSE;
m_HotPatchAlways = FALSE;
m_FreezeInjectedSon = FALSE;
@ -176,6 +179,8 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
m_FlipEmulation = TRUE; // better set true default, since this mode is more compatible
m_MarkBlit = FALSE;
m_MarkLock = FALSE;
m_MarkWinG32 = FALSE;
m_MarkGDI32 = FALSE;
m_NoSysMemPrimary = FALSE;
m_NoSysMemBackBuf = FALSE;
m_NoBlt = FALSE;

5
host/TargetDlg.h
View File

@ -60,6 +60,8 @@ public:
BOOL m_OutDebugString;
BOOL m_OutWinMessages;
BOOL m_OutDWTrace;
BOOL m_OutOGLTrace;
BOOL m_OutWGTrace;
BOOL m_OutD3DTrace;
BOOL m_OutDDRAWTrace;
BOOL m_AssertDialog;
@ -131,6 +133,8 @@ public:
BOOL m_FlipEmulation;
BOOL m_MarkBlit;
BOOL m_MarkLock;
BOOL m_MarkWinG32;
BOOL m_MarkGDI32;
BOOL m_NoSysMemPrimary;
BOOL m_NoSysMemBackBuf;
BOOL m_NoBlt;
@ -215,6 +219,7 @@ public:
BOOL m_BufferedIOFix;
BOOL m_ZBufferClean;
BOOL m_ZBuffer0Clean;
BOOL m_DynamicZClean;
BOOL m_ZBufferAlways;
BOOL m_HotPatchAlways;
BOOL m_FreezeInjectedSon;

BIN
host/dxwndhost.aps
View File

Binary file not shown.

BIN
host/dxwndhost.rc
View File

Binary file not shown.

BIN
host/dxwndhost.vs2008.suo
View File

Binary file not shown.

24
host/dxwndhostView.cpp
View File

@ -360,6 +360,8 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
if(dlg->m_AddRelativeTime) t->tflags |= ADDRELATIVETIME;
if(dlg->m_OutWinMessages) t->tflags |= OUTWINMESSAGES;
if(dlg->m_OutDWTrace) t->tflags |= OUTDXWINTRACE;
if(dlg->m_OutOGLTrace) t->tflags |= OUTOGLTRACE;
if(dlg->m_OutWGTrace) t->tflags |= OUTWINGTRACE;
if(dlg->m_OutDDRAWTrace) t->tflags |= OUTDDRAWTRACE;
if(dlg->m_OutD3DTrace) t->tflags |= OUTD3DTRACE;
if(dlg->m_AssertDialog) t->tflags |= ASSERTDIALOG;
@ -376,6 +378,7 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
if(dlg->m_BufferedIOFix) t->flags3 |= BUFFEREDIOFIX;
if(dlg->m_ZBufferClean) t->flags4 |= ZBUFFERCLEAN;
if(dlg->m_ZBuffer0Clean) t->flags4 |= ZBUFFER0CLEAN;
if(dlg->m_DynamicZClean) t->flags8 |= DYNAMICZCLEAN;
if(dlg->m_ZBufferAlways) t->flags4 |= ZBUFFERALWAYS;
if(dlg->m_HotPatchAlways) t->flags4 |= HOTPATCHALWAYS;
if(dlg->m_FreezeInjectedSon) t->flags5 |= FREEZEINJECTEDSON;
@ -452,6 +455,8 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
if(dlg->m_FlipEmulation) t->flags6 |= FLIPEMULATION;
if(dlg->m_MarkBlit) t->flags3 |= MARKBLIT;
if(dlg->m_MarkLock) t->flags3 |= MARKLOCK;
if(dlg->m_MarkWinG32) t->flags8 |= MARKWING32;
if(dlg->m_MarkGDI32) t->flags8 |= MARKGDI32;
if(dlg->m_NoSysMemPrimary) t->flags6 |= NOSYSMEMPRIMARY;
if(dlg->m_NoSysMemBackBuf) t->flags6 |= NOSYSMEMBACKBUF;
if(dlg->m_NoBlt) t->flags5 |= NOBLT;
@ -676,6 +681,8 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
dlg->m_AddRelativeTime = t->tflags & ADDRELATIVETIME ? 1 : 0;
dlg->m_OutWinMessages = t->tflags & OUTWINMESSAGES ? 1 : 0;
dlg->m_OutDWTrace = t->tflags & OUTDXWINTRACE ? 1 : 0;
dlg->m_OutOGLTrace = t->tflags & OUTOGLTRACE ? 1 : 0;
dlg->m_OutWGTrace = t->tflags & OUTWINGTRACE ? 1 : 0;
dlg->m_OutD3DTrace = t->tflags & OUTD3DTRACE ? 1 : 0;
dlg->m_OutDDRAWTrace = t->tflags & OUTDDRAWTRACE ? 1 : 0;
dlg->m_AssertDialog = t->tflags & ASSERTDIALOG ? 1 : 0;
@ -733,6 +740,7 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
dlg->m_BufferedIOFix = t->flags3 & BUFFEREDIOFIX ? 1 : 0;
dlg->m_ZBufferClean = t->flags4 & ZBUFFERCLEAN ? 1 : 0;
dlg->m_ZBuffer0Clean = t->flags4 & ZBUFFER0CLEAN ? 1 : 0;
dlg->m_DynamicZClean = t->flags8 & DYNAMICZCLEAN ? 1 : 0;
dlg->m_ZBufferAlways = t->flags4 & ZBUFFERALWAYS ? 1 : 0;
dlg->m_HotPatchAlways = t->flags4 & HOTPATCHALWAYS ? 1 : 0;
dlg->m_FreezeInjectedSon = t->flags5 & FREEZEINJECTEDSON ? 1 : 0;
@ -769,6 +777,8 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
dlg->m_FlipEmulation = t->flags6 & FLIPEMULATION ? 1 : 0;
dlg->m_MarkBlit = t->flags3 & MARKBLIT ? 1 : 0;
dlg->m_MarkLock = t->flags3 & MARKLOCK ? 1 : 0;
dlg->m_MarkWinG32 = t->flags8 & MARKWING32 ? 1 : 0;
dlg->m_MarkGDI32 = t->flags8 & MARKGDI32 ? 1 : 0;
dlg->m_NoSysMemPrimary = t->flags6 & NOSYSMEMPRIMARY ? 1 : 0;
dlg->m_NoSysMemBackBuf = t->flags6 & NOSYSMEMBACKBUF ? 1 : 0;
dlg->m_NoBlt = t->flags5 & NOBLT ? 1 : 0;
@ -1620,6 +1630,7 @@ void CDxwndhostView::OnExplore()
POSITION pos;
int len;
CString FilePath;
HINSTANCE ret;
CListCtrl& listctrl = GetListCtrl();
@ -1630,8 +1641,16 @@ void CDxwndhostView::OnExplore()
len=FilePath.ReverseFind('\\');
if (len==0) return;
FilePath.Truncate(len);
//MessageBox(FilePath, "path", 0);
ShellExecute(NULL, "explore", FilePath, NULL, NULL, SW_SHOW);
extern BOOL IsWinXP(void);
ret = ShellExecute(NULL, IsWinXP() ? "open" : "explore", FilePath, NULL, NULL, SW_SHOW);
if((int)ret <= 32){
char message[MAX_PATH];
sprintf(message, "ShellExecute(\"%s\", \"%s\") failed.\nerror=%d",
IsWinXP() ? "open" : "explore", FilePath, ret);
MessageBox(message, "error", 0);
}
}
void CDxwndhostView::OnViewLog()
@ -2551,7 +2570,8 @@ void CDxwndhostView::OnRButtonDown(UINT nFlags, CPoint point)
int res;
ClientToScreen(&point);
popup.LoadMenu(IDR_MENU_POPUP);
popup.LoadMenu(gbDebug ? IDR_MENU_POPUP_EX : IDR_MENU_POPUP);
res = popup.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN | TPM_TOPALIGN | TPM_LEFTBUTTON | TPM_RETURNCMD, point.x, point.y, this);
switch(res){
case ID_PRUN:

BIN
host/resource
View File

Binary file not shown.

BIN
wing/wing32.suo
View File

Binary file not shown.