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_02_49_src

Browse Source 
Former-commit-id: 5c236b9df56bdded7a137dc0a99efa043028ac41
This commit is contained in:
gho tik 2013-12-22 11:38:36 -05:00 committed by Refael ACkermann
parent fceaa16fbd
commit d38799715a
68 changed files with 5882 additions and 1539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Include/dxwnd.h
View File

@ -122,19 +122,23 @@
#define ZBUFFERALWAYS 0x00000040 // Forces ZBUFFER D3DCMP_ALWAYS condition to show all planes....
#define DISABLEFOGGING 0x00000080 // Disable D3D fogging
#define NOPOWER2FIX 0x00000100 // Handle textures whose size is not a power of 2 (32, 64, 128 ...)
#define NOPERFCOUNTER 0x00000200 // Disables the GetPerfCounter performance metrics API,as if it was not supported....
#define ADDPROXYLIBS 0x00000400 // Add proxy libs to otherwise hook-resilient system libraries (e.g. d3d9.dll)
// logging Tflags DWORD:
#define OUTTRACE 0x00000001 // enables tracing to dxwnd.log in general
#define OUTDDRAWTRACE 0x00000002 // traces DxWnd directdraw screen handling
#define OUTWINMESSAGES 0x00000004 // traces windows messages
#define OUTCURSORTRACE 0x00000008 // traces cursor positions & operations
#define OUTPROXYTRACE 0x00000010 // warning: it also enables proxy functions !!!!
#define OUTPROXYTRACE 0x00000010 // enables all operations through proxy functions
#define DXPROXED 0x00000020 // hook DX proxy methods to log each call in original behaviour
#define ASSERTDIALOG 0x00000040 // show assert messages in Dialog Box
#define OUTIMPORTTABLE 0x00000080 // dump import table contents
#define OUTDEBUG 0x00000100 // detailed debugging indormation
#define OUTREGISTRY 0x00000200 // log registry operations
#define TRACEHOOKS 0x00000400 // log hook operations
#define OUTD3DTRACE 0x00000800 // traces DxWnd direct3d screen handling
#define OUTDXWINTRACE 0x00001000 // traces DxWnd internal operations
#define EMULATEFLAGS (EMULATEBUFFER | EMULATESURFACE | LOCKEDSURFACE)
#define HANDLEFPS (SHOWFPS | SHOWFPSOVERLAY | LIMITFPS | SKIPFPS)
@ -206,7 +210,9 @@ LRESULT CALLBACK extWindowProc(HWND, UINT, WPARAM, LPARAM);
#define OutTraceW if(dxw.dwTFlags & OUTWINMESSAGES) OutTrace
#define OutTraceX if(dxw.dwTFlags & OUTPROXYTRACE) OutTrace
#define OutTraceD if(dxw.dwTFlags & OUTDDRAWTRACE) OutTrace
#define OutTraceDW if(dxw.dwTFlags & OUTDXWINTRACE) OutTrace
#define OutTraceDDRAW if(dxw.dwTFlags & OUTDDRAWTRACE) OutTrace
#define OutTraceD3D if(dxw.dwTFlags & OUTD3DTRACE) OutTrace
#define OutTraceC if(dxw.dwTFlags & OUTCURSORTRACE) OutTrace
#define OutTraceB if(dxw.dwTFlags & OUTDEBUG) OutTrace
#define OutTraceR if(dxw.dwTFlags & OUTREGISTRY) OutTrace
@ -216,7 +222,9 @@ LRESULT CALLBACK extWindowProc(HWND, UINT, WPARAM, LPARAM);
#define IsTraceW (dxw.dwTFlags & OUTWINMESSAGES)
#define IsTraceX (dxw.dwTFlags & OUTPROXYTRACE)
#define IsTraceD (dxw.dwTFlags & OUTDDRAWTRACE)
#define IsTraceDW (dxw.dwTFlags & OUTDXWINTRACE)
#define IsTraceDDRAW (dxw.dwTFlags & OUTDDRAWTRACE)
#define IsTraceD3D (dxw.dwTFlags & OUTD3DTRACE)
#define IsTraceC (dxw.dwTFlags & OUTCURSORTRACE)
#define IsTraceR (dxw.dwTFlags & OUTREGISTRY)
#define IsTraceH (dxw.dwTFlags & TRACEHOOKS)

3
build/d3d9.dll Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:bbba59e9978c6b6bbab608afb2d58ca5946c5a5dd80760539334f53b7f42f2ef
size 108544

4
build/dxwnd.dll
View File

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:57ef9c7d9946325fb6dd60e4af9dc304c495324ecae9a692cf86f91992cebbfb
size 431616
oid sha256:86344285657229fd81bf32b0431d3b4834a62cf91d50f521dd84035670bd8c9d
size 435200

4
build/dxwnd.exe
View File

@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:0a4a4d772a6ec7426fd16e1891cfb4b0bc0f853cbb5a6cdcaa080f131bdd340e
size 531968
oid sha256:344f365f6f431bb76c4c42f14654160bdc40c065462b4c8c45a0f3c2ab266a70
size 533504

1245
build/dxwnd.ini
View File

File diff suppressed because it is too large Load Diff

BIN
build/dxwnd_manual.pdf
View File

Binary file not shown.

24
build/exports/KnightShift.dxw Normal file
View File

@ -0,0 +1,24 @@
[target]
title0=KnightShift
path0=D:\Games\knightshift\KnightShift.ex1
module0=
opengllib0=
ver0=8
coord0=0
flag0=134217760
flagg0=1207959552
flagh0=20
flagi0=4
tflag0=3
initx0=0
inity0=0
minx0=0
miny0=0
maxx0=0
maxy0=0
posx0=50
posy0=50
sizx0=800
sizy0=600
maxfps0=0
initts0=0

24
build/exports/Knights Of Honor.dxw Normal file
View File

@ -0,0 +1,24 @@
[target]
title0=Knights Of Honor
path0=D:\Games\Knights Of Honor\KoH.exe
module0=
opengllib0=
ver0=0
coord0=0
flag0=-402382814
flagg0=1207959552
flagh0=65556
flagi0=4
tflag0=6431
initx0=0
inity0=0
minx0=0
miny0=0
maxx0=0
maxy0=0
posx0=50
posy0=50
sizx0=800
sizy0=600
maxfps0=0
initts0=0

24
build/exports/Kohan II Kings of War.dxw Normal file
View File

@ -0,0 +1,24 @@
[target]
title0=Kohan II Kings of War
path0=D:\Games\Kohan II Kings of War\k2.exe
module0=
opengllib0=
ver0=9
coord0=0
flag0=134217762
flagg0=1207959552
flagh0=20
flagi0=1028
tflag0=6163
initx0=0
inity0=0
minx0=0
miny0=0
maxx0=0
maxy0=0
posx0=50
posy0=50
sizx0=800
sizy0=600
maxfps0=0
initts0=0

24
build/exports/Lost Valley.dxw Normal file
View File

@ -0,0 +1,24 @@
[target]
title0=Lost Valley
path0=D:\Games\Lost Valley\lost valley\lost valley data.exe
module0=
opengllib0=
ver0=0
coord0=0
flag0=142614562
flagg0=1207959552
flagh0=-2071986156
flagi0=0
tflag0=0
initx0=0
inity0=0
minx0=0
miny0=0
maxx0=0
maxy0=0
posx0=50
posy0=50
sizx0=800
sizy0=600
maxfps0=0
initts0=0

14
build/exports/Empire Earth.dxw → build/exports/Project IGI.dxw
View File

@ -1,15 +1,15 @@
[target]
title0=Empire Earth
path0=D:\Games\Empire Earth\Empire Earth.exe
title0=Project IGI
path0=D:\Games\Project IGI\pc\IGI.exe
module0=
opengllib0=
ver0=0
coord0=0
flag0=1744847009
flagg0=201326608
flagh0=65620
flagi0=0
tflag0=23
flag0=671105060
flagg0=-939524096
flagh0=20
flagi0=4
tflag0=67
initx0=0
inity0=0
minx0=0

24
build/exports/State of Emergency.dxw Normal file
View File

@ -0,0 +1,24 @@
[target]
title0=State of Emergency
path0=D:\Games\State of Emergency\KaosPC.exe
module0=
opengllib0=
ver0=8
coord0=0
flag0=671088676
flagg0=1207959552
flagh0=20
flagi0=4
tflag0=7315
initx0=0
inity0=0
minx0=0
miny0=0
maxx0=0
maxy0=0
posx0=50
posy0=50
sizx0=800
sizy0=600
maxfps0=0
initts0=0

24
build/exports/Take no Prisoners.dxw Normal file
View File

@ -0,0 +1,24 @@
[target]
title0=Take no Prisoners
path0=D:\Games\Take no Prisoners\TNP.EXE
module0=
opengllib0=
ver0=0
coord0=0
flag0=134217762
flagg0=134217860
flagh0=20
flagi0=512
tflag0=259
initx0=0
inity0=0
minx0=0
miny0=0
maxx0=0
maxy0=0
posx0=50
posy0=50
sizx0=800
sizy0=600
maxfps0=0
initts0=0

24
build/exports/Worms Pinball.dxw Normal file
View File

@ -0,0 +1,24 @@
[target]
title0=Worms Pinball
path0=D:\Games\Worms Pinball\WPIB.exe
module0=
opengllib0=
ver0=1
coord0=0
flag0=134217762
flagg0=1207959568
flagh0=20
flagi0=4
tflag0=0
initx0=0
inity0=0
minx0=0
miny0=0
maxx0=0
maxy0=0
posx0=50
posy0=50
sizx0=800
sizy0=600
maxfps0=0
initts0=0

4
build/issues.txt
View File

@ -1,4 +0,0 @@
Ancient Evil: working both in emulated / direct mode, but in emulated mode the cursor is not visible.
window handling for ddraw8 games - see WildFire with keep aspect ratio & client area
"devastation" intro movie - bad cooordinates
Praetorians: bad splash screen & crash

15
build/readme-relnotes.txt
View File

@ -323,4 +323,17 @@ Clean ZBUFFER @0.0 fix: to fix "Crimson Skies" black blocks bug on ATI cards
v2.02.48
New options: "Disable fogging", "Textures not power of 2 fix"
A few fix to prevent game crashes
A few fix to prevent game crashes
v2.02.49
Separated ddraw, d3d and dxwnd log messages
Hooked GetAvailableVidMem method to limit memory values
Hooked ChangeDisplaySettings call in both versions ANSI and WIDECHAR, to prevent messing up with the screen
Added HookWindowProc() subroutine, called at dxhook.c@1534
Added "Add proxy libs" flag - so far to copy a d3d9.dll proxy lib to fix d3d9 games
Hooked d3d8/9 SetCursorPosition method
Hooked d3d8/9 AddRef / release methods (for logging)
Fixed D3DDevice8/9 hooking
Hooked QueryPerformanceFrequency
Fixed a bug in d3d7 hooking
GUI: added desktop cplor setting

1667
d3d9proxy/d3d9.h Normal file
View File

File diff suppressed because it is too large Load Diff

71
d3d9proxy/d3dx9.h Normal file
View File

@ -0,0 +1,71 @@
//////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) Microsoft Corporation. All Rights Reserved.
//
// File: d3dx9.h
// Content: D3DX utility library
//
//////////////////////////////////////////////////////////////////////////////
#ifdef __D3DX_INTERNAL__
#error Incorrect D3DX header used
#endif
#ifndef __D3DX9_H__
#define __D3DX9_H__
// Defines
#include <limits.h>
#define D3DX_DEFAULT ((UINT) -1)
#define D3DX_DEFAULT_NONPOW2 ((UINT) -2)
#define D3DX_DEFAULT_FLOAT FLT_MAX
#ifndef D3DXINLINE
#ifdef _MSC_VER
#if (_MSC_VER >= 1200)
#define D3DXINLINE __forceinline
#else
#define D3DXINLINE __inline
#endif
#else
#ifdef __cplusplus
#define D3DXINLINE inline
#else
#define D3DXINLINE
#endif
#endif
#endif
// Includes
#include "d3d9.h"
#include "d3dx9math.h"
#include "d3dx9core.h"
#include "d3dx9mesh.h"
#include "d3dx9tex.h"
#include "d3dx9shader.h"
#include "d3dx9effect.h"
#include "d3dx9shape.h"
#include "d3dx9anim.h"
// Errors
#define _FACDD 0x876
#define MAKE_DDHRESULT( code ) MAKE_HRESULT( 1, _FACDD, code )
enum _D3DXERR {
D3DXERR_CANNOTMODIFYINDEXBUFFER = MAKE_DDHRESULT(2900),
D3DXERR_INVALIDMESH = MAKE_DDHRESULT(2901),
D3DXERR_CANNOTATTRSORT = MAKE_DDHRESULT(2902),
D3DXERR_SKINNINGNOTSUPPORTED = MAKE_DDHRESULT(2903),
D3DXERR_TOOMANYINFLUENCES = MAKE_DDHRESULT(2904),
D3DXERR_INVALIDDATA = MAKE_DDHRESULT(2905),
D3DXERR_LOADEDMESHASNODATA = MAKE_DDHRESULT(2906),
D3DXERR_DUPLICATENAMEDFRAGMENT = MAKE_DDHRESULT(2907),
};
#endif //__D3DX9_H__

BIN
d3d9proxy/d3dx9.lib Normal file
View File

Binary file not shown.

154
d3d9proxy/myIDirect3D9.cpp Normal file
View File

@ -0,0 +1,154 @@
// myIDirect3D9.cpp
#include "StdAfx.h"
#include "stdio.h"
#define trace if(log) fprintf
extern FILE *log;
myIDirect3D9::myIDirect3D9(IDirect3D9 *pOriginal)
{
m_pIDirect3D9 = pOriginal;
}
myIDirect3D9::~myIDirect3D9(void)
{
}
HRESULT __stdcall myIDirect3D9::QueryInterface(REFIID riid, void** ppvObj)
{
*ppvObj = NULL;
// call this to increase AddRef at original object
// and to check if such an interface is there
HRESULT hRes = m_pIDirect3D9->QueryInterface(riid, ppvObj);
if (hRes == NOERROR) // if OK, send our "fake" address
{
*ppvObj = this;
}
return hRes;
}
ULONG __stdcall myIDirect3D9::AddRef(void)
{
return(m_pIDirect3D9->AddRef());
}
ULONG __stdcall myIDirect3D9::Release(void)
{
extern myIDirect3D9* gl_pmyIDirect3D9;
// call original routine
ULONG count = m_pIDirect3D9->Release();
// in case no further Ref is there, the Original Object has deleted itself
// so do we here
if (count == 0){
gl_pmyIDirect3D9 = NULL;
delete(this);
}
return(count);
}
HRESULT __stdcall myIDirect3D9::RegisterSoftwareDevice(void* pInitializeFunction)
{
trace(log, "IDirect3D9::RegisterSoftwareDevice\n");
return(m_pIDirect3D9->RegisterSoftwareDevice(pInitializeFunction));
}
UINT __stdcall myIDirect3D9::GetAdapterCount(void)
{
trace(log, "IDirect3D9::GetAdapterCount\n");
return(m_pIDirect3D9->GetAdapterCount());
}
HRESULT __stdcall myIDirect3D9::GetAdapterIdentifier(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier)
{
trace(log, "IDirect3D9::GetAdapterIdentifier\n");
return(m_pIDirect3D9->GetAdapterIdentifier(Adapter,Flags,pIdentifier));
}
UINT __stdcall myIDirect3D9::GetAdapterModeCount(UINT Adapter, D3DFORMAT Format)
{
trace(log, "IDirect3D9::GetAdapterModeCount\n");
return(m_pIDirect3D9->GetAdapterModeCount(Adapter, Format));
}
HRESULT __stdcall myIDirect3D9::EnumAdapterModes(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode)
{
trace(log, "IDirect3D9::EnumAdapterModes\n");
return(m_pIDirect3D9->EnumAdapterModes(Adapter,Format,Mode,pMode));
}
HRESULT __stdcall myIDirect3D9::GetAdapterDisplayMode( UINT Adapter,D3DDISPLAYMODE* pMode)
{
trace(log, "IDirect3D9::GetAdapterDisplayMode\n");
return(m_pIDirect3D9->GetAdapterDisplayMode(Adapter,pMode));
}
HRESULT __stdcall myIDirect3D9::CheckDeviceType(UINT iAdapter,D3DDEVTYPE DevType,D3DFORMAT DisplayFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed)
{
trace(log, "IDirect3D9::CheckDeviceType\n");
return(m_pIDirect3D9->CheckDeviceType(iAdapter,DevType,DisplayFormat,BackBufferFormat,bWindowed));
}
HRESULT __stdcall myIDirect3D9::CheckDeviceFormat(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat)
{
trace(log, "IDirect3D9::CheckDeviceFormat\n");
return(m_pIDirect3D9->CheckDeviceFormat(Adapter,DeviceType,AdapterFormat,Usage,RType,CheckFormat));
}
HRESULT __stdcall myIDirect3D9::CheckDeviceMultiSampleType(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels)
{
trace(log, "IDirect3D9::CheckDeviceMultiSampleType\n");
return(m_pIDirect3D9->CheckDeviceMultiSampleType(Adapter,DeviceType,SurfaceFormat,Windowed,MultiSampleType,pQualityLevels));
}
HRESULT __stdcall myIDirect3D9::CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat)
{
trace(log, "IDirect3D9::CheckDepthStencilMatch\n");
return(m_pIDirect3D9->CheckDepthStencilMatch(Adapter,DeviceType,AdapterFormat,RenderTargetFormat,DepthStencilFormat));
}
HRESULT __stdcall myIDirect3D9::CheckDeviceFormatConversion(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SourceFormat,D3DFORMAT TargetFormat)
{
trace(log, "IDirect3D9::CheckDeviceFormatConversion\n");
return(m_pIDirect3D9->CheckDeviceFormatConversion(Adapter,DeviceType,SourceFormat,TargetFormat));
}
HRESULT __stdcall myIDirect3D9::GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps)
{
trace(log, "IDirect3D9::GetDeviceCaps\n");
return(m_pIDirect3D9->GetDeviceCaps(Adapter,DeviceType,pCaps));
}
HMONITOR __stdcall myIDirect3D9::GetAdapterMonitor(UINT Adapter)
{
trace(log, "IDirect3D9::GetAdapterMonitor\n");
return(m_pIDirect3D9->GetAdapterMonitor(Adapter));
}
HRESULT __stdcall myIDirect3D9::CreateDevice(UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface)
{
trace(log, "IDirect3D9::CreateDevice\n");
// global var
extern myIDirect3DDevice9* gl_pmyIDirect3DDevice9;
// we intercept this call and provide our own "fake" Device Object
HRESULT hres = m_pIDirect3D9->CreateDevice( Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface);
// Create our own Device object and store it in global pointer
// note: the object will delete itself once Ref count is zero (similar to COM objects)
gl_pmyIDirect3DDevice9 = new myIDirect3DDevice9(*ppReturnedDeviceInterface);
// store our pointer (the fake one) for returning it to the calling progam
*ppReturnedDeviceInterface = gl_pmyIDirect3DDevice9;
return(hres);
}

31
d3d9proxy/myIDirect3D9.h Normal file
View File

@ -0,0 +1,31 @@
#pragma once
class myIDirect3D9 : public IDirect3D9
{
public:
myIDirect3D9(IDirect3D9 *pOriginal);
virtual ~myIDirect3D9(void);
// The original DX9 function definitions
HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj);
ULONG __stdcall AddRef(void);
ULONG __stdcall Release(void);
HRESULT __stdcall RegisterSoftwareDevice(void* pInitializeFunction);
UINT __stdcall GetAdapterCount(void);
HRESULT __stdcall GetAdapterIdentifier(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier) ;
UINT __stdcall GetAdapterModeCount(UINT Adapter, D3DFORMAT Format);
HRESULT __stdcall EnumAdapterModes(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode) ;
HRESULT __stdcall GetAdapterDisplayMode( UINT Adapter,D3DDISPLAYMODE* pMode) ;
HRESULT __stdcall CheckDeviceType(UINT iAdapter,D3DDEVTYPE DevType,D3DFORMAT DisplayFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed) ;
HRESULT __stdcall CheckDeviceFormat(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat) ;
HRESULT __stdcall CheckDeviceMultiSampleType(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels) ;
HRESULT __stdcall CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat) ;
HRESULT __stdcall CheckDeviceFormatConversion(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SourceFormat,D3DFORMAT TargetFormat);
HRESULT __stdcall GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps) ;
HMONITOR __stdcall GetAdapterMonitor(UINT Adapter) ;
HRESULT __stdcall CreateDevice(UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface) ;
// The original DX9 function definitions
private:
IDirect3D9 *m_pIDirect3D9;
};

776
d3d9proxy/myIDirect3DDevice9.cpp Normal file
View File

@ -0,0 +1,776 @@
#include "StdAfx.h"
#include "myIDirect3DDevice9.h"
#include "stdio.h"
#define trace if(log) fprintf
extern FILE *log;
myIDirect3DDevice9::myIDirect3DDevice9(IDirect3DDevice9* pOriginal)
{
m_pIDirect3DDevice9 = pOriginal; // store the pointer to original object
}
myIDirect3DDevice9::~myIDirect3DDevice9(void)
{
}
HRESULT myIDirect3DDevice9::QueryInterface (REFIID riid, void** ppvObj)
{
trace(log, "IDirect3DDevice9::QueryInterface\n");
// check if original dll can provide interface. then send *our* address
*ppvObj = NULL;
HRESULT hRes = m_pIDirect3DDevice9->QueryInterface(riid, ppvObj);
if (hRes == NOERROR)
{
*ppvObj = this;
}
return hRes;
}
ULONG myIDirect3DDevice9::AddRef(void)
{
trace(log, "IDirect3DDevice9::AddRef\n");
return(m_pIDirect3DDevice9->AddRef());
}
ULONG myIDirect3DDevice9::Release(void)
{
trace(log, "IDirect3DDevice9::Release\n");
// ATTENTION: This is a booby-trap ! Watch out !
// If we create our own sprites, surfaces, etc. (thus increasing the ref counter
// by external action), we need to delete that objects before calling the original
// Release function
// global var
extern myIDirect3DDevice9* gl_pmyIDirect3DDevice9;
// release/delete own objects
// .....
// Calling original function now
ULONG count = m_pIDirect3DDevice9->Release();
// now, the Original Object has deleted itself, so do we here
if(count == 0){
gl_pmyIDirect3DDevice9 = NULL;
delete(this); // destructor will be called automatically
}
return (count);
}
HRESULT myIDirect3DDevice9::TestCooperativeLevel(void)
{
trace(log, "IDirect3DDevice9::TestCooperativeLevel\n");
return(m_pIDirect3DDevice9->TestCooperativeLevel());
}
UINT myIDirect3DDevice9::GetAvailableTextureMem(void)
{
trace(log, "IDirect3DDevice9::GetAvailableTextureMem\n");
return(m_pIDirect3DDevice9->GetAvailableTextureMem());
}
HRESULT myIDirect3DDevice9::EvictManagedResources(void)
{
trace(log, "IDirect3DDevice9::EvictManagedResources\n");
return(m_pIDirect3DDevice9->EvictManagedResources());
}
HRESULT myIDirect3DDevice9::GetDirect3D(IDirect3D9** ppD3D9)
{
trace(log, "IDirect3DDevice9::GetDirect3D\n");
return(m_pIDirect3DDevice9->GetDirect3D(ppD3D9));
}
HRESULT myIDirect3DDevice9::GetDeviceCaps(D3DCAPS9* pCaps)
{
trace(log, "IDirect3DDevice9::GetDeviceCaps\n");
return(m_pIDirect3DDevice9->GetDeviceCaps(pCaps));
}
HRESULT myIDirect3DDevice9::GetDisplayMode(UINT iSwapChain,D3DDISPLAYMODE* pMode)
{
trace(log, "IDirect3DDevice9::GetDisplayMode\n");
return(m_pIDirect3DDevice9->GetDisplayMode(iSwapChain, pMode));
}
HRESULT myIDirect3DDevice9::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters)
{
trace(log, "IDirect3DDevice9::GetCreationParameters\n");
return(m_pIDirect3DDevice9->GetCreationParameters(pParameters));
}
HRESULT myIDirect3DDevice9::SetCursorProperties(UINT XHotSpot,UINT YHotSpot,IDirect3DSurface9* pCursorBitmap)
{
trace(log, "IDirect3DDevice9::SetCursorProperties\n");
return(m_pIDirect3DDevice9->SetCursorProperties(XHotSpot,YHotSpot,pCursorBitmap));
}
void myIDirect3DDevice9::SetCursorPosition(int X,int Y,DWORD Flags)
{
trace(log, "IDirect3DDevice9::SetCursorPosition\n");
return(m_pIDirect3DDevice9->SetCursorPosition(X,Y,Flags));
}
BOOL myIDirect3DDevice9::ShowCursor(BOOL bShow)
{
trace(log, "IDirect3DDevice9::ShowCursor\n");
return(m_pIDirect3DDevice9->ShowCursor(bShow));
}
HRESULT myIDirect3DDevice9::CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain9** pSwapChain)
{
trace(log, "IDirect3DDevice9::CreateAdditionalSwapChain\n");
return(m_pIDirect3DDevice9->CreateAdditionalSwapChain(pPresentationParameters,pSwapChain));
}
HRESULT myIDirect3DDevice9::GetSwapChain(UINT iSwapChain,IDirect3DSwapChain9** pSwapChain)
{
trace(log, "IDirect3DDevice9::GetSwapChain\n");
return(m_pIDirect3DDevice9->GetSwapChain(iSwapChain,pSwapChain));
}
UINT myIDirect3DDevice9::GetNumberOfSwapChains(void)
{
trace(log, "IDirect3DDevice9::GetNumberOfSwapChains\n");
return(m_pIDirect3DDevice9->GetNumberOfSwapChains());
}
HRESULT myIDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParameters)
{
trace(log, "IDirect3DDevice9::Reset\n");
return(m_pIDirect3DDevice9->Reset(pPresentationParameters));
}
HRESULT myIDirect3DDevice9::Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion)
{
trace(log, "IDirect3DDevice9::Present\n");
// we may want to draw own things here before flipping surfaces
// ... draw own stuff ...
// this->ShowWeAreHere();
// call original routine
HRESULT hres = m_pIDirect3DDevice9->Present( pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
return (hres);
}
HRESULT myIDirect3DDevice9::GetBackBuffer(UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer)
{
trace(log, "IDirect3DDevice9::GetBackBuffer\n");
return(m_pIDirect3DDevice9->GetBackBuffer(iSwapChain,iBackBuffer,Type,ppBackBuffer));
}
HRESULT myIDirect3DDevice9::GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus)
{
trace(log, "IDirect3DDevice9::GetRasterStatus\n");
return(m_pIDirect3DDevice9->GetRasterStatus(iSwapChain,pRasterStatus));
}
HRESULT myIDirect3DDevice9::SetDialogBoxMode(BOOL bEnableDialogs)
{
trace(log, "IDirect3DDevice9::SetDialogBoxMode\n");
return(m_pIDirect3DDevice9->SetDialogBoxMode(bEnableDialogs));
}
void myIDirect3DDevice9::SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp)
{
trace(log, "IDirect3DDevice9::SetGammaRamp\n");
return(m_pIDirect3DDevice9->SetGammaRamp(iSwapChain,Flags,pRamp));
}
void myIDirect3DDevice9::GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp)
{
trace(log, "IDirect3DDevice9::GetGammaRamp\n");
return(m_pIDirect3DDevice9->GetGammaRamp(iSwapChain,pRamp));
}
HRESULT myIDirect3DDevice9::CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,HANDLE* pSharedHandle)
{
trace(log, "IDirect3DDevice9::CreateTexture\n");
return(m_pIDirect3DDevice9->CreateTexture(Width,Height,Levels,Usage,Format,Pool,ppTexture,pSharedHandle));
}
HRESULT myIDirect3DDevice9::CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,HANDLE* pSharedHandle)
{
trace(log, "IDirect3DDevice9::CreateVolumeTexture\n");
return(m_pIDirect3DDevice9->CreateVolumeTexture(Width,Height,Depth,Levels,Usage,Format,Pool,ppVolumeTexture,pSharedHandle));
}
HRESULT myIDirect3DDevice9::CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,HANDLE* pSharedHandle)
{
trace(log, "IDirect3DDevice9::CreateCubeTexture\n");
return(m_pIDirect3DDevice9->CreateCubeTexture(EdgeLength,Levels,Usage,Format,Pool,ppCubeTexture,pSharedHandle));
}
HRESULT myIDirect3DDevice9::CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,HANDLE* pSharedHandle)
{
trace(log, "IDirect3DDevice9::CreateVertexBuffer\n");
return(m_pIDirect3DDevice9->CreateVertexBuffer(Length,Usage,FVF,Pool,ppVertexBuffer,pSharedHandle));
}
HRESULT myIDirect3DDevice9::CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE* pSharedHandle)
{
trace(log, "IDirect3DDevice9::CreateIndexBuffer\n");
return(m_pIDirect3DDevice9->CreateIndexBuffer(Length,Usage,Format,Pool,ppIndexBuffer,pSharedHandle));
}
HRESULT myIDirect3DDevice9::CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
{
trace(log, "IDirect3DDevice9::CreateRenderTarget\n");
return(m_pIDirect3DDevice9->CreateRenderTarget(Width,Height,Format,MultiSample,MultisampleQuality,Lockable,ppSurface,pSharedHandle));
}
HRESULT myIDirect3DDevice9::CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
{
trace(log, "IDirect3DDevice9::CreateDepthStencilSurface\n");
return(m_pIDirect3DDevice9->CreateDepthStencilSurface(Width,Height,Format,MultiSample,MultisampleQuality,Discard,ppSurface,pSharedHandle));
}
HRESULT myIDirect3DDevice9::UpdateSurface(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestinationSurface,CONST POINT* pDestPoint)
{
trace(log, "IDirect3DDevice9::UpdateSurface\n");
return(m_pIDirect3DDevice9->UpdateSurface(pSourceSurface,pSourceRect,pDestinationSurface,pDestPoint));
}
HRESULT myIDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9* pSourceTexture,IDirect3DBaseTexture9* pDestinationTexture)
{
trace(log, "IDirect3DDevice9::UpdateTexture\n");
return(m_pIDirect3DDevice9->UpdateTexture(pSourceTexture,pDestinationTexture));
}
HRESULT myIDirect3DDevice9::GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface)
{
trace(log, "IDirect3DDevice9::GetRenderTargetData\n");
return(m_pIDirect3DDevice9->GetRenderTargetData(pRenderTarget,pDestSurface));
}
HRESULT myIDirect3DDevice9::GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface)
{
trace(log, "IDirect3DDevice9::GetFrontBufferData\n");
return(m_pIDirect3DDevice9->GetFrontBufferData(iSwapChain,pDestSurface));
}
HRESULT myIDirect3DDevice9::StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter)
{
trace(log, "IDirect3DDevice9::StretchRect\n");
return(m_pIDirect3DDevice9->StretchRect(pSourceSurface,pSourceRect,pDestSurface,pDestRect,Filter));
}
HRESULT myIDirect3DDevice9::ColorFill(IDirect3DSurface9* pSurface,CONST RECT* pRect,D3DCOLOR color)
{
trace(log, "IDirect3DDevice9::ColorFill\n");
return(m_pIDirect3DDevice9->ColorFill(pSurface,pRect,color));
}
HRESULT myIDirect3DDevice9::CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
{
trace(log, "IDirect3DDevice9::CreateOffscreenPlainSurface\n");
return(m_pIDirect3DDevice9->CreateOffscreenPlainSurface(Width,Height,Format,Pool,ppSurface,pSharedHandle));
}
HRESULT myIDirect3DDevice9::SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget)
{
trace(log, "IDirect3DDevice9::SetRenderTarget\n");
return(m_pIDirect3DDevice9->SetRenderTarget(RenderTargetIndex,pRenderTarget));
}
HRESULT myIDirect3DDevice9::GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget)
{
trace(log, "IDirect3DDevice9::GetRenderTarget\n");
return(m_pIDirect3DDevice9->GetRenderTarget(RenderTargetIndex,ppRenderTarget));
}
HRESULT myIDirect3DDevice9::SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil)
{
trace(log, "IDirect3DDevice9::SetDepthStencilSurface\n");
return(m_pIDirect3DDevice9->SetDepthStencilSurface(pNewZStencil));
}
HRESULT myIDirect3DDevice9::GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface)
{
trace(log, "IDirect3DDevice9::GetDepthStencilSurface\n");
return(m_pIDirect3DDevice9->GetDepthStencilSurface(ppZStencilSurface));
}
HRESULT myIDirect3DDevice9::BeginScene(void)
{
trace(log, "IDirect3DDevice9::BeginScene\n");
return(m_pIDirect3DDevice9->BeginScene());
}
HRESULT myIDirect3DDevice9::EndScene(void)
{
trace(log, "IDirect3DDevice9::EndScene\n");
return(m_pIDirect3DDevice9->EndScene());
}
HRESULT myIDirect3DDevice9::Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil)
{
trace(log, "IDirect3DDevice9::Clear\n");
return(m_pIDirect3DDevice9->Clear(Count,pRects,Flags,Color,Z,Stencil));
}
HRESULT myIDirect3DDevice9::SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix)
{
trace(log, "IDirect3DDevice9::SetTransform\n");
return(m_pIDirect3DDevice9->SetTransform(State,pMatrix));
}
HRESULT myIDirect3DDevice9::GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix)
{
trace(log, "IDirect3DDevice9::GetTransform\n");
return(m_pIDirect3DDevice9->GetTransform(State,pMatrix));
}
HRESULT myIDirect3DDevice9::MultiplyTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix)
{
trace(log, "IDirect3DDevice9::MultiplyTransform\n");
return(m_pIDirect3DDevice9->MultiplyTransform(State,pMatrix));
}
HRESULT myIDirect3DDevice9::SetViewport(CONST D3DVIEWPORT9* pViewport)
{
trace(log, "IDirect3DDevice9::SetViewport\n");
return(m_pIDirect3DDevice9->SetViewport(pViewport));
}
HRESULT myIDirect3DDevice9::GetViewport(D3DVIEWPORT9* pViewport)
{
trace(log, "IDirect3DDevice9::GetViewport\n");
return(m_pIDirect3DDevice9->GetViewport(pViewport));
}
HRESULT myIDirect3DDevice9::SetMaterial(CONST D3DMATERIAL9* pMaterial)
{
trace(log, "IDirect3DDevice9::SetMaterial\n");
return(m_pIDirect3DDevice9->SetMaterial(pMaterial));
}
HRESULT myIDirect3DDevice9::GetMaterial(D3DMATERIAL9* pMaterial)
{
trace(log, "IDirect3DDevice9::GetMaterial\n");
return(m_pIDirect3DDevice9->GetMaterial(pMaterial));
}
HRESULT myIDirect3DDevice9::SetLight(DWORD Index,CONST D3DLIGHT9* pLight)
{
trace(log, "IDirect3DDevice9::SetLight\n");
return(m_pIDirect3DDevice9->SetLight(Index,pLight));
}
HRESULT myIDirect3DDevice9::GetLight(DWORD Index,D3DLIGHT9* pLight)
{
trace(log, "IDirect3DDevice9::GetLight\n");
return(m_pIDirect3DDevice9->GetLight(Index,pLight));
}
HRESULT myIDirect3DDevice9::LightEnable(DWORD Index,BOOL Enable)
{
trace(log, "IDirect3DDevice9::LightEnable\n");
return(m_pIDirect3DDevice9->LightEnable(Index,Enable));
}
HRESULT myIDirect3DDevice9::GetLightEnable(DWORD Index,BOOL* pEnable)
{
trace(log, "IDirect3DDevice9::GetLightEnable\n");
return(m_pIDirect3DDevice9->GetLightEnable(Index, pEnable));
}
HRESULT myIDirect3DDevice9::SetClipPlane(DWORD Index,CONST float* pPlane)
{
trace(log, "IDirect3DDevice9::SetClipPlane\n");
return(m_pIDirect3DDevice9->SetClipPlane(Index, pPlane));
}
HRESULT myIDirect3DDevice9::GetClipPlane(DWORD Index,float* pPlane)
{
trace(log, "IDirect3DDevice9::GetClipPlane\n");
return(m_pIDirect3DDevice9->GetClipPlane(Index,pPlane));
}
HRESULT myIDirect3DDevice9::SetRenderState(D3DRENDERSTATETYPE State,DWORD Value)
{
//trace(log, "IDirect3DDevice9::SetRenderState\n");
return(m_pIDirect3DDevice9->SetRenderState(State, Value));
}
HRESULT myIDirect3DDevice9::GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue)
{
trace(log, "IDirect3DDevice9::GetRenderState\n");
return(m_pIDirect3DDevice9->GetRenderState(State, pValue));
}
HRESULT myIDirect3DDevice9::CreateStateBlock(D3DSTATEBLOCKTYPE Type,IDirect3DStateBlock9** ppSB)
{
trace(log, "IDirect3DDevice9::CreateStateBlock\n");
return(m_pIDirect3DDevice9->CreateStateBlock(Type,ppSB));
}
HRESULT myIDirect3DDevice9::BeginStateBlock(void)
{
trace(log, "IDirect3DDevice9::BeginStateBlock\n");
return(m_pIDirect3DDevice9->BeginStateBlock());
}
HRESULT myIDirect3DDevice9::EndStateBlock(IDirect3DStateBlock9** ppSB)
{
trace(log, "IDirect3DDevice9::EndStateBlock\n");
return(m_pIDirect3DDevice9->EndStateBlock(ppSB));
}
HRESULT myIDirect3DDevice9::SetClipStatus(CONST D3DCLIPSTATUS9* pClipStatus)
{
trace(log, "IDirect3DDevice9::SetClipStatus\n");
return(m_pIDirect3DDevice9->SetClipStatus(pClipStatus));
}
HRESULT myIDirect3DDevice9::GetClipStatus(D3DCLIPSTATUS9* pClipStatus)
{
trace(log, "IDirect3DDevice9::GetClipStatus\n");
return(m_pIDirect3DDevice9->GetClipStatus( pClipStatus));
}
HRESULT myIDirect3DDevice9::GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture)
{
trace(log, "IDirect3DDevice9::GetTexture\n");
return(m_pIDirect3DDevice9->GetTexture(Stage,ppTexture));
}
HRESULT myIDirect3DDevice9::SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture)
{
trace(log, "IDirect3DDevice9::SetTexture\n");
return(m_pIDirect3DDevice9->SetTexture(Stage,pTexture));
}
HRESULT myIDirect3DDevice9::GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue)
{
trace(log, "IDirect3DDevice9::GetTextureStageState\n");
return(m_pIDirect3DDevice9->GetTextureStageState(Stage,Type, pValue));
}
HRESULT myIDirect3DDevice9::SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value)
{
trace(log, "IDirect3DDevice9::SetTextureStageState\n");
return(m_pIDirect3DDevice9->SetTextureStageState(Stage,Type,Value));
}
HRESULT myIDirect3DDevice9::GetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue)
{
trace(log, "IDirect3DDevice9::GetSamplerState\n");
return(m_pIDirect3DDevice9->GetSamplerState(Sampler,Type, pValue));
}
HRESULT myIDirect3DDevice9::SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value)
{
trace(log, "IDirect3DDevice9::SetSamplerState\n");
return(m_pIDirect3DDevice9->SetSamplerState(Sampler,Type,Value));
}
HRESULT myIDirect3DDevice9::ValidateDevice(DWORD* pNumPasses)
{
trace(log, "IDirect3DDevice9::ValidateDevice\n");
return(m_pIDirect3DDevice9->ValidateDevice( pNumPasses));
}
HRESULT myIDirect3DDevice9::SetPaletteEntries(UINT PaletteNumber,CONST PALETTEENTRY* pEntries)
{
trace(log, "IDirect3DDevice9::SetPaletteEntries\n");
return(m_pIDirect3DDevice9->SetPaletteEntries(PaletteNumber, pEntries));
}
HRESULT myIDirect3DDevice9::GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries)
{
trace(log, "IDirect3DDevice9::GetPaletteEntries\n");
return(m_pIDirect3DDevice9->GetPaletteEntries(PaletteNumber, pEntries));
}
HRESULT myIDirect3DDevice9::SetCurrentTexturePalette(UINT PaletteNumber)
{
trace(log, "IDirect3DDevice9::SetCurrentTexturePalette\n");
return(m_pIDirect3DDevice9->SetCurrentTexturePalette(PaletteNumber));
}
HRESULT myIDirect3DDevice9::GetCurrentTexturePalette(UINT *PaletteNumber)
{
trace(log, "IDirect3DDevice9::GetCurrentTexturePalette\n");
return(m_pIDirect3DDevice9->GetCurrentTexturePalette(PaletteNumber));
}
HRESULT myIDirect3DDevice9::SetScissorRect(CONST RECT* pRect)
{
trace(log, "IDirect3DDevice9::SetScissorRect\n");
return(m_pIDirect3DDevice9->SetScissorRect( pRect));
}
HRESULT myIDirect3DDevice9::GetScissorRect( RECT* pRect)
{
trace(log, "IDirect3DDevice9::GetScissorRect\n");
return(m_pIDirect3DDevice9->GetScissorRect( pRect));
}
HRESULT myIDirect3DDevice9::SetSoftwareVertexProcessing(BOOL bSoftware)
{
trace(log, "IDirect3DDevice9::SetSoftwareVertexProcessing\n");
return(m_pIDirect3DDevice9->SetSoftwareVertexProcessing(bSoftware));
}
BOOL myIDirect3DDevice9::GetSoftwareVertexProcessing(void)
{
trace(log, "IDirect3DDevice9::GetSoftwareVertexProcessing\n");
return(m_pIDirect3DDevice9->GetSoftwareVertexProcessing());
}
HRESULT myIDirect3DDevice9::SetNPatchMode(float nSegments)
{
trace(log, "IDirect3DDevice9::SetNPatchMode\n");
return(m_pIDirect3DDevice9->SetNPatchMode(nSegments));
}
float myIDirect3DDevice9::GetNPatchMode(void)
{
trace(log, "IDirect3DDevice9::GetNPatchMode\n");
return(m_pIDirect3DDevice9->GetNPatchMode());
}
HRESULT myIDirect3DDevice9::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount)
{
trace(log, "IDirect3DDevice9::DrawPrimitive\n");
return(m_pIDirect3DDevice9->DrawPrimitive(PrimitiveType,StartVertex,PrimitiveCount));
}
HRESULT myIDirect3DDevice9::DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount)
{
trace(log, "IDirect3DDevice9::DrawIndexedPrimitive\n");
return(m_pIDirect3DDevice9->DrawIndexedPrimitive(PrimitiveType,BaseVertexIndex,MinVertexIndex,NumVertices,startIndex,primCount));
}
HRESULT myIDirect3DDevice9::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
{
trace(log, "IDirect3DDevice9::DrawPrimitiveUP\n");
return(m_pIDirect3DDevice9->DrawPrimitiveUP(PrimitiveType,PrimitiveCount,pVertexStreamZeroData,VertexStreamZeroStride));
}
HRESULT myIDirect3DDevice9::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
{
trace(log, "IDirect3DDevice9::DrawIndexedPrimitiveUP\n");
return(m_pIDirect3DDevice9->DrawIndexedPrimitiveUP(PrimitiveType,MinVertexIndex,NumVertices,PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData,VertexStreamZeroStride));
}
HRESULT myIDirect3DDevice9::ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer9* pDestBuffer,IDirect3DVertexDeclaration9* pVertexDecl,DWORD Flags)
{
trace(log, "IDirect3DDevice9::ProcessVertices\n");
return(m_pIDirect3DDevice9->ProcessVertices( SrcStartIndex, DestIndex, VertexCount, pDestBuffer, pVertexDecl, Flags));
}
HRESULT myIDirect3DDevice9::CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl)
{
trace(log, "IDirect3DDevice9::CreateVertexDeclaration\n");
return(m_pIDirect3DDevice9->CreateVertexDeclaration( pVertexElements,ppDecl));
}
HRESULT myIDirect3DDevice9::SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl)
{
trace(log, "IDirect3DDevice9::SetVertexDeclaration\n");
return(m_pIDirect3DDevice9->SetVertexDeclaration(pDecl));
}
HRESULT myIDirect3DDevice9::GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl)
{
trace(log, "IDirect3DDevice9::GetVertexDeclaration\n");
return(m_pIDirect3DDevice9->GetVertexDeclaration(ppDecl));
}
HRESULT myIDirect3DDevice9::SetFVF(DWORD FVF)
{
trace(log, "IDirect3DDevice9::SetFVF\n");
return(m_pIDirect3DDevice9->SetFVF(FVF));
}
HRESULT myIDirect3DDevice9::GetFVF(DWORD* pFVF)
{
trace(log, "IDirect3DDevice9::GetFVF\n");
return(m_pIDirect3DDevice9->GetFVF(pFVF));
}
HRESULT myIDirect3DDevice9::CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader)
{
trace(log, "IDirect3DDevice9::CreateVertexShader\n");
return(m_pIDirect3DDevice9->CreateVertexShader(pFunction,ppShader));
}
HRESULT myIDirect3DDevice9::SetVertexShader(IDirect3DVertexShader9* pShader)
{
trace(log, "IDirect3DDevice9::SetVertexShader\n");
return(m_pIDirect3DDevice9->SetVertexShader(pShader));
}
HRESULT myIDirect3DDevice9::GetVertexShader(IDirect3DVertexShader9** ppShader)
{
trace(log, "IDirect3DDevice9::GetVertexShader\n");
return(m_pIDirect3DDevice9->GetVertexShader(ppShader));
}
HRESULT myIDirect3DDevice9::SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
{
trace(log, "IDirect3DDevice9::SetVertexShaderConstantF\n");
return(m_pIDirect3DDevice9->SetVertexShaderConstantF(StartRegister,pConstantData, Vector4fCount));
}
HRESULT myIDirect3DDevice9::GetVertexShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount)
{
trace(log, "IDirect3DDevice9::GetVertexShaderConstantF\n");
return(m_pIDirect3DDevice9->GetVertexShaderConstantF(StartRegister,pConstantData,Vector4fCount));
}
HRESULT myIDirect3DDevice9::SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
{
trace(log, "IDirect3DDevice9::SetVertexShaderConstantI\n");
return(m_pIDirect3DDevice9->SetVertexShaderConstantI(StartRegister,pConstantData,Vector4iCount));
}
HRESULT myIDirect3DDevice9::GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
{
trace(log, "IDirect3DDevice9::GetVertexShaderConstantI\n");
return(m_pIDirect3DDevice9->GetVertexShaderConstantI(StartRegister,pConstantData,Vector4iCount));
}
HRESULT myIDirect3DDevice9::SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount)
{
trace(log, "IDirect3DDevice9::SetVertexShaderConstantB\n");
return(m_pIDirect3DDevice9->SetVertexShaderConstantB(StartRegister,pConstantData,BoolCount));
}
HRESULT myIDirect3DDevice9::GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
{
trace(log, "IDirect3DDevice9::GetVertexShaderConstantB\n");
return(m_pIDirect3DDevice9->GetVertexShaderConstantB(StartRegister,pConstantData,BoolCount));
}
HRESULT myIDirect3DDevice9::SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride)
{
trace(log, "IDirect3DDevice9::SetStreamSource\n");
return(m_pIDirect3DDevice9->SetStreamSource(StreamNumber,pStreamData,OffsetInBytes,Stride));
}
HRESULT myIDirect3DDevice9::GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9** ppStreamData,UINT* OffsetInBytes,UINT* pStride)
{
trace(log, "IDirect3DDevice9::GetStreamSource\n");
return(m_pIDirect3DDevice9->GetStreamSource(StreamNumber,ppStreamData,OffsetInBytes,pStride));
}
HRESULT myIDirect3DDevice9::SetStreamSourceFreq(UINT StreamNumber,UINT Divider)
{
trace(log, "IDirect3DDevice9::SetStreamSourceFreq\n");
return(m_pIDirect3DDevice9->SetStreamSourceFreq(StreamNumber,Divider));
}
HRESULT myIDirect3DDevice9::GetStreamSourceFreq(UINT StreamNumber,UINT* Divider)
{
trace(log, "IDirect3DDevice9::GetStreamSourceFreq\n");
return(m_pIDirect3DDevice9->GetStreamSourceFreq(StreamNumber,Divider));
}
HRESULT myIDirect3DDevice9::SetIndices(IDirect3DIndexBuffer9* pIndexData)
{
trace(log, "IDirect3DDevice9::SetIndices\n");
return(m_pIDirect3DDevice9->SetIndices(pIndexData));
}
HRESULT myIDirect3DDevice9::GetIndices(IDirect3DIndexBuffer9** ppIndexData)
{
trace(log, "IDirect3DDevice9::GetIndices\n");
return(m_pIDirect3DDevice9->GetIndices(ppIndexData));
}
HRESULT myIDirect3DDevice9::CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader)
{
trace(log, "IDirect3DDevice9::CreatePixelShader\n");
return(m_pIDirect3DDevice9->CreatePixelShader(pFunction,ppShader));
}
HRESULT myIDirect3DDevice9::SetPixelShader(IDirect3DPixelShader9* pShader)
{
trace(log, "IDirect3DDevice9::SetPixelShader\n");
return(m_pIDirect3DDevice9->SetPixelShader(pShader));
}
HRESULT myIDirect3DDevice9::GetPixelShader(IDirect3DPixelShader9** ppShader)
{
trace(log, "IDirect3DDevice9::GetPixelShader\n");
return(m_pIDirect3DDevice9->GetPixelShader(ppShader));
}
HRESULT myIDirect3DDevice9::SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
{
trace(log, "IDirect3DDevice9::SetPixelShaderConstantF\n");
return(m_pIDirect3DDevice9->SetPixelShaderConstantF(StartRegister,pConstantData,Vector4fCount));
}
HRESULT myIDirect3DDevice9::GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount)
{
trace(log, "IDirect3DDevice9::GetPixelShaderConstantF\n");
return(m_pIDirect3DDevice9->GetPixelShaderConstantF(StartRegister,pConstantData,Vector4fCount));
}
HRESULT myIDirect3DDevice9::SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
{
trace(log, "IDirect3DDevice9::SetPixelShaderConstantI\n");
return(m_pIDirect3DDevice9->SetPixelShaderConstantI(StartRegister,pConstantData,Vector4iCount));
}
HRESULT myIDirect3DDevice9::GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
{
trace(log, "IDirect3DDevice9::GetPixelShaderConstantI\n");
return(m_pIDirect3DDevice9->GetPixelShaderConstantI(StartRegister,pConstantData,Vector4iCount));
}
HRESULT myIDirect3DDevice9::SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount)
{
trace(log, "IDirect3DDevice9::SetPixelShaderConstantB\n");
return(m_pIDirect3DDevice9->SetPixelShaderConstantB(StartRegister,pConstantData,BoolCount));
}
HRESULT myIDirect3DDevice9::GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
{
trace(log, "IDirect3DDevice9::GetPixelShaderConstantB\n");
return(m_pIDirect3DDevice9->GetPixelShaderConstantB(StartRegister,pConstantData,BoolCount));
}
HRESULT myIDirect3DDevice9::DrawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo)
{
trace(log, "IDirect3DDevice9::DrawRectPatch\n");
return(m_pIDirect3DDevice9->DrawRectPatch(Handle,pNumSegs, pRectPatchInfo));
}
HRESULT myIDirect3DDevice9::DrawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo)
{
trace(log, "IDirect3DDevice9::DrawTriPatch\n");
return(m_pIDirect3DDevice9->DrawTriPatch(Handle, pNumSegs, pTriPatchInfo));
}
HRESULT myIDirect3DDevice9::DeletePatch(UINT Handle)
{
trace(log, "IDirect3DDevice9::DeletePatch\n");
return(m_pIDirect3DDevice9->DeletePatch(Handle));
}
HRESULT myIDirect3DDevice9::CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery)
{
trace(log, "IDirect3DDevice9::CreateQuery\n");
return(m_pIDirect3DDevice9->CreateQuery(Type,ppQuery));
}
// This is our test function
void myIDirect3DDevice9::ShowWeAreHere(void)
{
D3DRECT rec = {1,1,50,50};
m_pIDirect3DDevice9->Clear(1, &rec, D3DCLEAR_TARGET, D3DCOLOR_ARGB(255,255,255,0),0 ,0);
}

136
d3d9proxy/myIDirect3DDevice9.h Normal file
View File

@ -0,0 +1,136 @@
#pragma once
class myIDirect3DDevice9 : public IDirect3DDevice9
{
public:
myIDirect3DDevice9(IDirect3DDevice9* pOriginal);
virtual ~myIDirect3DDevice9(void);
// START: The original DX9 function definitions
HRESULT __stdcall QueryInterface (REFIID riid, void** ppvObj);
ULONG __stdcall AddRef(void);
ULONG __stdcall Release(void);
HRESULT __stdcall TestCooperativeLevel(void);
UINT __stdcall GetAvailableTextureMem(void);
HRESULT __stdcall EvictManagedResources(void);
HRESULT __stdcall GetDirect3D(IDirect3D9** ppD3D9);
HRESULT __stdcall GetDeviceCaps(D3DCAPS9* pCaps);
HRESULT __stdcall GetDisplayMode(UINT iSwapChain,D3DDISPLAYMODE* pMode);
HRESULT __stdcall GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters);
HRESULT __stdcall SetCursorProperties(UINT XHotSpot,UINT YHotSpot,IDirect3DSurface9* pCursorBitmap);
void __stdcall SetCursorPosition(int X,int Y,DWORD Flags);
BOOL __stdcall ShowCursor(BOOL bShow);
HRESULT __stdcall CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain9** pSwapChain) ;
HRESULT __stdcall GetSwapChain(UINT iSwapChain,IDirect3DSwapChain9** pSwapChain);
UINT __stdcall GetNumberOfSwapChains(void);
HRESULT __stdcall Reset(D3DPRESENT_PARAMETERS* pPresentationParameters);
HRESULT __stdcall Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion);
HRESULT __stdcall GetBackBuffer(UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer);
HRESULT __stdcall GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus);
HRESULT __stdcall SetDialogBoxMode(BOOL bEnableDialogs);
void __stdcall SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp);
void __stdcall GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp);
HRESULT __stdcall CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,HANDLE* pSharedHandle);
HRESULT __stdcall CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,HANDLE* pSharedHandle);
HRESULT __stdcall CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,HANDLE* pSharedHandle);
HRESULT __stdcall CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,HANDLE* pSharedHandle);
HRESULT __stdcall CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE* pSharedHandle);
HRESULT __stdcall CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle);
HRESULT __stdcall CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle);
HRESULT __stdcall UpdateSurface(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestinationSurface,CONST POINT* pDestPoint);
HRESULT __stdcall UpdateTexture(IDirect3DBaseTexture9* pSourceTexture,IDirect3DBaseTexture9* pDestinationTexture);
HRESULT __stdcall GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface);
HRESULT __stdcall GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface);
HRESULT __stdcall StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter);
HRESULT __stdcall ColorFill(IDirect3DSurface9* pSurface,CONST RECT* pRect,D3DCOLOR color);
HRESULT __stdcall CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle);
HRESULT __stdcall SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget);
HRESULT __stdcall GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget);
HRESULT __stdcall SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil);
HRESULT __stdcall GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface);
HRESULT __stdcall BeginScene(void);
HRESULT __stdcall EndScene(void);
HRESULT __stdcall Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil);
HRESULT __stdcall SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix);
HRESULT __stdcall GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix);
HRESULT __stdcall MultiplyTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix);
HRESULT __stdcall SetViewport(CONST D3DVIEWPORT9* pViewport);
HRESULT __stdcall GetViewport(D3DVIEWPORT9* pViewport);
HRESULT __stdcall SetMaterial(CONST D3DMATERIAL9* pMaterial);
HRESULT __stdcall GetMaterial(D3DMATERIAL9* pMaterial);
HRESULT __stdcall SetLight(DWORD Index,CONST D3DLIGHT9* pLight);
HRESULT __stdcall GetLight(DWORD Index,D3DLIGHT9* pLight);
HRESULT __stdcall LightEnable(DWORD Index,BOOL Enable);
HRESULT __stdcall GetLightEnable(DWORD Index,BOOL* pEnable);
HRESULT __stdcall SetClipPlane(DWORD Index,CONST float* pPlane);
HRESULT __stdcall GetClipPlane(DWORD Index,float* pPlane);
HRESULT __stdcall SetRenderState(D3DRENDERSTATETYPE State,DWORD Value);
HRESULT __stdcall GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue);
HRESULT __stdcall CreateStateBlock(D3DSTATEBLOCKTYPE Type,IDirect3DStateBlock9** ppSB);
HRESULT __stdcall BeginStateBlock(void);
HRESULT __stdcall EndStateBlock(IDirect3DStateBlock9** ppSB);
HRESULT __stdcall SetClipStatus(CONST D3DCLIPSTATUS9* pClipStatus);
HRESULT __stdcall GetClipStatus(D3DCLIPSTATUS9* pClipStatus);
HRESULT __stdcall GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture);
HRESULT __stdcall SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture);
HRESULT __stdcall GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue);
HRESULT __stdcall SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value);
HRESULT __stdcall GetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue);
HRESULT __stdcall SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value);
HRESULT __stdcall ValidateDevice(DWORD* pNumPasses);
HRESULT __stdcall SetPaletteEntries(UINT PaletteNumber,CONST PALETTEENTRY* pEntries);
HRESULT __stdcall GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries);
HRESULT __stdcall SetCurrentTexturePalette(UINT PaletteNumber);
HRESULT __stdcall GetCurrentTexturePalette(UINT *PaletteNumber);
HRESULT __stdcall SetScissorRect(CONST RECT* pRect);
HRESULT __stdcall GetScissorRect( RECT* pRect);
HRESULT __stdcall SetSoftwareVertexProcessing(BOOL bSoftware);
BOOL __stdcall GetSoftwareVertexProcessing(void);
HRESULT __stdcall SetNPatchMode(float nSegments);
float __stdcall GetNPatchMode(void);
HRESULT __stdcall DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount);
HRESULT __stdcall DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount);
HRESULT __stdcall DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride);
HRESULT __stdcall DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride);
HRESULT __stdcall ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer9* pDestBuffer,IDirect3DVertexDeclaration9* pVertexDecl,DWORD Flags);
HRESULT __stdcall CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl);
HRESULT __stdcall SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl);
HRESULT __stdcall GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl);
HRESULT __stdcall SetFVF(DWORD FVF);
HRESULT __stdcall GetFVF(DWORD* pFVF);
HRESULT __stdcall CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader);
HRESULT __stdcall SetVertexShader(IDirect3DVertexShader9* pShader);
HRESULT __stdcall GetVertexShader(IDirect3DVertexShader9** ppShader);
HRESULT __stdcall SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
HRESULT __stdcall GetVertexShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount);
HRESULT __stdcall SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
HRESULT __stdcall GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount);
HRESULT __stdcall SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount);
HRESULT __stdcall GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount);
HRESULT __stdcall SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride);
HRESULT __stdcall GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9** ppStreamData,UINT* OffsetInBytes,UINT* pStride);
HRESULT __stdcall SetStreamSourceFreq(UINT StreamNumber,UINT Divider);
HRESULT __stdcall GetStreamSourceFreq(UINT StreamNumber,UINT* Divider);
HRESULT __stdcall SetIndices(IDirect3DIndexBuffer9* pIndexData);
HRESULT __stdcall GetIndices(IDirect3DIndexBuffer9** ppIndexData);
HRESULT __stdcall CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader);
HRESULT __stdcall SetPixelShader(IDirect3DPixelShader9* pShader);
HRESULT __stdcall GetPixelShader(IDirect3DPixelShader9** ppShader);
HRESULT __stdcall SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
HRESULT __stdcall GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount);
HRESULT __stdcall SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
HRESULT __stdcall GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount);
HRESULT __stdcall SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount);
HRESULT __stdcall GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount);
HRESULT __stdcall DrawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo);
HRESULT __stdcall DrawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo);
HRESULT __stdcall DeletePatch(UINT Handle);
HRESULT __stdcall CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery);
// END: The original DX9 function definitions
private:
IDirect3DDevice9 *m_pIDirect3DDevice9;
// This is our test function
void ShowWeAreHere(void);
};

116
d3d9proxy/proxydll.cpp Normal file
View File

@ -0,0 +1,116 @@
// proxydll.cpp
#include "stdafx.h"
#include "proxydll.h"
#include "stdio.h"
// global variables
#pragma data_seg (".d3d9_shared")
myIDirect3DDevice9* gl_pmyIDirect3DDevice9;
myIDirect3D9* gl_pmyIDirect3D9;
HINSTANCE gl_hOriginalDll;
HINSTANCE gl_hThisInstance;
FILE *log;
#pragma data_seg ()
#define trace if(log) fprintf
BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
// to avoid compiler lvl4 warnings
LPVOID lpDummy = lpReserved;
lpDummy = NULL;
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH: InitInstance(hModule); break;
case DLL_PROCESS_DETACH: ExitInstance(); break;
case DLL_THREAD_ATTACH: break;
case DLL_THREAD_DETACH: break;
}
return TRUE;
}
// Exported function (faking d3d9.dll's one-and-only export)
IDirect3D9* WINAPI Direct3DCreate9(UINT SDKVersion)
{
trace(log, "Direct3DCreate9\n");
if (!gl_hOriginalDll) LoadOriginalDll(); // looking for the "right d3d9.dll"
// Hooking IDirect3D Object from Original Library
typedef IDirect3D9 *(WINAPI* D3D9_Type)(UINT SDKVersion);
D3D9_Type D3DCreate9_fn = (D3D9_Type) GetProcAddress( gl_hOriginalDll, "Direct3DCreate9");
// Debug
if (!D3DCreate9_fn)
{
OutputDebugString("PROXYDLL: Pointer to original D3DCreate9 function not received ERROR ****\r\n");
::ExitProcess(0); // exit the hard way
}
// Request pointer from Original Dll.
IDirect3D9 *pIDirect3D9_orig = D3DCreate9_fn(SDKVersion);
// Create my IDirect3D8 object and store pointer to original object there.
// note: the object will delete itself once Ref count is zero (similar to COM objects)
gl_pmyIDirect3D9 = new myIDirect3D9(pIDirect3D9_orig);
// Return pointer to hooking Object instead of "real one"
return (gl_pmyIDirect3D9);
}
void InitInstance(HANDLE hModule)
{
char *logpath;
OutputDebugString("PROXYDLL: InitInstance called.\r\n");
// Initialisation
gl_hOriginalDll = NULL;
gl_hThisInstance = NULL;
gl_pmyIDirect3D9 = NULL;
gl_pmyIDirect3DDevice9 = NULL;
// Storing Instance handle into global var
gl_hThisInstance = (HINSTANCE) hModule;
log=NULL;
logpath=getenv("d3d9log");
if(logpath) log=fopen(logpath, "a+");
}
void LoadOriginalDll(void)
{
char buffer[MAX_PATH];
// Getting path to system dir and to d3d8.dll
::GetSystemDirectory(buffer,MAX_PATH);
// Append dll name
strcat(buffer,"\\d3d9.dll");
// try to load the system's d3d9.dll, if pointer empty
if (!gl_hOriginalDll) gl_hOriginalDll = ::LoadLibrary(buffer);
// Debug
if (!gl_hOriginalDll)
{
OutputDebugString("PROXYDLL: Original d3d9.dll not loaded ERROR ****\r\n");
::ExitProcess(0); // exit the hard way
}
}
void ExitInstance()
{
OutputDebugString("PROXYDLL: ExitInstance called.\r\n");
// Release the system's d3d9.dll
if (gl_hOriginalDll)
{
::FreeLibrary(gl_hOriginalDll);
gl_hOriginalDll = NULL;
}
fclose(log);
}

4
d3d9proxy/proxydll.def Normal file
View File

@ -0,0 +1,4 @@
LIBRARY "d3d9"
EXPORTS
Direct3DCreate9 @1

10
d3d9proxy/proxydll.h Normal file
View File

@ -0,0 +1,10 @@
// proxydll.h
#pragma once
// Exported function
IDirect3D9* WINAPI Direct3DCreate9 (UINT SDKVersion);
// regular functions
void InitInstance(HANDLE hModule);
void ExitInstance(void);
void LoadOriginalDll(void);

19
d3d9proxy/proxydll.sln Normal file
View File

@ -0,0 +1,19 @@
Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "proxydll", "proxydll.vcproj", "{02EB97D5-B1C5-411E-8274-83A95985DE6F}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{02EB97D5-B1C5-411E-8274-83A95985DE6F}.Debug|Win32.ActiveCfg = Debug|Win32
{02EB97D5-B1C5-411E-8274-83A95985DE6F}.Debug|Win32.Build.0 = Debug|Win32
{02EB97D5-B1C5-411E-8274-83A95985DE6F}.Release|Win32.ActiveCfg = Release|Win32
{02EB97D5-B1C5-411E-8274-83A95985DE6F}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

BIN
d3d9proxy/proxydll.suo Normal file
View File

Binary file not shown.

BIN
d3d9proxy/proxydll.suo.old Normal file
View File

Binary file not shown.

253
d3d9proxy/proxydll.vcproj Normal file
View File

@ -0,0 +1,253 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="proxydll"
ProjectGUID="{02EB97D5-B1C5-411E-8274-83A95985DE6F}"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;PROXYDLL_EXPORTS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
UsePrecompiledHeader="2"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="Winmm.lib d3dx9.lib"
OutputFile="../Release/d3d9.dll"
LinkIncremental="2"
ModuleDefinitionFile="proxydll.def"
GenerateDebugInformation="true"
ProgramDatabaseFile="$(OutDir)/proxydll.pdb"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary="$(OutDir)/proxydll.lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;PROXYDLL_EXPORTS"
RuntimeLibrary="0"
UsePrecompiledHeader="2"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="Winmm.lib d3dx9.lib"
OutputFile="../Release/d3d9.dll"
LinkIncremental="1"
ModuleDefinitionFile="proxydll.def"
GenerateDebugInformation="true"
SubSystem="2"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary="$(OutDir)/proxydll.lib"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="source"
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\myIDirect3D9.cpp"
>
</File>
<File
RelativePath=".\myIDirect3DDevice9.cpp"
>
</File>
<File
RelativePath=".\proxydll.cpp"
>
</File>
<File
RelativePath=".\proxydll.def"
>
</File>
<File
RelativePath=".\stdafx.cpp"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="1"
/>
</FileConfiguration>
</File>
</Filter>
<Filter
Name="include"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath=".\myIDirect3D9.h"
>
</File>
<File
RelativePath=".\myIDirect3DDevice9.h"
>
</File>
<File
RelativePath=".\proxydll.h"
>
</File>
<File
RelativePath=".\stdafx.h"
>
</File>
</Filter>
<Filter
Name="resources"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

2
d3d9proxy/stdafx.cpp Normal file
View File

@ -0,0 +1,2 @@
// stdafx.cpp
#include "stdafx.h"

10
d3d9proxy/stdafx.h Normal file
View File

@ -0,0 +1,10 @@
// stdafx.h
#pragma once
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "d3d9.h"
#include "myIDirect3D9.h"
#include "myIDirect3DDevice9.h"

14
dll/advapi.cpp
View File

@ -72,7 +72,7 @@ LONG WINAPI extRegOpenKeyEx(
FILE *regf;
char sKey[256+1];
sprintf(sKey,"%s\\%s", hKey2String(hKey), lpSubKey);
OutTraceD("RegOpenKeyEx: searching for key=\"%s\"\n", sKey);
OutTraceDW("RegOpenKeyEx: searching for key=\"%s\"\n", sKey);
regf=fopen("dxwnd.reg","r");
if(regf==NULL) return ERROR_FILE_NOT_FOUND;
fgets(RegBuf, 256, regf);
@ -150,7 +150,7 @@ LONG WINAPI extRegQueryValueEx(
else {
if(hCurKey==hKey){
//OutTraceD("loop: \"%s\"\n", RegBuf);
//OutTraceDW("loop: \"%s\"\n", RegBuf);
if((RegBuf[0]=='"') &&
!strncmp(lpValueName, &RegBuf[1], strlen(lpValueName)) &&
(RegBuf[strlen(lpValueName)+1]=='"') &&
@ -172,7 +172,7 @@ LONG WINAPI extRegQueryValueEx(
}
if(lpType) *lpType=REG_SZ;
//
OutTraceD("RegQueryValueEx: Data=\"%s\" type=REG_SZ\n", lpData);
OutTraceDW("RegQueryValueEx: Data=\"%s\" type=REG_SZ\n", lpData);
res=ERROR_SUCCESS;
}
if(!strncmp(pData,"dword:",strlen("dword:"))){ //dword value
@ -182,7 +182,7 @@ LONG WINAPI extRegQueryValueEx(
memcpy(lpData, &val, sizeof(DWORD));
if(lpType) *lpType=REG_DWORD;
*lpcbData=sizeof(DWORD);
OutTraceD("RegQueryValueEx: Data=0x%x type=REG_DWORD\n", val);
OutTraceDW("RegQueryValueEx: Data=0x%x type=REG_DWORD\n", val);
res=ERROR_SUCCESS;
}
if(!strncmp(pData,"hex:",strlen("hex:"))){ //dword value
@ -190,15 +190,15 @@ LONG WINAPI extRegQueryValueEx(
lpData[strlen((char *)lpData)-1]=0; // eliminates \n
if(lpType) *lpType=REG_BINARY;
*lpcbData=0;
OutTraceD("RegQueryValueEx: Data=");
OutTraceDW("RegQueryValueEx: Data=");
while(strlen(pData)>1){
sscanf(pData, "%x,", (char *)lpData);
OutTraceD("%02.2x,", *(unsigned char *)lpData);
OutTraceDW("%02.2x,", *(unsigned char *)lpData);
pData+=3;
lpData++;
(*lpcbData)++;
}
OutTraceD(" type=REG_BINARY cbData=%d\n", *lpcbData);
OutTraceDW(" type=REG_BINARY cbData=%d\n", *lpcbData);
res=ERROR_SUCCESS;
}
fclose(regf);

10
dll/ddproxy.cpp
View File

@ -666,7 +666,7 @@ HRESULT WINAPI extInitializeProxy(LPDIRECTDRAW lpdd, GUID FAR *lpguid)
HRESULT res;
GUID FAR *lpPrivGuid = lpguid;
OutTraceD("Initialize: lpdd=%x guid=%x(%s)\n", lpdd, lpguid, ExplainGUID(lpguid));
OutTraceDW("Initialize: lpdd=%x guid=%x(%s)\n", lpdd, lpguid, ExplainGUID(lpguid));
res=(*pInitialize)(lpdd, lpPrivGuid);
@ -2072,18 +2072,18 @@ int WINAPI extGetDeviceCapsProxy(HDC hdc, int nindex)
DWORD res;
res = (*pGDIGetDeviceCaps)(hdc, nindex);
OutTraceD("GetDeviceCaps: hdc=%x index=%x(%s) res=%x\n",
OutTraceDW("GetDeviceCaps: hdc=%x index=%x(%s) res=%x\n",
hdc, nindex, ExplainDeviceCaps(nindex), res);
switch(nindex){
case VERTRES:
OutTraceD("GetDeviceCaps: VERTRES=%d\n", res);
OutTraceDW("GetDeviceCaps: VERTRES=%d\n", res);
break;
case HORZRES:
OutTraceD("GetDeviceCaps: HORZRES=%d\n", res);
OutTraceDW("GetDeviceCaps: HORZRES=%d\n", res);
break;
case RASTERCAPS:
OutTraceD("GetDeviceCaps: RASTERCAPS=%x(%s)\n",res, ExplainRasterCaps(res));
OutTraceDW("GetDeviceCaps: RASTERCAPS=%x(%s)\n",res, ExplainRasterCaps(res));
break;
}
return res;

461
dll/ddraw.cpp
View File

File diff suppressed because it is too large Load Diff

26
dll/dinput.cpp
View File

@ -96,7 +96,7 @@ HRESULT WINAPI extDirectInputCreate(HINSTANCE hinst,
{
HRESULT res;
OutTraceD("DirectInputCreate: dwVersion = %x\n",
OutTraceDW("DirectInputCreate: dwVersion = %x\n",
dwversion);
res = (*pDirectInputCreate)(hinst, dwversion, lplpdi, pu);
@ -111,7 +111,7 @@ HRESULT WINAPI extDirectInputCreateEx(HINSTANCE hinst,
{
HRESULT res;
OutTraceD("DirectInputCreateEx: dwVersion = %x REFIID = %x\n",
OutTraceDW("DirectInputCreateEx: dwVersion = %x REFIID = %x\n",
dwversion, riidltf.Data1);
res = (*pDirectInputCreateEx)(hinst, dwversion, riidltf, ppvout, pu);
@ -125,7 +125,7 @@ HRESULT WINAPI extQueryInterfaceI(void * lpdi, REFIID riid, LPVOID *obp)
{
HRESULT res;
OutTraceD("lpDI->QueryInterface: REFIID = %x\n",
OutTraceDW("lpDI->QueryInterface: REFIID = %x\n",
riid.Data1);
res = (*pQueryInterfaceI)(lpdi, riid, obp);
@ -145,7 +145,7 @@ HRESULT WINAPI extDirectInput8Create(HINSTANCE hinst,
{
HRESULT res;
OutTraceD("DirectInput8Create: dwVersion = %x REFIID = %x\n",
OutTraceDW("DirectInput8Create: dwVersion = %x REFIID = %x\n",
dwversion, riidltf.Data1);
res = (*pDirectInputCreateEx)(hinst, dwversion, riidltf, ppvout, pu);
@ -159,7 +159,7 @@ HRESULT WINAPI extDICreateDevice(LPDIRECTINPUT lpdi, REFGUID rguid,
{
HRESULT res;
OutTraceD("lpDI->CreateDevice: REFGUID = %x\n",
OutTraceDW("lpDI->CreateDevice: REFGUID = %x\n",
rguid.Data1);
res = (*pDICreateDevice)(lpdi, rguid, lplpdid, pu);
@ -176,7 +176,7 @@ HRESULT WINAPI extDICreateDeviceEx(LPDIRECTINPUT lpdi, REFGUID rguid,
{
HRESULT res;
OutTraceD("lpDI->CreateDeviceEx: GUID = %x REFIID = %x\n",
OutTraceDW("lpDI->CreateDeviceEx: GUID = %x REFIID = %x\n",
rguid.Data1, riid.Data1);
res = (*pDICreateDeviceEx)(lpdi, rguid, riid, pvout, pu);
@ -195,7 +195,7 @@ HRESULT WINAPI extGetDeviceData(LPDIRECTINPUTDEVICE lpdid, DWORD cbdata, LPVOID
unsigned int i;
POINT p;
OutTraceD("GetDeviceData cbdata:%i\n", cbdata);
OutTraceDW("GetDeviceData cbdata:%i\n", cbdata);
res = (*pGetDeviceData)(lpdid, cbdata, rgdod, pdwinout, dwflags);
if(res) return res;
@ -225,7 +225,7 @@ HRESULT WINAPI extGetDeviceData(LPDIRECTINPUTDEVICE lpdid, DWORD cbdata, LPVOID
}
tmp += cbdata;
}
OutTraceD("DEBUG: directinput mousedata=(%d,%d)\n", p.x, p.y);
OutTraceDW("DEBUG: directinput mousedata=(%d,%d)\n", p.x, p.y);
}
return 0;
}
@ -235,7 +235,7 @@ HRESULT WINAPI extGetDeviceState(LPDIRECTINPUTDEVICE lpdid, DWORD cbdata, LPDIMO
HRESULT res;
POINT p = {0, 0};
OutTraceD("GetDeviceState cbData:%i %i\n", cbdata, dxw.bActive);
OutTraceDW("GetDeviceState cbData:%i %i\n", cbdata, dxw.bActive);
res = (*pGetDeviceState)(lpdid, cbdata, lpvdata);
if(res) return res;
@ -257,7 +257,7 @@ HRESULT WINAPI extGetDeviceState(LPDIRECTINPUTDEVICE lpdid, DWORD cbdata, LPDIMO
lpvdata->lZ = 0;
*(DWORD *)lpvdata->rgbButtons = 0;
}
OutTraceD("DEBUG: directinput mousestate=(%d,%d)\n", p.x, p.y);
OutTraceDW("DEBUG: directinput mousestate=(%d,%d)\n", p.x, p.y);
}
if(cbdata == 256 && !dxw.bActive) ZeroMemory(lpvdata, 256);
@ -266,7 +266,7 @@ HRESULT WINAPI extGetDeviceState(LPDIRECTINPUTDEVICE lpdid, DWORD cbdata, LPDIMO
HRESULT WINAPI extSetDataFormat(LPDIRECTINPUTDEVICE lpdid, LPCDIDATAFORMAT lpdf)
{
OutTraceD("SetDataFormat: flags = 0x%x\n", lpdf->dwFlags);
OutTraceDW("SetDataFormat: flags = 0x%x\n", lpdf->dwFlags);
if(lpdf->dwFlags & DIDF_ABSAXIS) dxw.bDInputAbs = 1;
if(lpdf->dwFlags & DIDF_RELAXIS) dxw.bDInputAbs = 0;
@ -275,7 +275,7 @@ HRESULT WINAPI extSetDataFormat(LPDIRECTINPUTDEVICE lpdid, LPCDIDATAFORMAT lpdf)
HRESULT WINAPI extDISetCooperativeLevel(LPDIRECTINPUTDEVICE lpdid, HWND hwnd, DWORD dwflags)
{
OutTraceD("lpDI->SetCooperativeLevel\n");
OutTraceDW("lpDI->SetCooperativeLevel\n");
dwflags = DISCL_NONEXCLUSIVE | DISCL_BACKGROUND;
return (*pDISetCooperativeLevel)(lpdid, hwnd, dwflags);
@ -290,7 +290,7 @@ void GetMousePosition(int *x, int *y)
extGetCursorPos(&p);
*x = p.x;
*y = p.y;
OutTraceD("GetMousePosition: x,y=(%d,%d)\n", *x, *y);
OutTraceDW("GetMousePosition: x,y=(%d,%d)\n", *x, *y);
}
void InitPosition(int x, int y, int minx, int miny, int maxx, int maxy)

38
dll/dxdiaghook.cpp
View File

@ -40,15 +40,15 @@ HRESULT HookDxDiag(REFIID riid, LPVOID FAR* ppv)
{
HMODULE dxdlib;
OutTraceD("CoCreateInstance: CLSID_DxDiagProvider object\n");
OutTraceDW("CoCreateInstance: CLSID_DxDiagProvider object\n");
dxdlib=(*pLoadLibraryA)("dxdiagn.dll");
OutTraceD("CoCreateInstance: dxdiagn lib handle=%x\n", dxdlib);
OutTraceDW("CoCreateInstance: dxdiagn lib handle=%x\n", dxdlib);
extern void HookModule(HMODULE, int);
HookModule(dxdlib, 0);
switch (*(DWORD *)&riid){
case 0x9C6B4CB0:
OutTraceD("CoCreateInstance: IID_DxDiagProvider RIID\n");
OutTraceDW("CoCreateInstance: IID_DxDiagProvider RIID\n");
// IID_DxDiagProvider::QueryInterface
SetHook((void *)(**(DWORD **)ppv), extQueryInterfaceDD, (void **)&pQueryInterfaceDD, "QueryInterface(DxDiag)");
// IID_DxDiagProvider::Initialize
@ -57,7 +57,7 @@ HRESULT HookDxDiag(REFIID riid, LPVOID FAR* ppv)
SetHook((void *)(**(DWORD **)ppv + 16), extGetRootContainer, (void **)&pGetRootContainer, "GetRootContainer(DxDiag)");
break;
case 0x7D0F462F:
OutTraceD("CoCreateInstance: IID_IDxDiagContainer RIID\n");
OutTraceDW("CoCreateInstance: IID_IDxDiagContainer RIID\n");
break;
}
@ -68,65 +68,65 @@ HRESULT HookDxDiag(REFIID riid, LPVOID FAR* ppv)
HRESULT WINAPI extInitializeDD(void *th, DXDIAG_INIT_PARAMS *pParams)
{
HRESULT res;
OutTraceD("DxDiag::Initialize Params=%x\n", pParams);
OutTraceDW("DxDiag::Initialize Params=%x\n", pParams);
res=(*pInitializeDD)(th, pParams);
OutTraceD("DxDiag::Initialize res=%x\n", res);
OutTraceDW("DxDiag::Initialize res=%x\n", res);
return res;
}
HRESULT WINAPI extGetRootContainer(void *th, IDxDiagContainer **ppInstance)
{
HRESULT res;
OutTraceD("DxDiag::GetRootContainer pInstance=%x\n", *ppInstance);
OutTraceDW("DxDiag::GetRootContainer pInstance=%x\n", *ppInstance);
res=(*pGetRootContainer)(th, ppInstance);
// IID_IDxDiagContainer::GetNumberOfChildContainers
SetHook((void *)(**(DWORD **)ppInstance + 12), extGetNumberOfChildContainers, (void **)&pGetNumberOfChildContainers, "GetNumberOfChildContainers(DxDiag)");
// IID_IDxDiagContainer::GetProp
SetHook((void *)(**(DWORD **)ppInstance + 32), extGetProp, (void **)&pGetProp, "GetProp(DxDiag)");
OutTraceD("DxDiag::GetRootContainer res=%x\n", res);
OutTraceDW("DxDiag::GetRootContainer res=%x\n", res);
return res;
}
HRESULT WINAPI extGetNumberOfChildContainers(void *th, DWORD *pdwCount)
{
HRESULT res;
OutTraceD("DxDiag::GetNumberOfChildContainers\n");
OutTraceDW("DxDiag::GetNumberOfChildContainers\n");
res=(*pGetNumberOfChildContainers)(th, pdwCount);
OutTraceD("DxDiag::GetNumberOfChildContainers res=%x Count=%d\n", res, *pdwCount);
OutTraceDW("DxDiag::GetNumberOfChildContainers res=%x Count=%d\n", res, *pdwCount);
return res;
}
HRESULT WINAPI extQueryInterfaceDD(void *th, REFIID riid, LPVOID *ppvObj)
{
HRESULT res;
OutTraceD("DxDiag::QueryInterface ref=%x\n");
OutTraceDW("DxDiag::QueryInterface ref=%x\n");
res=(*pQueryInterfaceDD)(th, riid, ppvObj);
OutTraceD("DxDiag::QueryInterface res=%x\n", res);
OutTraceDW("DxDiag::QueryInterface res=%x\n", res);
return res;
}
HRESULT WINAPI extGetProp(void *th, LPCWSTR pwszPropName, VARIANT *pvarProp)
{
HRESULT res;
OutTraceD("DxDiag::GetProp PropName=%ls\n", pwszPropName);
OutTraceDW("DxDiag::GetProp PropName=%ls\n", pwszPropName);
res=(*pGetProp)(th, pwszPropName, pvarProp);
if(res)
OutTraceE("DxDiag::GetProp ERROR res=%x\n", res);
if (!wcsncmp(L"dwDirectXVersionMajor", pwszPropName, sizeof(L"dwDirectXVersionMajor"))){
OutTraceD("DxDiag::GetProp DirectXVersionMajor=%d\n", *pvarProp);
OutTraceDW("DxDiag::GetProp DirectXVersionMajor=%d\n", *pvarProp);
//*(DWORD *)pvarProp=10;
//OutTraceD("DxDiag::GetProp fixed DirectXVersionMajor=%d\n", *pvarProp);
//OutTraceDW("DxDiag::GetProp fixed DirectXVersionMajor=%d\n", *pvarProp);
}
if (!wcsncmp(L"dwDirectXVersionMinor", pwszPropName, sizeof(L"dwDirectXVersionMinor"))){
OutTraceD("DxDiag::GetProp DirectXVersionMinor=%d\n", *pvarProp);
OutTraceDW("DxDiag::GetProp DirectXVersionMinor=%d\n", *pvarProp);
//*(DWORD *)pvarProp=10;
//OutTraceD("DxDiag::GetProp fixed dwDirectXVersionMinor=%d\n", *pvarProp);
//OutTraceDW("DxDiag::GetProp fixed dwDirectXVersionMinor=%d\n", *pvarProp);
}
if (!wcsncmp(L"szDirectXVersionLetter", pwszPropName, sizeof(L"szDirectXVersionLetter"))){
OutTraceD("DxDiag::GetProp DirectXVersionLetter=%d\n", *pvarProp);
OutTraceDW("DxDiag::GetProp DirectXVersionLetter=%d\n", *pvarProp);
//*(DWORD *)pvarProp=9;
//OutTraceD("DxDiag::GetProp fixed szDirectXVersionLetter=%d\n", *pvarProp);
//OutTraceDW("DxDiag::GetProp fixed szDirectXVersionLetter=%d\n", *pvarProp);
}
return res;
}

72
dll/dxemublt.cpp
View File

@ -116,7 +116,7 @@ static HRESULT WINAPI EmuBlt_8_to_32(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdest
src8 += lpsrcrect->left;
srcpitch = ddsd_src.lPitch - w;
// OutTraceD("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src8,dest,srcpitch,destpitch);
// OutTraceDW("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src8,dest,srcpitch,destpitch);
for(y = 0; y < h; y ++){
for(x = 0; x < w; x ++){
*(dest ++) = PaletteEntries[*(src8 ++)];
@ -126,6 +126,31 @@ static HRESULT WINAPI EmuBlt_8_to_32(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdest
}
if(dxw.dwFlags3 & MARKBLIT) MarkRect32(dest0, w, h, destpitch);
#if 0
if(1 && IsTraceDDRAW) {
DWORD dwStats[256];
src8 = (BYTE *)lpsurface;
src8 += lpsrcrect->top*ddsd_src.lPitch;
src8 += lpsrcrect->left;
for(x = 0; x < 256; x ++) dwStats[x]=0;
for(y = 0; y < h; y ++){
for(x = 0; x < w; x ++){
dwStats[*(src8 ++)]++;
}
src8 += srcpitch;
}
OutTrace("Colors: ");
for(x = 0; x < 256; x ++) {
char sElement[8];
if (dwStats[x])
sprintf(sElement,"%x,", dwStats[x]);
else
strcpy(sElement, "_,");
OutTrace(sElement);
}
OutTrace("\n");
}
#endif
res=(*pUnlockMethod(lpddsdst))(lpddsdst, lpdestrect);
if (res) OutTraceE("EmuBlt8_32: Unlock ERROR dds=%x res=%x(%s) at %d\n", lpddsdst, res, ExplainDDError(res), __LINE__);
@ -134,7 +159,6 @@ static HRESULT WINAPI EmuBlt_8_to_32(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdest
return res;
}
static HRESULT WINAPI EmuBlt_16_to_32(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdestrect,
LPDIRECTDRAWSURFACE lpddssrc, LPRECT lpsrcrect, DWORD dwflags, LPVOID lpsurface)
{
@ -189,7 +213,7 @@ static HRESULT WINAPI EmuBlt_16_to_32(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdes
src16 += lpsrcrect->left;
srcpitch = ddsd_src.lPitch - w;
// OutTraceD("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src16,dest,srcpitch,destpitch);
// OutTraceDW("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src16,dest,srcpitch,destpitch);
if (!Palette16BPP) { // first time through .....
unsigned int pi;
Palette16BPP = (DWORD *)malloc(0x10000 * sizeof(DWORD));
@ -375,7 +399,7 @@ static HRESULT WINAPI EmuBlt_32_to_32(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdes
src32 += lpsrcrect->left;
srcpitch = ddsd_src.lPitch - w;
// OutTraceD("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src32,dest,srcpitch,destpitch);
// OutTraceDW("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src32,dest,srcpitch,destpitch);
for(y = 0; y < h; y ++){
for(x = 0; x < w; x ++)
*(dest ++) = *(src32 ++);
@ -446,7 +470,7 @@ static HRESULT WINAPI EmuBlt_8_to_16(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdest
src8 += lpsrcrect->left;
srcpitch = ddsd_src.lPitch - w;
// OutTraceD("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src8,dest,srcpitch,destpitch);
// OutTraceDW("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src8,dest,srcpitch,destpitch);
for(y = 0; y < h; y ++){
for(x = 0; x < w; x ++){
*(dest ++) = (SHORT)PaletteEntries[*(src8 ++)];
@ -471,7 +495,7 @@ static HRESULT WINAPI EmuBlt_16_to_16(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdes
#ifdef DXWNDDIRECTBLITTING
return (*pBlt)(lpddsdst, lpdestrect, lpddssrc, lpsrcrect, dwflags, NULL);
#else
OutTraceD("EmuBlt_16_to_16: UNSUPPORTED\n");
OutTraceDW("EmuBlt_16_to_16: UNSUPPORTED\n");
return -1;
#endif
}
@ -610,7 +634,7 @@ static int GetMatchingPaletteEntry32(DWORD crColor)
if (iMinDistance==0) break; // got the perfect match!
}
OutTraceD("GetMatchingPaletteEntry32: color=%x matched with palette[%d]=%x dist=%d\n",
OutTraceDW("GetMatchingPaletteEntry32: color=%x matched with palette[%d]=%x dist=%d\n",
crColor, iMinColorIndex, PaletteEntries[iMinColorIndex], iDistance);
return iMinColorIndex;
@ -647,7 +671,7 @@ static int GetMatchingPaletteEntry16(DWORD crColor)
if (iMinDistance==0) break; // got the perfect match!
}
OutTraceD("GetMatchingPaletteEntry: color=%x matched with palette[%d]=%x dist=%d\n",
OutTraceDW("GetMatchingPaletteEntry: color=%x matched with palette[%d]=%x dist=%d\n",
crColor, iMinColorIndex, PaletteEntries[iMinColorIndex], iDistance);
return iMinColorIndex;
@ -678,7 +702,7 @@ static HRESULT WINAPI RevBlt_32_to_8(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdest
static BYTE *PaletteFlags = NULL;
int pi;
OutTraceD("RevBlt32_8: src=%x dst=%d\n", lpddssrc, lpddsdst);
OutTraceDW("RevBlt32_8: src=%x dst=%d\n", lpddssrc, lpddsdst);
w = lpdestrect->right - lpdestrect->left;
h = lpdestrect->bottom - lpdestrect->top;
@ -710,7 +734,7 @@ static HRESULT WINAPI RevBlt_32_to_8(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdest
src8 += lpsrcrect->left;
srcpitch = ddsd_src.lPitch - w;
// OutTraceD("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src8,dest,srcpitch,destpitch);
// OutTraceDW("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src8,dest,srcpitch,destpitch);
if (!PaletteRev32BPP) { // first time through .....
PaletteRev32BPP = (BYTE *)malloc(REVPAL32SIZE);
PaletteFlags = (BYTE *)malloc(REVPAL32SIZE);
@ -756,7 +780,7 @@ static HRESULT WINAPI RevBlt_32_to_16(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdes
long srcpitch, destpitch;
DWORD x, y, w, h;
OutTraceD("RevBlt32_16: src=%x dst=%d\n", lpddssrc, lpddsdst);
OutTraceDW("RevBlt32_16: src=%x dst=%d\n", lpddssrc, lpddsdst);
w = lpdestrect->right - lpdestrect->left;
h = lpdestrect->bottom - lpdestrect->top;
@ -816,7 +840,7 @@ static HRESULT WINAPI RevBlt_16_to_8(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdest
static BYTE *PaletteFlags = NULL;
int pi;
OutTraceD("RevBlt16_8: src=%x dst=%d\n", lpddssrc, lpddsdst);
OutTraceDW("RevBlt16_8: src=%x dst=%d\n", lpddssrc, lpddsdst);
w = lpdestrect->right - lpdestrect->left;
h = lpdestrect->bottom - lpdestrect->top;
@ -848,7 +872,7 @@ static HRESULT WINAPI RevBlt_16_to_8(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdest
src8 += lpsrcrect->left;
srcpitch = ddsd_src.lPitch - w;
// OutTraceD("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src8,dest,srcpitch,destpitch);
// OutTraceDW("DEBUG: h=%d w=%d src=%x dst=%x spitch=%d dpitch=%d\n",h,w,src8,dest,srcpitch,destpitch);
if (!PaletteRev16BPP) { // first time through .....
PaletteRev16BPP = (BYTE *)malloc(REVPAL16SIZE);
PaletteFlags = (BYTE *)malloc(REVPAL16SIZE);
@ -902,7 +926,7 @@ static HRESULT WINAPI RevBlt_Null(LPDIRECTDRAWSURFACE lpddsdst, LPRECT lpdestrec
void SetBltTransformations()
{
OutTraceD("SetBltTransformations: color transformation %d->%d\n",
OutTraceDW("SetBltTransformations: color transformation %d->%d\n",
dxw.VirtualPixelFormat.dwRGBBitCount, dxw.ActualPixelFormat.dwRGBBitCount);
/* default (bad) setting */
@ -915,24 +939,24 @@ void SetBltTransformations()
case 8:
pRevBlt=RevBlt_32_to_8;
pEmuBlt=EmuBlt_8_to_32;
OutTraceD("set color transformation 8<->32\n");
OutTraceDW("set color transformation 8<->32\n");
break;
case 16:
pRevBlt=RevBlt_32_to_16;
pEmuBlt=EmuBlt_16_to_32;
OutTraceD("set color transformation 16<->32\n");
OutTraceDW("set color transformation 16<->32\n");
break;
case 24:
//pRevBlt=RevBlt_24_to_32;
pEmuBlt=EmuBlt_24_to_32;
OutTraceD("set color transformation 24->32\n");
OutTraceDW("set color transformation 24->32\n");
break;
case 32:
pEmuBlt=EmuBlt_32_to_32;
OutTraceD("set color transformation 32->32\n");
OutTraceDW("set color transformation 32->32\n");
break;
default:
OutTraceD("unsupported color transformation %d->32\n", dxw.VirtualPixelFormat.dwRGBBitCount);
OutTraceDW("unsupported color transformation %d->32\n", dxw.VirtualPixelFormat.dwRGBBitCount);
break;
}
break;
@ -941,28 +965,28 @@ void SetBltTransformations()
case 8:
pRevBlt=RevBlt_16_to_8;
pEmuBlt=EmuBlt_8_to_16;
OutTraceD("set color transformation 8<->16\n");
OutTraceDW("set color transformation 8<->16\n");
break;
case 16:
pRevBlt=RevBlt_16_to_16;
pEmuBlt=EmuBlt_16_to_16;
OutTraceD("set color transformation 16<->16\n");
OutTraceDW("set color transformation 16<->16\n");
break;
case 24:
//pRevBlt=RevBlt_24_to_16;
pEmuBlt=EmuBlt_24_to_16;
OutTraceD("set color transformation 24<->16\n");
OutTraceDW("set color transformation 24<->16\n");
break;
case 32:
pEmuBlt=EmuBlt_32_to_16;
break;
default:
OutTraceD("unsupported color transformation %d->16\n", dxw.VirtualPixelFormat.dwRGBBitCount);
OutTraceDW("unsupported color transformation %d->16\n", dxw.VirtualPixelFormat.dwRGBBitCount);
break;
}
break;
default:
OutTraceD("unsupported color transformation %d->%d\n",
OutTraceDW("unsupported color transformation %d->%d\n",
dxw.VirtualPixelFormat.dwRGBBitCount,
dxw.ActualPixelFormat.dwRGBBitCount);
break;

182
dll/dxhook.cpp
View File

@ -67,7 +67,7 @@ static char *Flag3Names[32]={
static char *Flag4Names[32]={
"NOALPHACHANNEL", "SUPPRESSCHILD", "FIXREFCOUNTER", "SHOWTIMESTRETCH",
"ZBUFFERCLEAN", "ZBUFFER0CLEAN", "ZBUFFERALWAYS", "DISABLEFOGGING",
"NOPOWER2FIX", "", "", "",
"NOPOWER2FIX", "NOPERFCOUNTER", "ADDPROXYLIBS", "",
"", "", "", "",
"", "", "", "",
"", "", "", "",
@ -143,19 +143,19 @@ static void dx_ToggleLogging()
{
// toggle LOGGING
if(dxw.dwTFlags & OUTTRACE){
OutTraceD("Toggle logging OFF\n");
OutTraceDW("Toggle logging OFF\n");
dxw.dwTFlags &= ~OUTTRACE;
}
else {
dxw.dwTFlags |= OUTTRACE;
OutTraceD("Toggle logging ON\n");
OutTraceDW("Toggle logging ON\n");
}
GetHookInfo()->isLogging=(dxw.dwTFlags & OUTTRACE);
}
static void SuppressIMEWindow()
{
OutTraceD("WindowProc: SUPPRESS IME\n");
OutTraceDW("WindowProc: SUPPRESS IME\n");
typedef BOOL (WINAPI *ImmDisableIME_Type)(DWORD);
ImmDisableIME_Type pImmDisableIME;
HMODULE ImmLib;
@ -222,7 +222,7 @@ void HookDlls(HMODULE module)
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
OutTraceD("HookDlls: EXCEPTION\n");
OutTraceDW("HookDlls: EXCEPTION\n");
}
return;
}
@ -282,7 +282,7 @@ void DumpImportTable(HMODULE module)
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
OutTraceD("DumpImportTable: EXCEPTION\n");
OutTraceDW("DumpImportTable: EXCEPTION\n");
}
return;
}
@ -304,23 +304,32 @@ void SetHook(void *target, void *hookproc, void **hookedproc, char *hookname)
if((dwTmp <= MaxHook) && (dwTmp >= MinHook)) return; // already hooked
if(dwTmp == 0){
sprintf(msg,"SetHook ERROR: NULL target for %s\n", hookname);
OutTraceD(msg);
OutTraceDW(msg);
MessageBox(0, msg, "SetHook", MB_OK | MB_ICONEXCLAMATION);
return; // error condition
}
if(!VirtualProtect(target, 4, PAGE_READWRITE, &oldprot)) {
sprintf(msg,"SetHook ERROR: target=%x err=%d\n", target, GetLastError());
OutTraceD(msg);
OutTraceDW(msg);
if (IsAssertEnabled) MessageBox(0, msg, "SetHook", MB_OK | MB_ICONEXCLAMATION);
return; // error condition
}
*(DWORD *)target = (DWORD)hookproc;
VirtualProtect(target, 4, oldprot, &oldprot);
if(!VirtualProtect(target, 4, oldprot, &oldprot)){
OutTrace("SetHook: VirtualProtect ERROR target=%x, err=%x\n", target, GetLastError());
return; // error condition
}
#if 0
if(!FlushInstructionCache(GetCurrentProcess(), target, 4)){
OutTrace("SetHook: FlushInstructionCache ERROR target=%x, err=%x\n", target, GetLastError());
return; // error condition
}
#endif
tmp=(void *)dwTmp;
if (*hookedproc && *hookedproc!=tmp) {
sprintf(msg,"SetHook: proc=%s oldhook=%x newhook=%x\n", hookname, hookedproc, tmp);
OutTraceD(msg);
OutTraceDW(msg);
if (IsAssertEnabled) MessageBox(0, msg, "SetHook", MB_OK | MB_ICONEXCLAMATION);
}
*hookedproc = tmp;
@ -397,13 +406,13 @@ void *HookAPI(HMODULE module, char *dll, void *apiproc, const char *apiname, voi
return 0;
}
pidesc = (PIMAGE_IMPORT_DESCRIPTOR)(base + rva);
OutTraceD("HookAPI: pidesc=%x\n", pidesc);
OutTraceDW("HookAPI: pidesc=%x\n", pidesc);
while(pidesc->Name){
pThunk=(PCHAR)base+pidesc->FirstThunk;
dwThunk = pidesc->FirstThunk;
pDllName=(PSTR)base+pidesc->Name;
OutTraceD("HookAPI: pDllName=%s Name=%s\n", pDllName, pidesc->Name);
OutTraceDW("HookAPI: pDllName=%s Name=%s\n", pDllName, pidesc->Name);
//impmodule = (PSTR)(base + pidesc->Name);
//if(!lstrcmpi(dll, impmodule)) break;
pidesc ++;
@ -417,7 +426,7 @@ void *HookAPI(HMODULE module, char *dll, void *apiproc, const char *apiname, voi
ptname = (pidesc->OriginalFirstThunk) ? (PIMAGE_THUNK_DATA)(base + (DWORD)pidesc->OriginalFirstThunk) : NULL;
if((apiproc==NULL) && (ptname==NULL)){
if (IsDebug) OutTraceD("HookAPI: unreacheable api=%s dll=%s\n", apiname, dll);
if (IsDebug) OutTraceDW("HookAPI: unreacheable api=%s dll=%s\n", apiname, dll);
return 0;
}
@ -440,23 +449,23 @@ void *HookAPI(HMODULE module, char *dll, void *apiproc, const char *apiname, voi
if(org == hookproc) return 0; // already hooked
if(!VirtualProtect(&ptaddr->u1.Function, 4, PAGE_EXECUTE_READWRITE, &oldprotect)) {
OutTraceD("HookAPI: VirtualProtect error %d at %d\n", GetLastError(), __LINE__);
OutTraceDW("HookAPI: VirtualProtect error %d at %d\n", GetLastError(), __LINE__);
return 0;
}
ptaddr->u1.Function = (DWORD)hookproc;
if(!VirtualProtect(&ptaddr->u1.Function, 4, oldprotect, &oldprotect)) {
OutTraceD("HookAPI: VirtualProtect error %d at %d\n", GetLastError(), __LINE__);
OutTraceDW("HookAPI: VirtualProtect error %d at %d\n", GetLastError(), __LINE__);
return 0;
}
if (!FlushInstructionCache(GetCurrentProcess(), &ptaddr->u1.Function, 4)) {
OutTraceD("HookAPI: FlushInstructionCache error %d at %d\n", GetLastError(), __LINE__);
OutTraceDW("HookAPI: FlushInstructionCache error %d at %d\n", GetLastError(), __LINE__);
return 0;
}
if(IsDebug) OutTrace("HookAPI hook=%s address=%x->%x\n", apiname, org, hookproc);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
OutTraceD("HookAPI: EXCEPTION hook=%s:%s Hook Failed.\n", dll, apiname);
OutTraceDW("HookAPI: EXCEPTION hook=%s:%s Hook Failed.\n", dll, apiname);
org = 0;
}
return org;
@ -537,23 +546,23 @@ void *HookAPI(HMODULE module, char *dll, void *apiproc, const char *apiname, voi
if(org == hookproc) return 0; // already hooked
if(!VirtualProtect(&ptaddr->u1.Function, 4, PAGE_EXECUTE_READWRITE, &oldprotect)) {
OutTraceD("HookAPI: VirtualProtect error %d at %d\n", GetLastError(), __LINE__);
OutTraceDW("HookAPI: VirtualProtect error %d at %d\n", GetLastError(), __LINE__);
return 0;
}
ptaddr->u1.Function = (DWORD)hookproc;
if(!VirtualProtect(&ptaddr->u1.Function, 4, oldprotect, &oldprotect)) {
OutTraceD("HookAPI: VirtualProtect error %d at %d\n", GetLastError(), __LINE__);
OutTraceDW("HookAPI: VirtualProtect error %d at %d\n", GetLastError(), __LINE__);
return 0;
}
if (!FlushInstructionCache(GetCurrentProcess(), &ptaddr->u1.Function, 4)) {
OutTraceD("HookAPI: FlushInstructionCache error %d at %d\n", GetLastError(), __LINE__);
OutTraceDW("HookAPI: FlushInstructionCache error %d at %d\n", GetLastError(), __LINE__);
return 0;
}
OutTraceH("HookAPI hook=%s address=%x->%x\n", apiname, org, hookproc);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
OutTraceD("HookAPI: EXCEPTION hook=%s:%s Hook Failed.\n", dll, apiname);
OutTraceDW("HookAPI: EXCEPTION hook=%s:%s Hook Failed.\n", dll, apiname);
org = 0;
}
return org;
@ -643,12 +652,12 @@ void CalculateWindowPos(HWND hwnd, DWORD width, DWORD height, LPWINDOWPOS wp)
void AdjustWindowPos(HWND hwnd, DWORD width, DWORD height)
{
WINDOWPOS wp;
OutTraceD("AdjustWindowPos: hwnd=%x, size=(%d,%d)\n", hwnd, width, height);
OutTraceDW("AdjustWindowPos: hwnd=%x, size=(%d,%d)\n", hwnd, width, height);
CalculateWindowPos(hwnd, width, height, &wp);
OutTraceD("AdjustWindowPos: fixed pos=(%d,%d) size=(%d,%d)\n", wp.x, wp.y, wp.cx, wp.cy);
OutTraceDW("AdjustWindowPos: fixed pos=(%d,%d) size=(%d,%d)\n", wp.x, wp.y, wp.cx, wp.cy);
//if(!pSetWindowPos) pSetWindowPos=SetWindowPos;
//OutTraceD("pSetWindowPos=%x\n", pSetWindowPos);
OutTraceD("hwnd=%x pos=(%d,%d) size=(%d,%d)\n", pSetWindowPos, wp.x, wp.y, wp.cx, wp.cy);
//OutTraceDW("pSetWindowPos=%x\n", pSetWindowPos);
OutTraceDW("hwnd=%x pos=(%d,%d) size=(%d,%d)\n", pSetWindowPos, wp.x, wp.y, wp.cx, wp.cy);
if(!(*pSetWindowPos)(hwnd, 0, wp.x, wp.y, wp.cx, wp.cy, 0)){
OutTraceE("AdjustWindowPos: ERROR err=%d at %d\n", GetLastError(), __LINE__);
}
@ -658,14 +667,29 @@ void AdjustWindowPos(HWND hwnd, DWORD width, DWORD height)
return;
}
void HookWindowProc(HWND hwnd)
{
WNDPROC pWindowProc;
pWindowProc = (WNDPROC)(*pGetWindowLong)(hwnd, GWL_WNDPROC);
if (pWindowProc == extWindowProc){
// hooked already !!!
OutTraceDW("GetWindowLong: hwnd=%x WindowProc HOOK already in place\n", hwnd);
}
else {// don't hook twice ....
long lres;
WhndStackPush(hwnd, pWindowProc);
lres=(*pSetWindowLong)(hwnd, GWL_WNDPROC, (LONG)extWindowProc);
OutTraceDW("SetWindowLong: hwnd=%x HOOK WindowProc=%x->%x\n", hwnd, lres, (LONG)extWindowProc);
}
}
void AdjustWindowFrame(HWND hwnd, DWORD width, DWORD height)
{
HRESULT res=0;
WNDPROC pWindowProc;
LONG style;
OutTraceD("AdjustWindowFrame hwnd=%x, size=(%d,%d) coord=%d\n", hwnd, width, height, dxw.Coordinates);
OutTraceDW("AdjustWindowFrame hwnd=%x, size=(%d,%d) coord=%d\n", hwnd, width, height, dxw.Coordinates);
dxw.SetScreenSize(width, height);
if (hwnd==NULL) return;
@ -684,29 +708,18 @@ void AdjustWindowFrame(HWND hwnd, DWORD width, DWORD height)
(*pSetWindowLong)(hwnd, GWL_STYLE, style);
(*pSetWindowLong)(hwnd, GWL_EXSTYLE, 0);
(*pShowWindow)(hwnd, SW_SHOWNORMAL);
OutTraceD("AdjustWindowFrame hwnd=%x, set style=%s extstyle=0\n", hwnd, (style == 0) ? "0" : "WS_OVERLAPPEDWINDOW");
OutTraceDW("AdjustWindowFrame hwnd=%x, set style=%s extstyle=0\n", hwnd, (style == 0) ? "0" : "WS_OVERLAPPEDWINDOW");
AdjustWindowPos(hwnd, width, height);
// fixing windows message handling procedure
pWindowProc = (WNDPROC)(*pGetWindowLong)(hwnd, GWL_WNDPROC);
if (pWindowProc == extWindowProc){
// hooked already !!!
OutTraceD("GetWindowLong: extWindowProc already in place, hwnd=%x\n", hwnd);
}
else {// don't hook twice ....
long lres;
WhndStackPush(hwnd, pWindowProc);
lres=(*pSetWindowLong)(hwnd, GWL_WNDPROC, (LONG)extWindowProc);
OutTraceD("AdjustWindowFrame: fixing hwnd=%x WindowProc=%x->%x\n", hwnd, lres, (LONG)extWindowProc);
}
HookWindowProc(hwnd);
// fixing cursor view and clipping region
if (dxw.dwFlags1 & HIDEHWCURSOR) while ((*pShowCursor)(0) >= 0);
if (dxw.dwFlags2 & SHOWHWCURSOR) while((*pShowCursor)(1) < 0);
if (dxw.dwFlags1 & CLIPCURSOR) {
OutTraceD("AdjustWindowFrame: setting clip region\n");
OutTraceDW("AdjustWindowFrame: setting clip region\n");
dxw.SetClipCursor();
}
@ -736,7 +749,7 @@ INT_PTR CALLBACK extDialogWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPA
pWindowProc=WhndGetWindowProc(hwnd);
if(pWindowProc) return(*pWindowProc)(hwnd, message, wparam, lparam);
char *sMsg="ASSERT: DialogWinMsg pWindowProc=NULL !!!\n";
OutTraceD(sMsg);
OutTraceDW(sMsg);
if (IsAssertEnabled) MessageBox(0, sMsg, "WindowProc", MB_OK | MB_ICONEXCLAMATION);
return NULL;
}
@ -799,7 +812,7 @@ static void dx_UpdatePositionLock(HWND hwnd)
(*pGetClientRect)(hwnd,&rect);
(*pClientToScreen)(hwnd,&p);
dxw.dwFlags1 |= LOCKWINPOS;
OutTraceD("Toggle position lock ON\n");
OutTraceDW("Toggle position lock ON\n");
dxw.InitWindowPos(p.x, p.y, rect.right-rect.left, rect.bottom-rect.top);
}
@ -808,11 +821,11 @@ static void dx_TogglePositionLock(HWND hwnd)
// toggle position locking
if(dxw.dwFlags1 & LOCKWINPOS){
// unlock
OutTraceD("Toggle position lock OFF\n");
OutTraceDW("Toggle position lock OFF\n");
dxw.dwFlags1 &= ~LOCKWINPOS;
}
else {
OutTraceD("Toggle position lock ON\n");
OutTraceDW("Toggle position lock ON\n");
dxw.dwFlags1 |= LOCKWINPOS;
dx_UpdatePositionLock(hwnd);
}
@ -915,19 +928,19 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
break;
case WM_NCCALCSIZE:
if((dxw.dwFlags1 & LOCKWINPOS) && (hwnd == dxw.GethWnd())){ // v2.02.30: don't alter child and other windows....
OutTraceD("WindowProc: WS_NCCALCSIZE wparam=%x\n", wparam);
OutTraceDW("WindowProc: WS_NCCALCSIZE wparam=%x\n", wparam);
if(wparam){
// nothing so far ....
if (IsDebug){
NCCALCSIZE_PARAMS *ncp;
ncp = (NCCALCSIZE_PARAMS *) lparam;
OutTraceD("WindowProc: WS_NCCALCSIZE rect[0]=(%d,%d)-(%d,%d)\n",
OutTraceDW("WindowProc: WS_NCCALCSIZE rect[0]=(%d,%d)-(%d,%d)\n",
ncp->rgrc[0].left, ncp->rgrc[0].top, ncp->rgrc[0].right, ncp->rgrc[0].bottom);
OutTraceD("WindowProc: WS_NCCALCSIZE rect[1]=(%d,%d)-(%d,%d)\n",
OutTraceDW("WindowProc: WS_NCCALCSIZE rect[1]=(%d,%d)-(%d,%d)\n",
ncp->rgrc[1].left, ncp->rgrc[1].top, ncp->rgrc[1].right, ncp->rgrc[1].bottom);
OutTraceD("WindowProc: WS_NCCALCSIZE rect[2]=(%d,%d)-(%d,%d)\n",
OutTraceDW("WindowProc: WS_NCCALCSIZE rect[2]=(%d,%d)-(%d,%d)\n",
ncp->rgrc[2].left, ncp->rgrc[2].top, ncp->rgrc[2].right, ncp->rgrc[2].bottom);
OutTraceD("WindowProc: WS_NCCALCSIZE winrect=(%d,%d)-(%d,%d)\n",
OutTraceDW("WindowProc: WS_NCCALCSIZE winrect=(%d,%d)-(%d,%d)\n",
ncp->lppos->x, ncp->lppos->y, ncp->lppos->cx, ncp->lppos->cy);
}
}
@ -960,7 +973,7 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
case WM_IME_KEYDOWN:
case WM_IME_KEYUP:
if(dxw.dwFlags2 & SUPPRESSIME){
OutTraceD("WindowProc: SUPPRESS WinMsg=[0x%x]%s(%x,%x)\n", message, ExplainWinMessage(message), wparam, lparam);
OutTraceDW("WindowProc: SUPPRESS WinMsg=[0x%x]%s(%x,%x)\n", message, ExplainWinMessage(message), wparam, lparam);
return 0;
}
break;
@ -981,13 +994,13 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
break;
case WM_ERASEBKGND:
if(dxw.IsDesktop(hwnd)){
OutTraceD("WindowProc: WM_ERASEBKGND(%x,%x) - suppressed\n", wparam, lparam);
OutTraceDW("WindowProc: WM_ERASEBKGND(%x,%x) - suppressed\n", wparam, lparam);
return 1; // 1 == OK, erased
}
break;
case WM_DISPLAYCHANGE:
if ((dxw.dwFlags1 & LOCKWINPOS) && dxw.IsFullScreen()){
OutTraceD("WindowProc: prevent WM_DISPLAYCHANGE depth=%d size=(%d,%d)\n",
OutTraceDW("WindowProc: prevent WM_DISPLAYCHANGE depth=%d size=(%d,%d)\n",
wparam, HIWORD(lparam), LOWORD(lparam));
// v2.02.43: unless EMULATESURFACE is set, lock the screen resolution only, but not the color depth!
if(dxw.dwFlags1 & EMULATESURFACE) return 0;
@ -1001,7 +1014,7 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
LPWINDOWPOS wp;
wp = (LPWINDOWPOS)lparam;
dxwFixWindowPos("WindowProc", hwnd, lparam);
OutTraceD("WindowProc: WM_WINDOWPOSCHANGING fixed size=(%d,%d)\n", wp->cx, wp->cy);
OutTraceDW("WindowProc: WM_WINDOWPOSCHANGING fixed size=(%d,%d)\n", wp->cx, wp->cy);
break;
case WM_ENTERSIZEMOVE:
if(IsToBeLocked){
@ -1090,16 +1103,16 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
GetHookInfo()->CursorY=HIWORD(lparam);
break;
case WM_SETFOCUS:
OutTraceD("WindowProc: hwnd=%x GOT FOCUS\n", hwnd);
OutTraceDW("WindowProc: hwnd=%x GOT FOCUS\n", hwnd);
if (dxw.dwFlags1 & ENABLECLIPPING) extClipCursor(lpClipRegion);
break;
case WM_KILLFOCUS:
OutTraceD("WindowProc: hwnd=%x LOST FOCUS\n", hwnd);
OutTraceDW("WindowProc: hwnd=%x LOST FOCUS\n", hwnd);
if (dxw.dwFlags1 & CLIPCURSOR) dxw.EraseClipCursor();
if (dxw.dwFlags1 & ENABLECLIPPING) (*pClipCursor)(NULL);
break;
case WM_CLOSE:
OutTraceD("WindowProc: WM_CLOSE - terminating process\n");
OutTraceDW("WindowProc: WM_CLOSE - terminating process\n");
if(dxw.dwFlags3 & FORCE16BPP) RecoverScreenMode();
TerminateProcess(GetCurrentProcess(),0);
break;
@ -1108,7 +1121,7 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
switch (wparam){
case VK_F12:
if(dxw.dwFlags1 & CLIPCURSOR){
OutTraceD("WindowProc: WM_SYSKEYDOWN key=%x ToggleState=%x\n",wparam,ClipCursorToggleState);
OutTraceDW("WindowProc: WM_SYSKEYDOWN key=%x ToggleState=%x\n",wparam,ClipCursorToggleState);
ClipCursorToggleState = !ClipCursorToggleState;
ClipCursorToggleState ? dxw.SetClipCursor() : dxw.EraseClipCursor();
}
@ -1138,7 +1151,7 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
break;
case VK_F4:
if (dxw.dwFlags1 & HANDLEALTF4) {
OutTraceD("WindowProc: WM_SYSKEYDOWN(ALT-F4) - terminating process\n");
OutTraceDW("WindowProc: WM_SYSKEYDOWN(ALT-F4) - terminating process\n");
TerminateProcess(GetCurrentProcess(),0);
}
break;
@ -1180,12 +1193,12 @@ LRESULT CALLBACK extWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lp
return ret;
}
//OutTraceD("ASSERT: WindowProc mismatch hwnd=%x\n", hwnd);
//OutTraceDW("ASSERT: WindowProc mismatch hwnd=%x\n", hwnd);
// ??? maybe it's a normal condition, whenever you don't have a WindowProc routine
// like in Commandos 2. Flag it?
char sMsg[81];
sprintf(sMsg,"ASSERT: WindowProc mismatch hwnd=%x\n", hwnd);
OutTraceD(sMsg);
OutTraceDW(sMsg);
if (IsAssertEnabled) MessageBox(0, sMsg, "WindowProc", MB_OK | MB_ICONEXCLAMATION);
return (*pDefWindowProc)(hwnd, message, wparam, lparam);
}
@ -1209,7 +1222,7 @@ static void SaveScreenMode()
if(DoOnce) return;
DoOnce=TRUE;
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &InitDevMode);
OutTraceD("DXWND: Initial display mode WxH=(%dx%d) BitsPerPel=%d\n",
OutTraceDW("DXWND: Initial display mode WxH=(%dx%d) BitsPerPel=%d\n",
InitDevMode.dmPelsWidth, InitDevMode.dmPelsHeight, InitDevMode.dmBitsPerPel);
}
@ -1218,11 +1231,11 @@ static void RecoverScreenMode()
DEVMODE CurrentDevMode;
BOOL res;
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &CurrentDevMode);
OutTraceD("ChangeDisplaySettings: recover CURRENT WxH=(%dx%d) BitsPerPel=%d TARGET WxH=(%dx%d) BitsPerPel=%d\n",
OutTraceDW("ChangeDisplaySettings: recover CURRENT WxH=(%dx%d) BitsPerPel=%d TARGET WxH=(%dx%d) BitsPerPel=%d\n",
CurrentDevMode.dmPelsWidth, CurrentDevMode.dmPelsHeight, CurrentDevMode.dmBitsPerPel,
InitDevMode.dmPelsWidth, InitDevMode.dmPelsHeight, InitDevMode.dmBitsPerPel);
InitDevMode.dmFields = (DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT);
res=(*pChangeDisplaySettings)(&InitDevMode, 0);
res=(*pChangeDisplaySettingsA)(&InitDevMode, 0);
if(res) OutTraceE("ChangeDisplaySettings: ERROR err=%d at %d\n", GetLastError(), __LINE__);
}
@ -1231,11 +1244,11 @@ void SwitchTo16BPP()
DEVMODE CurrentDevMode;
BOOL res;
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &CurrentDevMode);
OutTraceD("ChangeDisplaySettings: CURRENT wxh=(%dx%d) BitsPerPel=%d -> 16\n",
OutTraceDW("ChangeDisplaySettings: CURRENT wxh=(%dx%d) BitsPerPel=%d -> 16\n",
CurrentDevMode.dmPelsWidth, CurrentDevMode.dmPelsHeight, CurrentDevMode.dmBitsPerPel);
CurrentDevMode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
CurrentDevMode.dmBitsPerPel = 16;
res=(*pChangeDisplaySettings)(&CurrentDevMode, CDS_UPDATEREGISTRY);
res=(*pChangeDisplaySettingsA)(&CurrentDevMode, CDS_UPDATEREGISTRY);
if(res) OutTraceE("ChangeDisplaySettings: ERROR err=%d at %d\n", GetLastError(), __LINE__);
}
@ -1243,13 +1256,13 @@ static void LockScreenMode(DWORD dmPelsWidth, DWORD dmPelsHeight, DWORD dmBitsPe
{
DEVMODE InitDevMode;
BOOL res;
OutTraceD("ChangeDisplaySettings: LOCK wxh=(%dx%d) BitsPerPel=%d -> wxh=(%dx%d) BitsPerPel=%d\n",
OutTraceDW("ChangeDisplaySettings: LOCK wxh=(%dx%d) BitsPerPel=%d -> wxh=(%dx%d) BitsPerPel=%d\n",
InitDevMode.dmPelsWidth, InitDevMode.dmPelsHeight, InitDevMode.dmBitsPerPel,
dmPelsWidth, dmPelsHeight, dmBitsPerPel);
if( (dmPelsWidth != InitDevMode.dmPelsWidth) ||
(dmPelsHeight !=InitDevMode.dmPelsHeight) ||
(dmBitsPerPel != InitDevMode.dmBitsPerPel)){
res=(*pChangeDisplaySettings)(&InitDevMode, 0);
res=(*pChangeDisplaySettingsA)(&InitDevMode, 0);
if(res) OutTraceE("ChangeDisplaySettings: ERROR err=%d at %d\n", GetLastError(), __LINE__);
}
}
@ -1300,7 +1313,7 @@ LONG WINAPI myUnhandledExceptionFilter(LPEXCEPTION_POINTERS ExceptionInfo)
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI extSetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter)
{
OutTraceD("SetUnhandledExceptionFilter: lpExceptionFilter=%x\n", lpTopLevelExceptionFilter);
OutTraceDW("SetUnhandledExceptionFilter: lpExceptionFilter=%x\n", lpTopLevelExceptionFilter);
extern LONG WINAPI myUnhandledExceptionFilter(LPEXCEPTION_POINTERS);
return (*pSetUnhandledExceptionFilter)(myUnhandledExceptionFilter);
}
@ -1310,7 +1323,7 @@ void HookExceptionHandler(void)
void *tmp;
HMODULE base;
OutTraceD("Set exception handlers\n");
OutTraceDW("Set exception handlers\n");
base=GetModuleHandle(NULL);
pSetUnhandledExceptionFilter = SetUnhandledExceptionFilter;
//v2.1.75 override default exception handler, if any....
@ -1385,15 +1398,15 @@ void SetSingleProcessAffinity(void)
DWORD ProcessAffinityMask, SystemAffinityMask;
if(!GetProcessAffinityMask(GetCurrentProcess(), &ProcessAffinityMask, &SystemAffinityMask))
OutTraceE("GetProcessAffinityMask: ERROR err=%d\n", GetLastError());
OutTraceD("Process affinity=%x\n", ProcessAffinityMask);
OutTraceDW("Process affinity=%x\n", ProcessAffinityMask);
for (i=0; i<(8 * sizeof(DWORD)); i++){
if (ProcessAffinityMask & 0x1) break;
ProcessAffinityMask >>= 1;
}
OutTraceD("First process affinity bit=%d\n", i);
OutTraceDW("First process affinity bit=%d\n", i);
ProcessAffinityMask &= 0x1;
for (; i; i--) ProcessAffinityMask <<= 1;
OutTraceD("Process affinity=%x\n", ProcessAffinityMask);
OutTraceDW("Process affinity=%x\n", ProcessAffinityMask);
if (!SetProcessAffinityMask(GetCurrentProcess(), ProcessAffinityMask))
OutTraceE("SetProcessAffinityMask: ERROR err=%d\n", GetLastError());
}
@ -1440,7 +1453,7 @@ void HookInit(TARGETMAP *target, HWND hwnd)
dxw.SethWnd((dxw.dwFlags1 & FIXPARENTWIN) ? GetParent(hwnd) : hwnd);
}
if(IsTraceD){
if(IsTraceDDRAW){
OutTrace("HookInit: path=\"%s\" module=\"%s\" dxversion=%s pos=(%d,%d) size=(%d,%d)",
target->path, target->module, dxversions[dxw.dwTargetDDVersion],
target->posx, target->posy, target->sizx, target->sizy);
@ -1448,6 +1461,19 @@ void HookInit(TARGETMAP *target, HWND hwnd)
else OutTrace("\n");
}
#if 0
if(dxw.dwFlags4 & ADDPROXYLIBS){
#define MAX_FILE_PATH 512
char sSourcePath[MAX_FILE_PATH+1];
char *p;
GetModuleFileName(GetModuleHandle("dxwnd"), sSourcePath, MAX_FILE_PATH);
p=&sSourcePath[strlen(sSourcePath)-strlen("dxwnd.dll")];
strcpy(p, "d3d9.dll");
OutTraceDW("HookInit: copy %s -> d3d9.dll\n", sSourcePath);
CopyFile(sSourcePath, "d3d9.dll", FALSE);
}
#endif
if (hwnd && IsDebug){
DWORD dwStyle, dwExStyle;
dwStyle=GetWindowLong(dxw.GethWnd(), GWL_STYLE);
@ -1489,7 +1515,7 @@ void HookInit(TARGETMAP *target, HWND hwnd)
OutTraceE("HookInit: LoadLibrary ERROR module=%s err=%d\n", sModule, GetLastError());
}
else {
OutTraceD("HookInit: hooking additional module=%s base=%x\n", sModule, base);
OutTraceDW("HookInit: hooking additional module=%s base=%x\n", sModule, base);
if (dxw.dwTFlags & OUTIMPORTTABLE) DumpImportTable(base);
HookModule(base, dxw.dwTargetDDVersion);
}
@ -1507,8 +1533,9 @@ void HookInit(TARGETMAP *target, HWND hwnd)
}
InitScreenParameters();
if(hwnd) HookWindowProc(hwnd);
if (IsDebug) OutTraceD("MoveWindow: target pos=(%d,%d) size=(%d,%d)\n", dxw.iPosX, dxw.iPosY, dxw.iSizX, dxw.iSizY); //v2.02.09
if (IsDebug) OutTraceDW("MoveWindow: target pos=(%d,%d) size=(%d,%d)\n", dxw.iPosX, dxw.iPosY, dxw.iSizX, dxw.iSizY); //v2.02.09
}
LPCSTR ProcToString(LPCSTR proc)
@ -1527,7 +1554,8 @@ FARPROC RemapLibrary(LPCSTR proc, HMODULE hModule, HookEntry_Type *Hooks)
for(; Hooks->APIName; Hooks++){
if (!strcmp(proc,Hooks->APIName)){
if (Hooks->StoreAddress) *(Hooks->StoreAddress)=(*pGetProcAddress)(hModule, proc);
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), (Hooks->StoreAddress) ? *(Hooks->StoreAddress) : 0);
OutTraceDW("GetProcAddress: hooking proc=%s addr=%x->%x\n",
ProcToString(proc), (Hooks->StoreAddress) ? *(Hooks->StoreAddress) : 0, Hooks->HookerAddress);
return Hooks->HookerAddress;
}
}

38
dll/dxwcore.cpp
View File

@ -37,14 +37,14 @@ dxwCore::~dxwCore()
void dxwCore::SetFullScreen(BOOL fs, int line)
{
OutTraceD("SetFullScreen: %s at %d\n", fs?"FULLSCREEN":"WINDOWED", line);
OutTraceDW("SetFullScreen: %s at %d\n", fs?"FULLSCREEN":"WINDOWED", line);
FullScreen=fs;
}
void dxwCore::SetFullScreen(BOOL fs)
{
if(dxw.dwFlags3 & FULLSCREENONLY) fs=TRUE;
OutTraceD("SetFullScreen: %s\n", fs?"FULLSCREEN":"WINDOWED");
OutTraceDW("SetFullScreen: %s\n", fs?"FULLSCREEN":"WINDOWED");
FullScreen=fs;
}
@ -84,7 +84,7 @@ void dxwCore::InitTarget(TARGETMAP *target)
void dxwCore::UnmarkPrimarySurface(LPDIRECTDRAWSURFACE ps)
{
int i;
// OutTraceD("PRIMARYSURFACE del %x\n",ps);
// OutTraceDW("PRIMARYSURFACE del %x\n",ps);
for (i=0;i<DDSQLEN;i++) {
if (PrimSurfaces[i]==(DWORD)ps) break;
if (PrimSurfaces[i]==0) break;
@ -101,7 +101,7 @@ void dxwCore::UnmarkPrimarySurface(LPDIRECTDRAWSURFACE ps)
void dxwCore::UnmarkBackBufferSurface(LPDIRECTDRAWSURFACE ps)
{
int i;
// OutTraceD("PRIMARYSURFACE del %x\n",ps);
// OutTraceDW("PRIMARYSURFACE del %x\n",ps);
for (i=0;i<DDSQLEN;i++) {
if (BackSurfaces[i]==(DWORD)ps) break;
if (BackSurfaces[i]==0) break;
@ -118,7 +118,7 @@ void dxwCore::UnmarkBackBufferSurface(LPDIRECTDRAWSURFACE ps)
void dxwCore::MarkPrimarySurface(LPDIRECTDRAWSURFACE ps)
{
int i;
// OutTraceD("PRIMARYSURFACE add %x\n",ps);
// OutTraceDW("PRIMARYSURFACE add %x\n",ps);
for (i=0;i<DDSQLEN;i++) {
if (PrimSurfaces[i]==(DWORD)ps) return; // if already there ....
if (PrimSurfaces[i]==(DWORD)0) break; // got end of list
@ -130,7 +130,7 @@ void dxwCore::MarkPrimarySurface(LPDIRECTDRAWSURFACE ps)
void dxwCore::MarkBackBufferSurface(LPDIRECTDRAWSURFACE ps)
{
int i;
// OutTraceD("PRIMARYSURFACE add %x\n",ps);
// OutTraceDW("PRIMARYSURFACE add %x\n",ps);
for (i=0;i<DDSQLEN;i++) {
if (BackSurfaces[i]==(DWORD)ps) return; // if already there ....
if (BackSurfaces[i]==(DWORD)0) break; // got end of list
@ -270,7 +270,7 @@ POINT dxwCore::FixCursorPos(POINT prev)
iRatioY = iSizY ? iSizY : 3;
if (!(*pGetClientRect)(hWnd, &rect)) { // v2.02.30: always use desktop win
OutTraceD("GetClientRect ERROR %d at %d\n", GetLastError(),__LINE__);
OutTraceDW("GetClientRect ERROR %d at %d\n", GetLastError(),__LINE__);
curr.x = curr.y = 0;
}
w = rect.right - rect.left;
@ -360,9 +360,9 @@ void dxwCore::SetClipCursor()
RECT Rect;
POINT UpLeftCorner={0,0};
OutTraceD("SetClipCursor:\n");
OutTraceDW("SetClipCursor:\n");
if (hWnd==NULL) {
OutTraceD("SetClipCursor: ASSERT hWnd==NULL\n");
OutTraceDW("SetClipCursor: ASSERT hWnd==NULL\n");
return;
}
if(!(*pGetClientRect)(hWnd, &Rect))
@ -376,19 +376,19 @@ void dxwCore::SetClipCursor()
(*pClipCursor)(NULL);
if(!(*pClipCursor)(&Rect))
OutTraceE("ClipCursor: ERROR err=%d at %d\n", GetLastError(), __LINE__);
OutTraceD("SetClipCursor: rect=(%d,%d)-(%d,%d)\n",
OutTraceDW("SetClipCursor: rect=(%d,%d)-(%d,%d)\n",
Rect.left, Rect.top, Rect.right, Rect.bottom);
}
void dxwCore::EraseClipCursor()
{
OutTraceD("EraseClipCursor:\n");
OutTraceDW("EraseClipCursor:\n");
(*pClipCursor)(NULL);
}
void dxwCore::SethWnd(HWND hwnd)
{
OutTraceD("SethWnd: setting main win=%x\n", hwnd);
OutTraceDW("SethWnd: setting main win=%x\n", hwnd);
hWnd=hwnd;
hWndFPS=hwnd;
}
@ -743,7 +743,7 @@ static void CountFPS(HWND hwnd)
char sBuf[80+15+1]; // title + fps string + terminator
char *fpss;
// log fps count
OutTrace("FPS: Delta=%x FPSCount=%d\n", (tmp-time), FPSCount);
// OutTrace("FPS: Delta=%x FPSCount=%d\n", (tmp-time), FPSCount);
// show fps count on status win
GetHookInfo()->FPSCount = FPSCount; // for overlay display
// show fps on win title bar
@ -1077,7 +1077,7 @@ void dxwCore::ShowBanner(HWND hwnd)
GetObject(g_hbmBall, sizeof(bm), &bm);
(*pGetWindowRect)(hwnd, &win);
OutTraceD("ShowBanner: hdc=%x win=(%d,%d)-(%d,%d) banner size=(%dx%d)\n",
OutTraceDW("ShowBanner: hwnd=%x win=(%d,%d)-(%d,%d) banner size=(%dx%d)\n",
hwnd, win.left, win.top, win.right, win.bottom, bm.bmWidth, bm.bmHeight);
//if(!pSetViewportOrgEx) pSetViewportOrgEx=SetViewportOrgEx;
@ -1153,7 +1153,7 @@ int dxwCore::GetDLLIndex(char *lpFileName)
(!lstrcmpi(lpName,SysNames[idx])) ||
(!lstrcmpi(lpName,SysNameExt))
){
OutTraceB("Registered DLL FileName=%s\n", lpFileName);
OutTraceDW("Registered DLL FileName=%s\n", lpFileName);
break;
}
}
@ -1168,7 +1168,7 @@ void dxwCore::FixStyle(char *ApiName, HWND hwnd, WPARAM wParam, LPARAM lParam)
switch (wParam) {
case GWL_STYLE:
OutTraceD("%s: new Style=%x(%s)\n",
OutTraceDW("%s: new Style=%x(%s)\n",
ApiName, lpSS->styleNew, ExplainStyle(lpSS->styleNew));
if (dxw.dwFlags1 & FIXWINFRAME){ // set canonical style
lpSS->styleNew= WS_OVERLAPPEDWINDOW;
@ -1178,13 +1178,13 @@ void dxwCore::FixStyle(char *ApiName, HWND hwnd, WPARAM wParam, LPARAM lParam)
}
if (dxw.dwFlags1 & PREVENTMAXIMIZE){ // disable maximize settings
if (lpSS->styleNew & WS_MAXIMIZE){
OutTraceD("%s: prevent maximize style\n", ApiName);
OutTraceDW("%s: prevent maximize style\n", ApiName);
lpSS->styleNew &= ~WS_MAXIMIZE;
}
}
break;
case GWL_EXSTYLE:
OutTraceD("%s: new ExStyle=%x(%s)\n",
OutTraceDW("%s: new ExStyle=%x(%s)\n",
ApiName, lpSS->styleNew, ExplainExStyle(lpSS->styleNew));
if (dxw.dwFlags1 & FIXWINFRAME){ // set canonical style
lpSS->styleNew= 0;
@ -1194,7 +1194,7 @@ void dxwCore::FixStyle(char *ApiName, HWND hwnd, WPARAM wParam, LPARAM lParam)
}
if ((dxw.dwFlags1 & PREVENTMAXIMIZE) && (hwnd==hWnd)){ // disable maximize settings
if (lpSS->styleNew & WS_EX_TOPMOST){
OutTraceD("%s: prevent EXSTYLE topmost style\n", ApiName);
OutTraceDW("%s: prevent EXSTYLE topmost style\n", ApiName);
lpSS->styleNew &= ~WS_EX_TOPMOST;
}
}

4
dll/dxwnd.cpp
View File

@ -24,7 +24,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "dxwnd.h"
#include "dxwcore.hpp"
#define VERSION "2.02.48"
#define VERSION "2.02.49"
#define DDTHREADLOCK 1
@ -92,7 +92,7 @@ int SetTarget(TARGETMAP *targets){
pStatus->Height = pStatus->Width = 0;
pStatus->DXVersion = 0;
for(i = 0; targets[i].path[0]; i ++){
//OutTraceD("SetTarget entry %s\n",pMapping[i].path);
//OutTraceDW("SetTarget entry %s\n",pMapping[i].path);
pMapping[i] = targets[i];
for(j = 0; pMapping[i].path[j]; j ++)
pMapping[i].path[j] = tolower(pMapping[i].path[j]);

BIN
dll/dxwnd.vs2008.suo
View File

Binary file not shown.

299
dll/gdi32.cpp
View File

File diff suppressed because it is too large Load Diff

522
dll/hd3d.cpp
View File

File diff suppressed because it is too large Load Diff

127
dll/hd3d7.cpp
View File

@ -9,8 +9,8 @@
// exported API
DWORD gD3DVersion; // quick & dirty ....
//#undef OutTraceD
//#define OutTraceD OutTrace
//#undef OutTraceDW
//#define OutTraceDW OutTrace
typedef HRESULT (WINAPI *Direct3DCreateDevice_Type)(GUID FAR *, LPDIRECT3D, LPDIRECTDRAWSURFACE, LPDIRECT3D *, LPUNKNOWN);
typedef HRESULT (WINAPI *Direct3DCreate_Type)(UINT, LPDIRECT3D *, LPUNKNOWN);
@ -106,6 +106,7 @@ int HookDirect3D7(HMODULE module, int version){
void *tmp;
HINSTANCE hinst;
LPDIRECT3D lpd3d=NULL;
HRESULT res;
gD3DVersion = version;
@ -122,22 +123,22 @@ int HookDirect3D7(HMODULE module, int version){
if(tmp) pDirect3DCreateDevice = (Direct3DCreateDevice_Type)tmp;
break;
case 7:
hinst = LoadLibrary("d3dim.dll");
hinst = (*pLoadLibraryA)("d3dim.dll");
if (hinst){
pDirect3DCreate =
(Direct3DCreate_Type)GetProcAddress(hinst, "Direct3DCreate");
(Direct3DCreate_Type)(*pGetProcAddress)(hinst, "Direct3DCreate");
if(pDirect3DCreate){
lpd3d = (LPDIRECT3D)extDirect3DCreate(0x0700, &lpd3d, NULL);
if(lpd3d) lpd3d->Release();
res = extDirect3DCreate(0x0700, &lpd3d, NULL);
if(res == DD_OK) lpd3d->Release();
}
}
else {
hinst = LoadLibrary("d3dim700.dll");
hinst = (*pLoadLibraryA)("d3dim700.dll");
pDirect3DCreate =
(Direct3DCreate_Type)GetProcAddress(hinst, "Direct3DCreate");
(Direct3DCreate_Type)(*pGetProcAddress)(hinst, "Direct3DCreate");
if(pDirect3DCreate){
lpd3d = (LPDIRECT3D)extDirect3DCreate(0x0700, &lpd3d, NULL);
if(lpd3d) lpd3d->Release();
res = extDirect3DCreate(0x0700, &lpd3d, NULL);
if(res == DD_OK) lpd3d->Release();
}
}
break;
@ -149,12 +150,12 @@ FARPROC Remap_d3d7_ProcAddress(LPCSTR proc, HMODULE hModule)
{
if (!strcmp(proc,"Direct3DCreate") && !pDirect3DCreate){
pDirect3DCreate=(Direct3DCreate_Type)(*pGetProcAddress)(hModule, proc);
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pDirect3DCreate);
OutTraceDW("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pDirect3DCreate);
return (FARPROC)extDirect3DCreate;
}
if (!strcmp(proc,"Direct3DCreateDevice") && !pDirect3DCreateDevice){
pDirect3DCreateDevice=(Direct3DCreateDevice_Type)(*pGetProcAddress)(hModule, proc);
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pDirect3DCreateDevice);
OutTraceDW("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pDirect3DCreateDevice);
return (FARPROC)extDirect3DCreateDevice;
}
// NULL -> keep the original call address
@ -165,17 +166,17 @@ HRESULT WINAPI extDirect3DCreateDevice(GUID FAR *lpGUID, LPDIRECT3D lpd3ddevice,
{
HRESULT res;
OutTraceD("Direct3DCreateDevice: guid=%x d3ddevice=%x dds=%x UnkOuter=%x\n",
OutTraceD3D("Direct3DCreateDevice: guid=%x d3ddevice=%x dds=%x UnkOuter=%x\n",
lpGUID, lpd3ddevice, 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 OutTraceD("Direct3DCreateDevice: d3ddevice=%x\n", *lplpd3ddevice);
else OutTraceD3D("Direct3DCreateDevice: d3ddevice=%x\n", *lplpd3ddevice);
return res;
}
void HookDirect3DSession(LPDIRECTDRAW *lplpdd, int dxversion)
{
OutTraceD("HookDirect3DSession: d3d=%x d3dversion=%d\n", *lplpdd, dxversion);
OutTraceDW("HookDirect3DSession: d3d=%x d3dversion=%d\n", *lplpdd, dxversion);
gD3DVersion = dxversion;
@ -213,7 +214,7 @@ void HookDirect3DSession(LPDIRECTDRAW *lplpdd, int dxversion)
void HookDirect3DDevice(void **lpd3ddev, int dxversion)
{
OutTraceD("HookDirect3DDevice: d3ddev=%x d3dversion=%d\n", lpd3ddev, dxversion);
OutTraceDW("HookDirect3DDevice: d3ddev=%x d3dversion=%d\n", lpd3ddev, dxversion);
gD3DVersion = dxversion;
@ -250,7 +251,7 @@ HRESULT WINAPI extDirect3DCreate(UINT SDKVersion, LPDIRECT3D *lplpd3d, LPUNKNOWN
{
HRESULT res;
OutTraceD("Direct3DCreate: SDKVersion=%x UnkOuter=%x\n", SDKVersion, pUnkOuter);
OutTraceD3D("Direct3DCreate: SDKVersion=%x UnkOuter=%x\n", SDKVersion, pUnkOuter);
res=(*pDirect3DCreate)(SDKVersion, lplpd3d, pUnkOuter);
if(res) {
@ -259,13 +260,13 @@ HRESULT WINAPI extDirect3DCreate(UINT SDKVersion, LPDIRECT3D *lplpd3d, LPUNKNOWN
}
HookDirect3DSession((LPDIRECTDRAW *)lplpd3d, SDKVersion);
OutTraceD("Direct3DCreate: d3d=%x\n", *lplpd3d);
OutTraceD3D("Direct3DCreate: d3d=%x\n", *lplpd3d);
return res;
}
void HookViewport(LPDIRECT3DVIEWPORT *lpViewport, int dxversion)
{
OutTraceD("HookViewport: Viewport=%x d3dversion=%d\n", *lpViewport, dxversion);
OutTraceDW("HookViewport: Viewport=%x d3dversion=%d\n", *lpViewport, dxversion);
switch(dxversion){
case 1:
@ -284,7 +285,7 @@ HRESULT WINAPI extQueryInterfaceD3(void *lpd3d, REFIID riid, LPVOID *ppvObj)
HRESULT res;
int d3dversion;
OutTraceD("QueryInterface(D3): d3d=%x REFIID=%x obj=%x\n", lpd3d, riid.Data1, ppvObj);
OutTraceD3D("QueryInterface(D3): d3d=%x REFIID=%x obj=%x\n", lpd3d, riid.Data1, ppvObj);
d3dversion=0;
res=(*pQueryInterfaceD3)(lpd3d, riid, ppvObj);
switch(riid.Data1){
@ -293,7 +294,7 @@ HRESULT WINAPI extQueryInterfaceD3(void *lpd3d, REFIID riid, LPVOID *ppvObj)
case 0xbb223240: d3dversion=6; break;
case 0xf5049e77: d3dversion=7; break;
}
if(d3dversion) OutTraceD("QueryInterface(D3): hooking version=%d\n", d3dversion);
if(d3dversion) OutTraceDW("QueryInterface(D3): hooking version=%d\n", d3dversion);
switch(d3dversion){
case 1:
SetHook((void *)(**(DWORD **)ppvObj + 12), extInitialize, (void **)&pInitialize, "Initialize");
@ -319,10 +320,10 @@ HRESULT WINAPI extInitialize(void *lpd3d)
{
HRESULT res;
OutTraceD("Initialize: d3d=%x\n", lpd3d);
OutTraceD3D("Initialize: d3d=%x\n", lpd3d);
res=(*pInitialize)(lpd3d);
if(res) OutTraceE("Initialize ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD("Initialize: OK\n");
else OutTraceD3D("Initialize: OK\n");
return res;
}
@ -333,7 +334,7 @@ typedef struct {
static void DumpD3DDevideDesc(LPD3DDEVICEDESC d3, char *label)
{
if(IsTraceD){
if(IsTraceD3D){
OutTrace("EnumDevices: CALLBACK dev=%s Size=%d Flags=%x ", label, d3->dwSize, d3->dwFlags);
if(d3->dwFlags & D3DDD_COLORMODEL) OutTrace("ColorModel=%x ", d3->dcmColorModel);
if(d3->dwFlags & D3DDD_DEVCAPS) OutTrace("DevCaps=%x ", d3->dwDevCaps);
@ -353,7 +354,7 @@ static void DumpD3DDevideDesc(LPD3DDEVICEDESC d3, char *label)
HRESULT WINAPI extDeviceProxy(GUID FAR *lpGuid, LPSTR lpDeviceDescription, LPSTR lpDeviceName, LPD3DDEVICEDESC lpd3ddd1, LPD3DDEVICEDESC lpd3ddd2, LPVOID arg)
{
HRESULT res;
OutTraceD("EnumDevices: CALLBACK GUID=%x(%s) DeviceDescription=\"%s\", DeviceName=\"%s\", arg=%x\n", lpGuid->Data1, ExplainGUID(lpGuid), lpDeviceDescription, lpDeviceName, ((CallbackArg *)arg)->arg);
OutTraceDW("EnumDevices: CALLBACK GUID=%x(%s) DeviceDescription=\"%s\", DeviceName=\"%s\", arg=%x\n", lpGuid->Data1, ExplainGUID(lpGuid), lpDeviceDescription, lpDeviceName, ((CallbackArg *)arg)->arg);
DumpD3DDevideDesc(lpd3ddd1, "HWDEV");
DumpD3DDevideDesc(lpd3ddd2, "SWDEV");
if(dxw.dwFlags4 & NOPOWER2FIX){
@ -369,7 +370,7 @@ HRESULT WINAPI extDeviceProxy(GUID FAR *lpGuid, LPSTR lpDeviceDescription, LPSTR
else {
res = (*(((CallbackArg *)arg)->cb))(lpGuid, lpDeviceDescription, lpDeviceName, lpd3ddd1, lpd3ddd2, ((CallbackArg *)arg)->arg);
}
OutTraceD("EnumDevices: CALLBACK ret=%x\n", res);
OutTraceDW("EnumDevices: CALLBACK ret=%x\n", res);
return res;
}
@ -378,12 +379,12 @@ HRESULT WINAPI extEnumDevices(void *lpd3d, LPD3DENUMDEVICESCALLBACK cb, LPVOID a
HRESULT res;
CallbackArg Arg;
OutTraceD("EnumDevices: d3d=%x arg=%x\n", lpd3d, arg);
OutTraceD3D("EnumDevices: d3d=%x arg=%x\n", lpd3d, arg);
Arg.cb= &cb;
Arg.arg=arg;
res=(*pEnumDevices)(lpd3d, (LPD3DENUMDEVICESCALLBACK)extDeviceProxy, (LPVOID)&Arg);
if(res) OutTraceE("EnumDevices ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD("EnumDevices: OK\n");
else OutTraceD3D("EnumDevices: OK\n");
return res;
}
@ -391,10 +392,10 @@ HRESULT WINAPI extCreateLight(void *lpd3d, LPDIRECT3DLIGHT *lpLight, IUnknown *p
{
HRESULT res;
OutTraceD("CreateLight: d3d=%x\n", lpd3d);
OutTraceD3D("CreateLight: d3d=%x\n", lpd3d);
res=(*pCreateLight)(lpd3d, lpLight, p0);
if(res) OutTraceE("CreateLight ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD("CreateLight: OK\n");
else OutTraceD3D("CreateLight: OK\n");
return res;
}
@ -402,10 +403,10 @@ HRESULT WINAPI extCreateMaterial(void *lpd3d, LPDIRECT3DMATERIAL *lpMaterial, IU
{
HRESULT res;
OutTraceD("CreateMaterial: d3d=%x\n", lpd3d);
OutTraceD3D("CreateMaterial: d3d=%x\n", lpd3d);
res=(*pCreateMaterial)(lpd3d, lpMaterial, p0);
if(res) OutTraceE("CreateMaterial ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD("CreateMaterial: OK\n");
else OutTraceD3D("CreateMaterial: OK\n");
return res;
}
@ -413,10 +414,10 @@ HRESULT WINAPI extCreateViewport(void *lpd3d, LPDIRECT3DVIEWPORT *lpViewport, IU
{
HRESULT res;
OutTraceD("CreateViewport: d3d=%x\n", lpd3d);
OutTraceD3D("CreateViewport: d3d=%x\n", lpd3d);
res=(*pCreateViewport)(lpd3d, lpViewport, p0);
if(res) OutTraceE("CreateViewport ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD("CreateViewport: Viewport=%x\n", *lpViewport);
else OutTraceD3D("CreateViewport: Viewport=%x\n", *lpViewport);
HookViewport(lpViewport, gD3DVersion);
return res;
}
@ -425,12 +426,12 @@ HRESULT WINAPI extFindDevice(void *lpd3d, LPD3DFINDDEVICESEARCH p1, LPD3DFINDDEV
{
HRESULT res;
OutTraceD("FindDevice: d3d=%x devsearch=%x (size=%d flags=%x caps=%x primcaps=%x colormodel=%x hw=%x guid=%x) p2=%x\n",
OutTraceD3D("FindDevice: 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);
res=(*pFindDevice)(lpd3d, p1, p2);
if(res) OutTraceE("FindDevice ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else {
OutTraceD("FindDevice: GUID=%x.%x.%x.%x\n", p2->guid.Data1, p2->guid.Data2, p2->guid.Data3, p2->guid.Data4);
OutTraceD3D("FindDevice: GUID=%x.%x.%x.%x\n", p2->guid.Data1, p2->guid.Data2, p2->guid.Data3, p2->guid.Data4);
DumpD3DDevideDesc(&(p2->ddHwDesc), "HWDEV");
DumpD3DDevideDesc(&(p2->ddSwDesc), "SWDEV");
}
@ -441,12 +442,12 @@ HRESULT WINAPI extSetViewport(void *lpvp, LPD3DVIEWPORT vpd)
{
HRESULT res;
OutTraceD("SetViewport: viewport=%x viewportd=%x size=%d pos=(%d,%d) dim=(%dx%d) scale=(%fx%f) maxXYZ=(%f,%f,%f) minZ=%f\n",
OutTraceD3D("SetViewport: viewport=%x viewportd=%x size=%d pos=(%d,%d) dim=(%dx%d) scale=(%fx%f) maxXYZ=(%f,%f,%f) minZ=%f\n",
lpvp, vpd, vpd->dwSize, vpd->dwX, vpd->dwY, vpd->dwHeight, vpd->dwWidth, vpd->dvScaleX, vpd->dvScaleY,
vpd->dvMaxX, vpd->dvMaxY, vpd->dvMaxZ, vpd->dvMinZ);
res=(*pSetViewport)(lpvp, vpd);
if(res) OutTraceE("SetViewport ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD("SetViewport: OK\n");
else OutTraceD3D("SetViewport: OK\n");
return res;
}
@ -454,10 +455,10 @@ HRESULT WINAPI extGetViewport(void *lpvp, LPD3DVIEWPORT vpd)
{
HRESULT res;
OutTraceD("GetViewport: viewport=%x viewportd=%x\n", lpvp, vpd);
OutTraceD3D("GetViewport: viewport=%x viewportd=%x\n", lpvp, vpd);
res=(*pGetViewport)(lpvp, vpd);
if(res) OutTraceE("GetViewport ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD("GetViewport: OK size=%d pos=(%d,%d) dim=(%dx%d) scale=(%fx%f) maxXYZ=(%f,%f,%f) minZ=%f\n",
else OutTraceD3D("GetViewport: OK size=%d pos=(%d,%d) dim=(%dx%d) scale=(%fx%f) maxXYZ=(%f,%f,%f) minZ=%f\n",
vpd->dwSize, vpd->dwX, vpd->dwY, vpd->dwHeight, vpd->dwWidth, vpd->dvScaleX, vpd->dvScaleY,
vpd->dvMaxX, vpd->dvMaxY, vpd->dvMaxZ, vpd->dvMinZ);
return res;
@ -467,10 +468,10 @@ HRESULT WINAPI extInitializeVP(void *lpvp, LPDIRECT3D lpd3d)
{
HRESULT res;
OutTraceD("Initialize(VP): viewport=%x d3d=%x\n", lpvp, lpd3d);
OutTraceD3D("Initialize(VP): viewport=%x d3d=%x\n", lpvp, lpd3d);
res=(*pInitializeVP)(lpvp, lpd3d);
if(res) OutTraceE("Initialize(VP) ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
else OutTraceD("Initialize(VP): OK \n");
else OutTraceD3D("Initialize(VP): OK \n");
return res;
}
@ -478,14 +479,14 @@ HRESULT WINAPI extCreateDevice2(void *lpd3d, REFCLSID Guid, LPDIRECTDRAWSURFACE
{
HRESULT res;
OutTraceD("CreateDevice(D3D2): d3d=%x GUID=%x(%s) lpdds=%x\n", lpd3d, Guid.Data1, ExplainGUID((GUID *)&Guid), lpdds);
OutTraceD3D("CreateDevice(D3D2): d3d=%x GUID=%x(%s) lpdds=%x\n", lpd3d, Guid.Data1, ExplainGUID((GUID *)&Guid), lpdds);
res=(*pCreateDevice2)(lpd3d, Guid, lpdds, lplpd3dd);
if(res) {
OutTraceE("CreateDevice(D3D2) ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
return res;
}
else
OutTraceD("CreateDevice(D3D2): lpd3dd=%x\n", lpd3d, *lplpd3dd);
OutTraceD3D("CreateDevice(D3D2): lpd3dd=%x\n", lpd3d, *lplpd3dd);
HookDirect3DDevice((void **)lplpd3dd, 2);
return res;
@ -501,7 +502,7 @@ HRESULT WINAPI extCreateDevice3(void *lpd3d, REFCLSID Guid, LPDIRECTDRAWSURFACE4
GUID IID_IDirect3DRampDevice = {0xF2086B20,0x259F,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56};
GUID IID_IDirect3DMMXDevice = {0x881949a1,0xd6f3,0x11d0,0x89,0xab,0x00,0xa0,0xc9,0x05,0x41,0x29};
OutTraceD("CreateDevice(D3D3): d3d=%x GUID=%x(%s) lpdds=%x\n", lpd3d, Guid.Data1, ExplainGUID((GUID *)&Guid), lpdds);
OutTraceD3D("CreateDevice(D3D3): d3d=%x GUID=%x(%s) lpdds=%x\n", lpd3d, Guid.Data1, ExplainGUID((GUID *)&Guid), lpdds);
res=(*pCreateDevice3)(lpd3d, Guid, lpdds, lplpd3dd, unk);
//res=(*pCreateDevice3)(lpd3d, IID_IDirect3DMMXDevice, lpdds, lplpd3dd, unk);
if(res) {
@ -528,7 +529,7 @@ HRESULT WINAPI extCreateDevice3(void *lpd3d, REFCLSID Guid, LPDIRECTDRAWSURFACE4
HRESULT WINAPI extD3DInitialize(void *d3dd, LPDIRECT3D lpd3d, LPGUID lpGuid, LPD3DDEVICEDESC lpd3dd)
{
HRESULT res;
OutTrace("Initialize: d3dd=%x lpd3d=%x GUID=%x lpd3ddd=%x\n", d3dd, lpd3d, lpGuid->Data1, lpd3dd);
OutTraceD3D("Initialize: d3dd=%x lpd3d=%x GUID=%x lpd3ddd=%x\n", d3dd, lpd3d, lpGuid->Data1, lpd3dd);
res=(*pD3DInitialize)(d3dd, lpd3d, lpGuid, lpd3dd);
if(res) OutTraceE("Initialize ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
DumpD3DDevideDesc(lpd3dd, "INIT");
@ -538,7 +539,7 @@ HRESULT WINAPI extD3DInitialize(void *d3dd, LPDIRECT3D lpd3d, LPGUID lpGuid, LPD
HRESULT WINAPI extD3DGetCaps(void *d3dd, LPD3DDEVICEDESC lpd3dd ,LPD3DDEVICEDESC lpd3dd2)
{
HRESULT res;
OutTrace("GetCaps(D3D): d3dd=%x lpd3dd=%x lpd3dd2=%x \n", d3dd, lpd3dd, lpd3dd2);
OutTraceD3D("GetCaps(D3D): d3dd=%x lpd3dd=%x lpd3dd2=%x \n", d3dd, lpd3dd, lpd3dd2);
res=(*pD3DGetCaps)(d3dd, lpd3dd, lpd3dd2);
if(res) OutTraceE("GetCaps(D3D) ERROR: err=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__);
DumpD3DDevideDesc(lpd3dd, "HWDEV");
@ -586,16 +587,16 @@ char *ExplainRenderstateValue(DWORD Value)
HRESULT WINAPI extSetRenderState2(void *d3dd, D3DRENDERSTATETYPE State, DWORD Value)
{
HRESULT res;
OutTraceD("SetRenderState(2): d3dd=%x State=%x(%s) Value=%x\n", d3dd, State, ExplainD3DRenderState(State), Value);
OutTraceD3D("SetRenderState(2): d3dd=%x State=%x(%s) Value=%x\n", d3dd, State, ExplainD3DRenderState(State), Value);
if((dxw.dwFlags4 & ZBUFFERALWAYS) && (State == D3DRENDERSTATE_ZFUNC)) {
DWORD OldValue;
OldValue = Value;
Value = D3DCMP_ALWAYS;
OutTraceD("SetRenderState: FIXED State=ZFUNC Value=%s->D3DCMP_ALWAYS\n", ExplainRenderstateValue(OldValue));
OutTraceDW("SetRenderState: FIXED State=ZFUNC Value=%s->D3DCMP_ALWAYS\n", ExplainRenderstateValue(OldValue));
}
if((dxw.dwFlags2 & WIREFRAME) && (State == D3DRENDERSTATE_FILLMODE)){
Value = D3DFILL_WIREFRAME;
OutTraceD("SetRenderState: FIXED State=FILLMODE Value=D3DFILL_WIREFRAME\n");
OutTraceDW("SetRenderState: FIXED State=FILLMODE Value=D3DFILL_WIREFRAME\n");
}
res=(*pSetRenderState2)(d3dd, State, Value);
if(res) OutTraceE("SetRenderState(2): res=%x(%s)\n", res, ExplainDDError(res));
@ -605,19 +606,19 @@ HRESULT WINAPI extSetRenderState2(void *d3dd, D3DRENDERSTATETYPE State, DWORD Va
HRESULT WINAPI extSetRenderState3(void *d3dd, D3DRENDERSTATETYPE State, DWORD Value)
{
HRESULT res;
OutTraceD("SetRenderState(3): d3dd=%x State=%x(%s) Value=%x\n", d3dd, State, ExplainD3DRenderState(State), Value);
OutTraceD3D("SetRenderState(3): d3dd=%x State=%x(%s) Value=%x\n", d3dd, State, ExplainD3DRenderState(State), Value);
if((dxw.dwFlags4 & ZBUFFERALWAYS) && (State == D3DRENDERSTATE_ZFUNC)) {
DWORD OldValue;
OldValue = Value;
Value = D3DCMP_ALWAYS;
OutTraceD("SetRenderState: FIXED State=ZFUNC Value=%s->D3DCMP_ALWAYS\n", ExplainRenderstateValue(OldValue));
OutTraceDW("SetRenderState: FIXED State=ZFUNC Value=%s->D3DCMP_ALWAYS\n", ExplainRenderstateValue(OldValue));
}
if((dxw.dwFlags2 & WIREFRAME) && (State == D3DRENDERSTATE_FILLMODE)){
Value = D3DFILL_WIREFRAME;
OutTraceD("SetRenderState: FIXED State=FILLMODE Value=D3DFILL_WIREFRAME\n");
OutTraceDW("SetRenderState: FIXED State=FILLMODE Value=D3DFILL_WIREFRAME\n");
}
if((dxw.dwFlags4 & DISABLEFOGGING) && (State == D3DRENDERSTATE_FOGENABLE)){
OutTraceD("SetRenderState: FIXED State=FOGENABLE Value=FALSE\n");
OutTraceDW("SetRenderState: FIXED State=FOGENABLE Value=FALSE\n");
Value = FALSE;
}
res=(*pSetRenderState3)(d3dd, State, Value);
@ -628,7 +629,7 @@ HRESULT WINAPI extSetRenderState3(void *d3dd, D3DRENDERSTATETYPE State, DWORD Va
HRESULT WINAPI extBeginScene1(void *d3dd)
{
HRESULT res;
OutTraceD("BeginScene(1): d3dd=%x\n", d3dd);
OutTraceD3D("BeginScene(1): d3dd=%x\n", d3dd);
res=(*pBeginScene1)(d3dd);
if(res) OutTraceE("BeginScene(1): res=%x(%s)\n", res, ExplainDDError(res));
return res;
@ -637,7 +638,7 @@ HRESULT WINAPI extBeginScene1(void *d3dd)
HRESULT WINAPI extBeginScene2(void *d3dd)
{
HRESULT res;
OutTraceD("BeginScene(2): d3dd=%x\n", d3dd);
OutTraceD3D("BeginScene(2): d3dd=%x\n", d3dd);
if(dxw.dwFlags4 & ZBUFFERCLEAN){
HRESULT res2;
LPDIRECT3DVIEWPORT2 vp;
@ -651,7 +652,7 @@ HRESULT WINAPI extBeginScene2(void *d3dd)
d3dRect.y1 = vpd.dwY;
d3dRect.x2 = vpd.dwX + vpd.dwWidth;
d3dRect.y2 = vpd.dwY + vpd.dwHeight;
OutTraceD("d3dRect=(%d,%d)-(%d,%d)\n", d3dRect.x1, d3dRect.y1, d3dRect.x2, d3dRect.y2);
OutTraceDW("d3dRect=(%d,%d)-(%d,%d)\n", d3dRect.x1, d3dRect.y1, d3dRect.x2, d3dRect.y2);
vp->Clear(1, &d3dRect, D3DCLEAR_ZBUFFER);
}
}
@ -663,7 +664,7 @@ HRESULT WINAPI extBeginScene2(void *d3dd)
HRESULT WINAPI extBeginScene3(void *d3dd)
{
HRESULT res;
OutTraceD("BeginScene(3): d3dd=%x\n", d3dd);
OutTraceD3D("BeginScene(3): d3dd=%x\n", d3dd);
if(dxw.dwFlags4 & (ZBUFFERCLEAN|ZBUFFER0CLEAN)){
HRESULT res2;
LPDIRECT3DVIEWPORT3 vp;
@ -677,7 +678,7 @@ HRESULT WINAPI extBeginScene3(void *d3dd)
d3dRect.y1 = vpd.dwY;
d3dRect.x2 = vpd.dwX + vpd.dwWidth;
d3dRect.y2 = vpd.dwY + vpd.dwHeight;
OutTraceD("d3dRect=(%d,%d)-(%d,%d)\n", d3dRect.x1, d3dRect.y1, d3dRect.x2, d3dRect.y2);
OutTraceDW("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);
}
@ -690,7 +691,7 @@ HRESULT WINAPI extBeginScene3(void *d3dd)
HRESULT WINAPI extEndScene1(void *d3dd)
{
HRESULT res;
OutTraceD("EndScene(1): d3dd=%x\n", d3dd);
OutTraceD3D("EndScene(1): d3dd=%x\n", d3dd);
res=(*pEndScene1)(d3dd);
//dxw.ShowOverlay();
if(res) OutTraceE("EndScene(1): res=%x(%s)\n", res, ExplainDDError(res));
@ -700,7 +701,7 @@ HRESULT WINAPI extEndScene1(void *d3dd)
HRESULT WINAPI extEndScene2(void *d3dd)
{
HRESULT res;
OutTraceD("EndScene(2): d3dd=%x\n", d3dd);
OutTraceD3D("EndScene(2): d3dd=%x\n", d3dd);
res=(*pEndScene2)(d3dd);
//dxw.ShowOverlay();
if(res) OutTraceE("EndScene(2): res=%x(%s)\n", res, ExplainDDError(res));
@ -710,7 +711,7 @@ HRESULT WINAPI extEndScene2(void *d3dd)
HRESULT WINAPI extEndScene3(void *d3dd)
{
HRESULT res;
OutTraceD("EndScene(3): d3dd=%x\n", d3dd);
OutTraceD3D("EndScene(3): d3dd=%x\n", d3dd);
res=(*pEndScene3)(d3dd);
//dxw.ShowOverlay();
if(res) OutTraceE("EndScene(3): res=%x(%s)\n", res, ExplainDDError(res));
@ -720,7 +721,7 @@ HRESULT WINAPI extEndScene3(void *d3dd)
HRESULT WINAPI extGetCaps3(void *d3dd, LPD3DDEVICEDESC hd, LPD3DDEVICEDESC sd)
{
HRESULT res;
OutTraceD("GetCaps(3): d3dd=%x hd=%x sd=%x\n", d3dd, hd, sd);
OutTraceD3D("GetCaps(3): d3dd=%x hd=%x sd=%x\n", d3dd, hd, sd);
res=(*pGetCaps3)(d3dd, hd, sd);
if(res) {
OutTraceE("GetCaps(3): res=%x(%s)\n", res, ExplainDDError(res));

16
dll/imelib.cpp
View File

@ -35,49 +35,49 @@ FARPROC Remap_ImeLib_ProcAddress(LPCSTR proc, HMODULE hModule)
BOOL WINAPI extImmNotifyIME(HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
{
OutTraceD("ImmNotifyIME: hIMC=%x dwAction=%x dwIndex=%x dwValue=%x\n", hIMC, dwAction, dwIndex, dwValue);
OutTraceDW("ImmNotifyIME: hIMC=%x dwAction=%x dwIndex=%x dwValue=%x\n", hIMC, dwAction, dwIndex, dwValue);
return(*pImmNotifyIME)(hIMC, dwAction, dwIndex, dwValue);
}
HIMC WINAPI extImmCreateContext(void)
{
OutTraceD("ImmCreateContext\n");
OutTraceDW("ImmCreateContext\n");
return(*pImmCreateContext)();
}
BOOL WINAPI extImmDestroyContext(HIMC hIMC)
{
OutTraceD("ImmDestroyContext: hIMC=%x\n", hIMC);
OutTraceDW("ImmDestroyContext: hIMC=%x\n", hIMC);
return(*pImmDestroyContext)(hIMC);
}
BOOL WINAPI extImmSetOpenStatus(HIMC hIMC, BOOL fOpen)
{
OutTraceD("ImmSetOpenStatus: hIMC=%x fOpen=%x\n", hIMC, fOpen);
OutTraceDW("ImmSetOpenStatus: hIMC=%x fOpen=%x\n", hIMC, fOpen);
return(*pImmSetOpenStatus)(hIMC, fOpen);
}
HIMC WINAPI extImmAssociateContext(HWND hwnd, HIMC hIMC)
{
OutTraceD("ImmAssociateContext: hwnd=%x hIMC=%x\n", hwnd, hIMC);
OutTraceDW("ImmAssociateContext: hwnd=%x hIMC=%x\n", hwnd, hIMC);
//return NULL;
return(*pImmAssociateContext)(hwnd, hIMC);
}
BOOL WINAPI extImmSetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
{
OutTraceD("ImmSetCompositionWindow: hIMC=%x lpCompForm=%x\n", hIMC, lpCompForm);
OutTraceDW("ImmSetCompositionWindow: hIMC=%x lpCompForm=%x\n", hIMC, lpCompForm);
return(*pImmSetCompositionWindow)(hIMC, lpCompForm);
}
BOOL WINAPI extImmSetCompositionString(HIMC hIMC, DWORD dwIndex, LPVOID lpComp, DWORD dwCompLen, LPVOID lpRead, DWORD dwReadLen)
{
OutTraceD("ImmSetCompositionString: hIMC=%x dwIndex=%x lpComp=%x dwCompLen=%x dwRead=%x dwReadLen=%x\n", hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
OutTraceDW("ImmSetCompositionString: hIMC=%x dwIndex=%x lpComp=%x dwCompLen=%x dwRead=%x dwReadLen=%x\n", hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
return (*pImmSetCompositionString)(hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
}
BOOL WINAPI extImmGetOpenStatus(HIMC hIMC)
{
OutTraceD("ImmGetOpenStatus: hIMC=%x\n", hIMC);
OutTraceDW("ImmGetOpenStatus: hIMC=%x\n", hIMC);
return(*pImmGetOpenStatus)(hIMC);
}

112
dll/kernel32.cpp
View File

@ -40,6 +40,7 @@ static HookEntry_Type TimeHooks[]={
{"SleepEx", (FARPROC)SleepEx, (FARPROC *)&pSleepEx, (FARPROC)extSleepEx},
{"SetTimer", (FARPROC)SetTimer, (FARPROC *)&pSetTimer, (FARPROC)extSetTimer},
{"QueryPerformanceCounter", (FARPROC)NULL, (FARPROC *)&pQueryPerformanceCounter, (FARPROC)extQueryPerformanceCounter},
{"QueryPerformanceFrequency", (FARPROC)NULL, (FARPROC *)&pQueryPerformanceFrequency, (FARPROC)extQueryPerformanceFrequency},
{0, NULL, 0, 0} // terminator
};
@ -64,6 +65,26 @@ void HookKernel32(HMODULE module)
if(dxw.dwFlags2 & TIMESTRETCH) HookLibrary(module, TimeHooks, libname);
if(dxw.dwFlags2 & FAKEVERSION) HookLibrary(module, VersionHooks, libname);
if(dxw.dwFlags4 & SUPPRESSCHILD) HookLibrary(module, SuppressChildHooks, libname);
#if 0
if(dxw.dwFlags2 & TIMESTRETCH){
HINSTANCE hinst;
LARGE_INTEGER myPerfCount;
hinst = LoadLibrary("kernel32.dll");
pQueryPerformanceFrequency=(QueryPerformanceFrequency_Type)GetProcAddress(hinst, "QueryPerformanceFrequency");
pQueryPerformanceCounter=(QueryPerformanceCounter_Type)GetProcAddress(hinst, "QueryPerformanceCounter");
pGetTickCount=(GetTickCount_Type)GetProcAddress(hinst, "GetTickCount");
if(pQueryPerformanceFrequency){
HookAPI(hinst, "kernel32.dll", pQueryPerformanceFrequency, "QueryPerformanceFrequency", extQueryPerformanceFrequency);
HookAPI(hinst, "kernel32.dll", pQueryPerformanceCounter, "QueryPerformanceCounter", extQueryPerformanceCounter);
extQueryPerformanceFrequency(&myPerfCount);
}
if(pGetTickCount){
HookAPI(hinst, "kernel32.dll", pGetTickCount, "GetTickCount", extGetTickCount);
extGetTickCount();
}
}
#endif
}
void HookKernel32Init()
@ -78,6 +99,14 @@ FARPROC Remap_kernel32_ProcAddress(LPCSTR proc, HMODULE hModule)
{
FARPROC addr;
if (dxw.dwFlags4 & NOPERFCOUNTER){
if( !strcmp(proc, "QueryPerformanceCounter") ||
!strcmp(proc, "QueryPerformanceFrequency")){
OutTraceDW("GetProcAddress: HIDING proc=%s\n", proc);
return NULL;
}
}
if (addr=RemapLibrary(proc, hModule, Hooks)) return addr;
if(dxw.dwFlags3 & BUFFEREDIOFIX)
@ -106,14 +135,14 @@ extern void HookModule(HMODULE, int);
int WINAPI extIsDebuggerPresent(void)
{
OutTraceD("extIsDebuggerPresent: return FALSE\n");
OutTraceDW("extIsDebuggerPresent: return FALSE\n");
return FALSE;
}
BOOL WINAPI extGetDiskFreeSpaceA(LPCSTR lpRootPathName, LPDWORD lpSectorsPerCluster, LPDWORD lpBytesPerSector, LPDWORD lpNumberOfFreeClusters, LPDWORD lpTotalNumberOfClusters)
{
BOOL ret;
OutTraceD("GetDiskFreeSpace: RootPathName=\"%s\"\n", lpRootPathName);
OutTraceDW("GetDiskFreeSpace: RootPathName=\"%s\"\n", lpRootPathName);
ret=(*pGetDiskFreeSpaceA)(lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters);
if(!ret) OutTraceE("GetDiskFreeSpace: ERROR err=%d at %d\n", GetLastError(), __LINE__);
*lpNumberOfFreeClusters = 16000;
@ -142,7 +171,7 @@ BIGENOUGH 0x20000000 // surely positive !!!
void WINAPI extGlobalMemoryStatus(LPMEMORYSTATUS lpBuffer)
{
(*pGlobalMemoryStatus)(lpBuffer);
OutTraceD("GlobalMemoryStatus: Length=%x MemoryLoad=%x "
OutTraceDW("GlobalMemoryStatus: Length=%x MemoryLoad=%x "
"TotalPhys=%x AvailPhys=%x TotalPageFile=%x AvailPageFile=%x TotalVirtual=%x AvailVirtual=%x\n",
lpBuffer->dwMemoryLoad, lpBuffer->dwTotalPhys, lpBuffer->dwAvailPhys,
lpBuffer->dwTotalPageFile, lpBuffer->dwAvailPageFile, lpBuffer->dwTotalVirtual, lpBuffer->dwAvailVirtual);
@ -200,7 +229,7 @@ BOOL WINAPI extGetVersionEx(LPOSVERSIONINFO lpVersionInfo)
return ret;
}
OutTraceD("GetVersionEx: version=%d.%d build=(%d)\n",
OutTraceDW("GetVersionEx: version=%d.%d build=(%d)\n",
lpVersionInfo->dwMajorVersion, lpVersionInfo->dwMinorVersion, lpVersionInfo->dwBuildNumber);
if(dxw.dwFlags2 & FAKEVERSION) {
@ -208,7 +237,7 @@ BOOL WINAPI extGetVersionEx(LPOSVERSIONINFO lpVersionInfo)
lpVersionInfo->dwMajorVersion = WinVersions[dxw.FakeVersionId].bMajor;
lpVersionInfo->dwMinorVersion = WinVersions[dxw.FakeVersionId].bMinor;
lpVersionInfo->dwBuildNumber = 0;
OutTraceD("GetVersionEx: FIXED version=%d.%d build=(%d) os=\"%s\"\n",
OutTraceDW("GetVersionEx: FIXED version=%d.%d build=(%d) os=\"%s\"\n",
lpVersionInfo->dwMajorVersion, lpVersionInfo->dwMinorVersion, lpVersionInfo->dwBuildNumber,
WinVersions[dxw.FakeVersionId].sName);
}
@ -234,14 +263,14 @@ DWORD WINAPI extGetVersion(void)
if (dwVersion < 0x80000000)
dwBuild = (DWORD)(HIWORD(dwVersion));
OutTraceD("GetVersion: version=%d.%d build=(%d)\n", dwMajorVersion, dwMinorVersion, dwBuild);
OutTraceDW("GetVersion: version=%d.%d build=(%d)\n", dwMajorVersion, dwMinorVersion, dwBuild);
if(dxw.dwFlags2 & FAKEVERSION) {
dwVersion = WinVersions[dxw.FakeVersionId].bMajor | (WinVersions[dxw.FakeVersionId].bMinor << 8);
dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
dwBuild = (DWORD)(HIWORD(dwVersion));
OutTraceD("GetVersion: FIXED version=%d.%d build=(%d) os=\"%s\"\n",
OutTraceDW("GetVersion: FIXED version=%d.%d build=(%d) os=\"%s\"\n",
dwMajorVersion, dwMinorVersion, dwBuild, WinVersions[dxw.FakeVersionId].sName);
}
@ -330,7 +359,7 @@ HMODULE WINAPI LoadLibraryExWrapper(LPCTSTR lpFileName, HANDLE hFile, DWORD dwFl
int idx;
libhandle=(*pLoadLibraryExA)(lpFileName, hFile, dwFlags);
OutTraceD("%s: FileName=%s hFile=%x Flags=%x(%s) hmodule=%x\n", api, lpFileName, hFile, dwFlags, ExplainLoadLibFlags(dwFlags), libhandle);
OutTraceDW("%s: FileName=%s hFile=%x Flags=%x(%s) hmodule=%x\n", api, lpFileName, hFile, dwFlags, ExplainLoadLibFlags(dwFlags), libhandle);
if(!libhandle){
OutTraceE("%s: ERROR FileName=%s err=%d\n", api, lpFileName, GetLastError());
return libhandle;
@ -348,6 +377,13 @@ HMODULE WINAPI LoadLibraryExWrapper(LPCTSTR lpFileName, HANDLE hFile, DWORD dwFl
SysLibs[idx]=libhandle;
}
if (idx == -1) HookModule(libhandle, 0);
#if 0
switch(idx){
case SYSLIBIDX_DIRECTDRAW: HookDirectDraw(libhandle, 0); break;
case SYSLIBIDX_DIRECT3D8: HookDirect3D(libhandle, 8); break;
case SYSLIBIDX_DIRECT3D9: HookDirect3D(libhandle, 9); break;
}
#endif
return libhandle;
}
@ -393,7 +429,7 @@ FARPROC WINAPI extGetProcAddress(HMODULE hModule, LPCSTR proc)
// If this parameter is an ordinal value, it must be in the low-order word;
// the high-order word must be zero.
OutTraceD("GetProcAddress: hModule=%x proc=%s\n", hModule, ProcToString(proc));
OutTraceDW("GetProcAddress: hModule=%x proc=%s\n", hModule, ProcToString(proc));
for(idx=0; idx<SYSLIBIDX_MAX; idx++){
if(SysLibs[idx]==hModule) break;
@ -468,12 +504,12 @@ FARPROC WINAPI extGetProcAddress(HMODULE hModule, LPCSTR proc)
switch((DWORD)proc){
case 0x0008: // DirectDrawCreate
pDirectDrawCreate=(DirectDrawCreate_Type)(*pGetProcAddress)(hModule, proc);
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pDirectDrawCreate);
OutTraceDW("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pDirectDrawCreate);
return (FARPROC)extDirectDrawCreate;
break;
case 0x000A: // DirectDrawCreateEx
pDirectDrawCreateEx=(DirectDrawCreateEx_Type)(*pGetProcAddress)(hModule, proc);
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pDirectDrawCreateEx);
OutTraceDW("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pDirectDrawCreateEx);
return (FARPROC)extDirectDrawCreateEx;
break;
case 0x000B: // DirectDrawEnumerateA
@ -490,22 +526,22 @@ FARPROC WINAPI extGetProcAddress(HMODULE hModule, LPCSTR proc)
break;
case SYSLIBIDX_USER32:
if ((DWORD)proc == 0x0020){ // ChangeDisplaySettingsA
pChangeDisplaySettings=(ChangeDisplaySettings_Type)(*pGetProcAddress)(hModule, proc);
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pChangeDisplaySettings);
return (FARPROC)extChangeDisplaySettings;
pChangeDisplaySettingsA=(ChangeDisplaySettingsA_Type)(*pGetProcAddress)(hModule, proc);
OutTraceDW("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pChangeDisplaySettingsA);
return (FARPROC)extChangeDisplaySettingsA;
}
break;
#ifndef ANTICHEATING
case SYSLIBIDX_KERNEL32:
if ((DWORD)proc == 0x022D){ // "IsDebuggerPresent"
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), extIsDebuggerPresent);
OutTraceDW("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), extIsDebuggerPresent);
return (FARPROC)extIsDebuggerPresent;
}
#endif
case SYSLIBIDX_OLE32:
if ((DWORD)proc == 0x0011){ // "CoCreateInstance"
pCoCreateInstance=(CoCreateInstance_Type)(*pGetProcAddress)(hModule, proc);
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pCoCreateInstance);
OutTraceDW("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pCoCreateInstance);
return (FARPROC)extCoCreateInstance;
}
break;
@ -513,13 +549,13 @@ FARPROC WINAPI extGetProcAddress(HMODULE hModule, LPCSTR proc)
}
ret=(*pGetProcAddress)(hModule, proc);
OutTraceD("GetProcAddress: ret=%x\n", ret);
OutTraceDW("GetProcAddress: ret=%x\n", ret);
return ret;
}
UINT WINAPI extGetDriveType(LPCTSTR lpRootPathName)
{
OutTraceD("GetDriveType: path=\"%s\"\n", lpRootPathName);
OutTraceDW("GetDriveType: path=\"%s\"\n", lpRootPathName);
if (dxw.dwFlags3 & CDROMDRIVETYPE) return DRIVE_CDROM;
return (*pGetDriveType)(lpRootPathName);
}
@ -701,25 +737,41 @@ BOOL WINAPI extCreateProcessA(
LPPROCESS_INFORMATION lpProcessInformation
)
{
OutTraceD("CreateProcess: SUPPRESS ApplicationName=%s CommandLine=\"%s\"\n", lpApplicationName, lpCommandLine);
OutTraceDW("CreateProcess: SUPPRESS ApplicationName=%s CommandLine=\"%s\"\n", lpApplicationName, lpCommandLine);
return TRUE;
}
BOOL WINAPI extQueryPerformanceFrequency(LARGE_INTEGER *lpFrequency)
{
// just proxy, but currently unhooked.....
BOOL ret;
ret=(*pQueryPerformanceFrequency)(lpFrequency);
return ret;
}
BOOL WINAPI extQueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)
{
BOOL ret;
LARGE_INTEGER myPerfCount;
ret=(*pQueryPerformanceCounter)(&myPerfCount);
myPerfCount.HighPart = dxw.StretchCounter(myPerfCount.HighPart);
myPerfCount.LowPart = dxw.StretchCounter(myPerfCount.LowPart);
if(dxw.dwFlags4 & NOPERFCOUNTER){
ret=0;
myPerfCount.HighPart = 0;
myPerfCount.LowPart = 0;
}
else{
ret=(*pQueryPerformanceCounter)(&myPerfCount);
myPerfCount.HighPart = dxw.StretchCounter(myPerfCount.HighPart);
myPerfCount.LowPart = dxw.StretchCounter(myPerfCount.LowPart);
}
*lpPerformanceCount = myPerfCount;
OutTraceB("QueryPerformanceCounter: ret=%x Count=%x-%x\n", ret, lpPerformanceCount->HighPart, lpPerformanceCount->LowPart);
return ret;
}
BOOL WINAPI extQueryPerformanceFrequency(LARGE_INTEGER *lpPerformanceFrequency)
{
BOOL ret;
if(dxw.dwFlags4 & NOPERFCOUNTER){
LARGE_INTEGER myPerfFrequency;
myPerfFrequency.LowPart = 0L;
myPerfFrequency.HighPart = 0L;
*lpPerformanceFrequency=myPerfFrequency;
ret = 0;
}
else
ret=(*pQueryPerformanceFrequency)(lpPerformanceFrequency);
OutTraceDW("QueryPerformanceFrequency: ret=%x Frequency=%x-%x\n", ret, lpPerformanceFrequency->HighPart, lpPerformanceFrequency->LowPart);
return ret;
}

4
dll/msvfw.cpp
View File

@ -30,7 +30,7 @@ void HookMSV4WLibs(HMODULE module)
LRESULT WINAPI extICSendMessage(HIC hic, UINT wMsg, DWORD_PTR dw1, DWORD_PTR dw2)
{
LRESULT res;
OutTraceD("ICSendMessage: hic=%x wMsg=%x dw1=%x dw2=%x\n", hic, wMsg, dw1, dw2);
OutTraceDW("ICSendMessage: hic=%x wMsg=%x dw1=%x dw2=%x\n", hic, wMsg, dw1, dw2);
return 0;
res=(*pICSendMessage)(hic, wMsg, dw1, dw2);
return res;
@ -38,7 +38,7 @@ LRESULT WINAPI extICSendMessage(HIC hic, UINT wMsg, DWORD_PTR dw1, DWORD_PTR dw2
HIC WINAPI extICOpen(DWORD fccType, DWORD fccHandler, UINT wMode)
{
OutTraceD("ICOpen: fccType=%x fccHandler=%x wMode=%x\n", fccType, fccHandler, wMode);
OutTraceDW("ICOpen: fccType=%x fccHandler=%x wMode=%x\n", fccType, fccHandler, wMode);
return (HIC)0;
}

82
dll/ole32.cpp
View File

@ -52,7 +52,7 @@ static void HookAdditionalModules()
if(hModule){ // --- and now it exists ...
HookModule(hModule, 0); // ... then hook it and ..
AddedModules[i].Hooked=TRUE; // .. mark it as already hooked
OutTraceD("CoCreateInstance: hooked module=%s hmodule=%x\n", AddedModules[i].ModuleName, hModule);
OutTraceDW("CoCreateInstance: hooked module=%s hmodule=%x\n", AddedModules[i].ModuleName, hModule);
//CloseHandle(hModule); // do NOT close this handle
}
}
@ -73,36 +73,36 @@ static HRESULT STDAPICALLTYPE myCoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnk
if(res)
OutTraceE("CoCreateInstance: ERROR res=%x\n", res);
else
OutTraceD("CoCreateInstance: ppv=%x->%x\n", *ppv, *(DWORD *)*ppv);
OutTraceDW("CoCreateInstance: ppv=%x->%x\n", *ppv, *(DWORD *)*ppv);
if (*(DWORD *)&rclsid==*(DWORD *)&CLSID_DirectDraw){
LPDIRECTDRAW lpOldDDraw;
OutTraceD("CoCreateInstance: CLSID_DirectDraw object\n");
OutTraceDW("CoCreateInstance: CLSID_DirectDraw object\n");
switch (*(DWORD *)&riid){
case 0x6C14DB80:
OutTraceD("DirectDrawCreate: IID_DirectDraw RIID\n");
OutTraceDW("DirectDrawCreate: IID_DirectDraw RIID\n");
res=extDirectDrawCreate(NULL, (LPDIRECTDRAW *)&ppv, 0);
if(res)OutTraceD("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
break;
case 0xB3A6F3E0:
OutTraceD("DirectDrawCreate: IID_DirectDraw2 RIID\n");
OutTraceDW("DirectDrawCreate: IID_DirectDraw2 RIID\n");
res=extDirectDrawCreate(NULL, &lpOldDDraw, 0);
if(res)OutTraceD("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
res=lpOldDDraw->QueryInterface(IID_IDirectDraw2, (LPVOID *)&ppv);
if(res)OutTraceD("QueryInterface: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("QueryInterface: res=%x(%s)\n", res, ExplainDDError(res));
lpOldDDraw->Release();
break;
case 0x9c59509a:
OutTraceD("DirectDrawCreate: IID_DirectDraw4 RIID\n");
OutTraceDW("DirectDrawCreate: IID_DirectDraw4 RIID\n");
res=extDirectDrawCreate(NULL, &lpOldDDraw, 0);
if(res)OutTraceD("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
res=lpOldDDraw->QueryInterface(IID_IDirectDraw4, (LPVOID *)&ppv);
if(res)OutTraceD("QueryInterface: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("QueryInterface: res=%x(%s)\n", res, ExplainDDError(res));
lpOldDDraw->Release();
case 0x15e65ec0:
OutTraceD("CoCreateInstance: IID_DirectDraw7 RIID\n");
OutTraceDW("CoCreateInstance: IID_DirectDraw7 RIID\n");
res=extDirectDrawCreateEx(NULL, (LPDIRECTDRAW *)&ppv, IID_IDirectDraw7, 0);
if(res)OutTraceD("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
break;
case 0xe436ebb3:
break;
@ -118,43 +118,43 @@ static HRESULT STDAPICALLTYPE myCoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnk
HRESULT STDAPICALLTYPE extCoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID FAR* ppv)
{
HRESULT res;
OutTraceD("CoCreateInstance: rclsid=%x UnkOuter=%x ClsContext=%x refiid=%x(%s)\n",
OutTraceDW("CoCreateInstance: rclsid=%x UnkOuter=%x ClsContext=%x refiid=%x(%s)\n",
rclsid, pUnkOuter, dwClsContext, riid.Data1, ExplainGUID((GUID *)&riid));
res=(*pCoCreateInstance)(rclsid, pUnkOuter, dwClsContext, riid, ppv);
if(res)
OutTraceE("CoCreateInstance: ERROR res=%x\n", res);
else
OutTraceD("CoCreateInstance: ppv=%x->%x\n", *ppv, *(DWORD *)*ppv);
OutTraceDW("CoCreateInstance: ppv=%x->%x\n", *ppv, *(DWORD *)*ppv);
if (*(DWORD *)&rclsid==*(DWORD *)&CLSID_DirectDraw){
LPDIRECTDRAW lpOldDDraw;
OutTraceD("CoCreateInstance: CLSID_DirectDraw object\n");
OutTraceDW("CoCreateInstance: CLSID_DirectDraw object\n");
switch (*(DWORD *)&riid){
case 0x6C14DB80:
OutTraceD("DirectDrawCreate: IID_DirectDraw RIID\n");
OutTraceDW("DirectDrawCreate: IID_DirectDraw RIID\n");
res=extDirectDrawCreate(NULL, (LPDIRECTDRAW *)&ppv, 0);
if(res)OutTraceD("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
break;
case 0xB3A6F3E0:
OutTraceD("DirectDrawCreate: IID_DirectDraw2 RIID\n");
OutTraceDW("DirectDrawCreate: IID_DirectDraw2 RIID\n");
res=extDirectDrawCreate(NULL, &lpOldDDraw, 0);
if(res)OutTraceD("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
res=lpOldDDraw->QueryInterface(IID_IDirectDraw2, (LPVOID *)&ppv);
if(res)OutTraceD("QueryInterface: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("QueryInterface: res=%x(%s)\n", res, ExplainDDError(res));
lpOldDDraw->Release();
break;
case 0x9c59509a:
OutTraceD("DirectDrawCreate: IID_DirectDraw4 RIID\n");
OutTraceDW("DirectDrawCreate: IID_DirectDraw4 RIID\n");
res=extDirectDrawCreate(NULL, &lpOldDDraw, 0);
if(res)OutTraceD("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreate: res=%x(%s)\n", res, ExplainDDError(res));
res=lpOldDDraw->QueryInterface(IID_IDirectDraw4, (LPVOID *)&ppv);
if(res)OutTraceD("QueryInterface: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("QueryInterface: res=%x(%s)\n", res, ExplainDDError(res));
lpOldDDraw->Release();
case 0x15e65ec0:
OutTraceD("CoCreateInstance: IID_DirectDraw7 RIID\n");
OutTraceDW("CoCreateInstance: IID_DirectDraw7 RIID\n");
res=extDirectDrawCreateEx(NULL, (LPDIRECTDRAW *)&ppv, IID_IDirectDraw7, 0);
if(res)OutTraceD("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
break;
case 0xe436ebb3:
break;
@ -172,7 +172,7 @@ HRESULT STDAPICALLTYPE extCoCreateInstanceEx(REFCLSID rclsid, IUnknown *punkOute
HRESULT res;
DWORD i;
OutTraceD("CoCreateInstanceEx: rclsid=%x UnkOuter=%x ClsContext=%x Count=%d\n",
OutTraceDW("CoCreateInstanceEx: rclsid=%x UnkOuter=%x ClsContext=%x Count=%d\n",
rclsid, punkOuter, dwClsCtx, dwCount);
res=(*pCoCreateInstanceEx)(rclsid, punkOuter, dwClsCtx, pServerInfo, dwCount, pResults);
@ -194,40 +194,40 @@ HRESULT STDAPICALLTYPE extCoCreateInstanceEx(REFCLSID rclsid, IUnknown *punkOute
// quartz.dll must be hooked.
if (*(DWORD *)&rclsid==0xe436ebb3){
HMODULE qlib;
OutTraceD("CoCreateInstanceEx: CLSID_FilterGraph RIID=%x\n", *(DWORD *)&riid);
OutTraceDW("CoCreateInstanceEx: CLSID_FilterGraph RIID=%x\n", *(DWORD *)&riid);
qlib=(*pLoadLibraryA)("quartz.dll");
OutTraceD("CoCreateInstanceEx: quartz lib handle=%x\n", qlib);
OutTraceDW("CoCreateInstanceEx: quartz lib handle=%x\n", qlib);
HookModule(qlib, 0);
}
if (*(DWORD *)&rclsid==*(DWORD *)&CLSID_DirectDraw){
LPDIRECTDRAW lpOldDDraw;
OutTraceD("CoCreateInstanceEx: CLSID_DirectDraw object\n");
OutTraceDW("CoCreateInstanceEx: CLSID_DirectDraw object\n");
switch (*(DWORD *)&riid){
case 0x6C14DB80:
OutTraceD("DirectDrawCreateEx: IID_DirectDraw RIID\n");
OutTraceDW("DirectDrawCreateEx: IID_DirectDraw RIID\n");
res=extDirectDrawCreate(NULL, (LPDIRECTDRAW *)&ppv, 0);
if(res)OutTraceD("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
break;
case 0xB3A6F3E0:
OutTraceD("DirectDrawCreateEx: IID_DirectDraw2 RIID\n");
OutTraceDW("DirectDrawCreateEx: IID_DirectDraw2 RIID\n");
res=extDirectDrawCreate(NULL, &lpOldDDraw, 0);
if(res)OutTraceD("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
res=lpOldDDraw->QueryInterface(IID_IDirectDraw2, (LPVOID *)&ppv);
if(res)OutTraceD("QueryInterfaceEx: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("QueryInterfaceEx: res=%x(%s)\n", res, ExplainDDError(res));
lpOldDDraw->Release();
break;
case 0x9c59509a:
OutTraceD("DirectDrawCreateEx: IID_DirectDraw4 RIID\n");
OutTraceDW("DirectDrawCreateEx: IID_DirectDraw4 RIID\n");
res=extDirectDrawCreate(NULL, &lpOldDDraw, 0);
if(res)OutTraceD("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
res=lpOldDDraw->QueryInterface(IID_IDirectDraw4, (LPVOID *)&ppv);
if(res)OutTraceD("QueryInterfaceEx: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("QueryInterfaceEx: res=%x(%s)\n", res, ExplainDDError(res));
lpOldDDraw->Release();
case 0x15e65ec0:
OutTraceD("CoCreateInstanceEx: IID_DirectDraw7 RIID\n");
OutTraceDW("CoCreateInstanceEx: IID_DirectDraw7 RIID\n");
res=extDirectDrawCreateEx(NULL, (LPDIRECTDRAW *)&ppv, IID_IDirectDraw7, 0);
if(res)OutTraceD("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
if(res)OutTraceDW("DirectDrawCreateEx: res=%x(%s)\n", res, ExplainDDError(res));
break;
case 0xe436ebb3:
break;
@ -244,7 +244,7 @@ HRESULT STDAPICALLTYPE extCoCreateInstanceEx(REFCLSID rclsid, IUnknown *punkOute
HRESULT WINAPI extCoInitialize(LPVOID pvReserved)
{
HRESULT res;
OutTraceD("CoInitialize: Reserved=%x\n", pvReserved);
OutTraceDW("CoInitialize: Reserved=%x\n", pvReserved);
res=(*pCoInitialize)(pvReserved);
return res;
}

36
dll/opengl.cpp
View File

@ -49,7 +49,7 @@ static FARPROC wglRemapLibrary(LPCSTR proc, HookEntry_Type *Hooks)
Hook=&Hooks[i];
if (!strcmp(proc,Hook->APIName)){
if (Hook->StoreAddress) *(Hook->StoreAddress)=(*pwglGetProcAddress)(proc);
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), (Hook->StoreAddress) ? *(Hook->StoreAddress) : 0);
OutTraceDW("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), (Hook->StoreAddress) ? *(Hook->StoreAddress) : 0);
return Hook->HookerAddress;
}
}
@ -154,7 +154,7 @@ void HookOpenGLLibs(HMODULE module, char *customlib)
if (!customlib) customlib=DefOpenGLModule;
OutTraceD("HookOpenGLLibs module=%x lib=\"%s\" forced=%x\n", module, customlib, (dxw.dwFlags3 & FORCEHOOKOPENGL)?1:0);
OutTraceDW("HookOpenGLLibs module=%x lib=\"%s\" forced=%x\n", module, customlib, (dxw.dwFlags3 & FORCEHOOKOPENGL)?1:0);
if (dxw.dwFlags3 & FORCEHOOKOPENGL)
ForceHookOpenGL(module);
else
@ -169,14 +169,14 @@ void WINAPI extglViewport(GLint x, GLint y, GLsizei width, GLsizei height
POINT p={0,0};
//if (dxw.dwFlags2 & HANDLEFPS) if(dxw.HandleFPS()) return;
(*pGetClientRect)(dxw.GethWnd(), &client);
OutTraceD("glViewport: declared pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
OutTraceDW("glViewport: declared pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
if(IsDebug) OutTrace("glViewport: DEBUG win=(%d,%d) screen=(%d,%d)\n",
client.right, client.bottom, dxw.GetScreenWidth(), dxw.GetScreenHeight());
x = (x * (GLint)client.right) / (GLint)dxw.GetScreenWidth();
y = (y * (GLint)client.bottom) / (GLint)dxw.GetScreenHeight();
width = (width * (GLint)client.right) / (GLint)dxw.GetScreenWidth();
height = (height * (GLint)client.bottom) / (GLint)dxw.GetScreenHeight();
OutTraceD("glViewport: remapped pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
OutTraceDW("glViewport: remapped pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
(*pglViewport)(x, y, width, height);
}
@ -186,19 +186,19 @@ 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);
OutTraceD("glScissor: declared pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
OutTraceDW("glScissor: declared 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();
height = (height * (GLint)client.bottom) / (GLint)dxw.GetScreenHeight();
OutTraceD("glScissor: remapped pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
OutTraceDW("glScissor: remapped pos=(%d,%d) size=(%d,%d)\n", x, y, width, height);
(*pglScissor)(x, y, width, height);
}
void WINAPI extglGetIntegerv(GLenum pname, GLint *params)
{
(*pglGetIntegerv)(pname, params);
OutTraceD("glGetIntegerv: pname=%d\n", pname);
OutTraceDW("glGetIntegerv: pname=%d\n", pname);
}
void WINAPI extglDrawBuffer(GLenum mode)
@ -224,8 +224,8 @@ void WINAPI extglDrawBuffer(GLenum mode)
void WINAPI extglPolygonMode(GLenum face, GLenum mode)
{
OutTraceD("glPolygonMode: face=%x mode=%x\n", face, mode);
//OutTraceD("glPolygonMode: extglPolygonMode=%x pglPolygonMode=%x\n", extglPolygonMode, pglPolygonMode);
OutTraceDW("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....
(*pglPolygonMode)(face, mode);
return;
@ -233,7 +233,7 @@ void WINAPI extglPolygonMode(GLenum face, GLenum mode)
void WINAPI extglGetFloatv(GLenum pname, GLboolean *params)
{
OutTraceD("glGetFloatv: pname=%x\n", pname);
OutTraceDW("glGetFloatv: pname=%x\n", pname);
(*pglGetFloatv)(pname, params);
return;
}
@ -247,22 +247,22 @@ void WINAPI extglClear(GLbitfield mask)
HGLRC WINAPI extwglCreateContext(HDC hdc)
{
HGLRC ret;
OutTraceD("wglCreateContext: hdc=%x\n", hdc);
OutTraceDW("wglCreateContext: hdc=%x\n", hdc);
// v2.02.31: don't let it use desktop hdc
if(dxw.IsDesktop(WindowFromDC(hdc))){
HDC oldhdc = hdc;
hdc=(*pGDIGetDC)(dxw.GethWnd());
OutTraceD("wglCreateContext: remapped desktop hdc=%x->%x\n", oldhdc, hdc);
OutTraceDW("wglCreateContext: remapped desktop hdc=%x->%x\n", oldhdc, hdc);
}
ret=(*pwglCreateContext)(hdc);
if(ret){
HWND hwnd;
hwnd=WindowFromDC(hdc);
dxw.SethWnd(hwnd);
OutTraceD("wglCreateContext: SET hwnd=%x\n", hwnd);
OutTraceDW("wglCreateContext: SET hwnd=%x\n", hwnd);
}
else {
OutTraceD("wglCreateContext: ERROR err=%x\n", GetLastError());
OutTraceDW("wglCreateContext: ERROR err=%x\n", GetLastError());
}
return ret;
}
@ -271,7 +271,7 @@ PROC WINAPI extwglGetProcAddress(LPCSTR proc)
{
PROC procaddr;
OutTraceD("wglGetProcAddress: proc=%s\n", proc);
OutTraceDW("wglGetProcAddress: proc=%s\n", proc);
procaddr=Remap_wgl_ProcAddress(proc);
if (!procaddr) procaddr=(*pwglGetProcAddress)(proc);
return procaddr;
@ -287,18 +287,18 @@ BOOL WINAPI extwglMakeCurrent(HDC hdc, HGLRC hglrc)
{
BOOL ret;
OutTraceD("wglMakeCurrent: hdc=%x hglrc=%x\n", hdc, hglrc);
OutTraceDW("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;
hdc=(*pGDIGetDC)(dxw.GethWnd());
OutTraceD("wglMakeCurrent: remapped desktop hdc=%x->%x\n", oldhdc, hdc);
OutTraceDW("wglMakeCurrent: remapped desktop hdc=%x->%x\n", oldhdc, hdc);
}
ret=(*pwglMakeCurrent)(hdc, hglrc);
if(ret){
HWND hWnd;
hWnd = WindowFromDC(hdc);
OutTraceD("wglMakeCurrent: setting hwnd=%x\n", hWnd);
OutTraceDW("wglMakeCurrent: setting hwnd=%x\n", hWnd);
dxw.SethWnd(hWnd);
}
return ret;

8
dll/smack.cpp
View File

@ -26,7 +26,7 @@ FARPROC Remap_smack_ProcAddress(LPCSTR proc, HMODULE hModule)
{
if (!strcmp(proc,"_SmackOpen@12") && !pSmackOpen){
pSmackOpen=(SmackOpen_Type)(*pGetProcAddress)(hModule, proc);
OutTraceD("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pSmackOpen);
OutTraceDW("GetProcAddress: hooking proc=%s at addr=%x\n", ProcToString(proc), pSmackOpen);
return (FARPROC)extSmackOpen;
}
// NULL -> keep the original call address
@ -36,12 +36,12 @@ FARPROC Remap_smack_ProcAddress(LPCSTR proc, HMODULE hModule)
SmackStruct * WINAPI extSmackOpen(HANDLE SmackFile, UINT32 flags, INT32 unknown)
{
SmackStruct *ret;
OutTraceD("SmackOpen: SmackFile=%x flags=%x unknown=%x\n", SmackFile, flags, unknown);
OutTraceDW("SmackOpen: SmackFile=%x flags=%x unknown=%x\n", SmackFile, flags, unknown);
if(!pSmackOpen) OutTraceE("ASSERT: NULL pSmackOpen\n");
ret=(*pSmackOpen)(SmackFile, flags, unknown);
OutTraceD("SmackOpen: ret=%x\n", ret);
OutTraceDW("SmackOpen: ret=%x\n", ret);
if (ret) {
OutTraceD("SmackOpen: version=%x screen=(%dx%d) frame_count=%d frame_number=%d\n",
OutTraceDW("SmackOpen: version=%x screen=(%dx%d) frame_count=%d frame_number=%d\n",
ret->version, ret->width, ret->height, ret->frame_count, ret->frame_number);
//ret->width=800;
//ret->height=600;

19
dll/syslibs.h
View File

@ -120,6 +120,7 @@ typedef DWORD (WINAPI *SetFilePointer_Type)(HANDLE, LONG, PLONG, DWORD);
typedef BOOL (WINAPI *CloseHandle_Type)(HANDLE);
typedef BOOL (WINAPI *QueryPerformanceFrequency_Type)(LARGE_INTEGER *);
typedef BOOL (WINAPI *QueryPerformanceCounter_Type)(LARGE_INTEGER *);
typedef BOOL (WINAPI *QueryPerformanceFrequency_Type)(LARGE_INTEGER *);
// ole32.dll:
typedef HRESULT (STDAPICALLTYPE *CoCreateInstance_Type)(REFCLSID, LPUNKNOWN, DWORD, REFIID, LPVOID FAR*);
@ -129,8 +130,10 @@ typedef HRESULT (STDAPICALLTYPE *CoInitialize_Type)(LPVOID);
// user32.dll:
typedef HDC (WINAPI *BeginPaint_Type)(HWND, LPPAINTSTRUCT);
typedef LRESULT (WINAPI *CallWindowProc_Type)(WNDPROC, HWND, UINT, WPARAM, LPARAM);
typedef LONG (WINAPI *ChangeDisplaySettings_Type)(DEVMODE *, DWORD);
typedef LONG (WINAPI *ChangeDisplaySettingsEx_Type)(LPCTSTR, DEVMODE *, HWND, DWORD, LPVOID);
typedef LONG (WINAPI *ChangeDisplaySettingsA_Type)(DEVMODEA *, DWORD);
typedef LONG (WINAPI *ChangeDisplaySettingsExA_Type)(LPCTSTR, DEVMODEA *, HWND, DWORD, LPVOID);
typedef LONG (WINAPI *ChangeDisplaySettingsW_Type)(DEVMODEW *, DWORD);
typedef LONG (WINAPI *ChangeDisplaySettingsExW_Type)(LPCTSTR, DEVMODEW *, HWND, DWORD, LPVOID);
typedef BOOL (WINAPI *ClientToScreen_Type)(HWND, LPPOINT);
typedef BOOL (WINAPI *ClipCursor_Type)(const RECT *);
typedef HWND (WINAPI *CreateDialogIndirectParam_Type)(HINSTANCE, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);
@ -314,8 +317,10 @@ DXWEXTERN CoInitialize_Type pCoInitialize DXWINITIALIZED;
// user32.dll:
DXWEXTERN BeginPaint_Type pBeginPaint DXWINITIALIZED;
DXWEXTERN CallWindowProc_Type pCallWindowProc DXWINITIALIZED;
DXWEXTERN ChangeDisplaySettings_Type pChangeDisplaySettings DXWINITIALIZED;
DXWEXTERN ChangeDisplaySettingsEx_Type pChangeDisplaySettingsEx DXWINITIALIZED;
DXWEXTERN ChangeDisplaySettingsA_Type pChangeDisplaySettingsA DXWINITIALIZED;
DXWEXTERN ChangeDisplaySettingsExA_Type pChangeDisplaySettingsExA DXWINITIALIZED;
DXWEXTERN ChangeDisplaySettingsW_Type pChangeDisplaySettingsW DXWINITIALIZED;
DXWEXTERN ChangeDisplaySettingsExW_Type pChangeDisplaySettingsExW DXWINITIALIZED;
DXWEXTERN ClientToScreen_Type pClientToScreen DXWINITIALIZED;
DXWEXTERN ClipCursor_Type pClipCursor DXWINITIALIZED;
DXWEXTERN CreateDialogIndirectParam_Type pCreateDialogIndirectParam DXWINITIALIZED;
@ -495,8 +500,10 @@ extern HRESULT STDAPICALLTYPE extCoInitialize(LPVOID);
// user32.dll:
extern HDC WINAPI extBeginPaint(HWND, LPPAINTSTRUCT);
extern LRESULT WINAPI extCallWindowProc(WNDPROC, HWND, UINT, WPARAM, LPARAM);
extern LONG WINAPI extChangeDisplaySettings(DEVMODE *, DWORD);
extern LONG WINAPI extChangeDisplaySettingsEx(LPCTSTR, DEVMODE *, HWND, DWORD, LPVOID);
extern LONG WINAPI extChangeDisplaySettingsA(DEVMODEA *, DWORD);
extern LONG WINAPI extChangeDisplaySettingsExA(LPCTSTR, DEVMODEA *, HWND, DWORD, LPVOID);
extern LONG WINAPI extChangeDisplaySettingsW(DEVMODEW *, DWORD);
extern LONG WINAPI extChangeDisplaySettingsExW(LPCTSTR, DEVMODEW *, HWND, DWORD, LPVOID);
extern BOOL WINAPI extClientToScreen(HWND, LPPOINT);
extern BOOL WINAPI extClipCursor(LPRECT);
extern HWND WINAPI extCreateDialogIndirectParam(HINSTANCE, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);

435
dll/user32.cpp
View File

File diff suppressed because it is too large Load Diff

14
dll/winmm.cpp
View File

@ -6,8 +6,8 @@
#include "MMSystem.h"
//#undef OutTraceD
//#define OutTraceD OutTrace
//#undef OutTraceDW
//#define OutTraceDW OutTrace
static HookEntry_Type Hooks[]={
{"mciSendCommandA", NULL, (FARPROC *)&pmciSendCommand, (FARPROC)extmciSendCommand},
@ -50,18 +50,18 @@ MMRESULT WINAPI exttimeSetEvent(UINT uDelay, UINT uResolution, LPTIMECALLBACK lp
{
MMRESULT res;
//uDelay = uDelay * 8;
OutTraceD("timeSetEvent: Delay=%d Resolution=%d Event=%x\n", uDelay, uResolution, fuEvent);
OutTraceDW("timeSetEvent: Delay=%d Resolution=%d Event=%x\n", uDelay, uResolution, fuEvent);
res=(*ptimeSetEvent)(uDelay, uResolution, lpTimeProc, dwUser, fuEvent);
OutTraceD("timeSetEvent: ret=%x\n", res);
OutTraceDW("timeSetEvent: ret=%x\n", res);
return res;
}
MMRESULT WINAPI exttimeKillEvent(UINT uTimerID)
{
MMRESULT res;
OutTraceD("timeKillEvent: TimerID=%x\n", uTimerID);
OutTraceDW("timeKillEvent: TimerID=%x\n", uTimerID);
res=(*ptimeKillEvent)(uTimerID);
OutTraceD("timeKillEvent: ret=%x\n", res);
OutTraceDW("timeKillEvent: ret=%x\n", res);
return res;
}
@ -84,7 +84,7 @@ MCIERROR WINAPI extmciSendCommand(MCIDEVICEID IDDevice, UINT uMsg, DWORD_PTR fdw
MCI_ANIM_RECT_PARMS *pr;
MCI_OVLY_WINDOW_PARMSW *pw;
OutTraceD("mciSendCommand: IDDevice=%x msg=%x(%s) Command=%x(%s)\n",
OutTraceDW("mciSendCommand: IDDevice=%x msg=%x(%s) Command=%x(%s)\n",
IDDevice, uMsg, ExplainMCICommands(uMsg), fdwCommand, ExplainMCIFlags(uMsg, fdwCommand));
if(dxw.IsFullScreen()){

4
dll/wintrust.cpp
View File

@ -28,8 +28,8 @@ FARPROC Remap_trust_ProcAddress(LPCSTR proc, HMODULE hModule)
LONG WINAPI extWinVerifyTrust(HWND hWnd, GUID *pgActionID, LPVOID pWVTData)
{
LONG ret;
OutTraceD("WinVerifyTrust: hwnd=%x pgActionID=%x pWVTData=%x\n", hWnd, pgActionID, pWVTData);
OutTraceDW("WinVerifyTrust: hwnd=%x pgActionID=%x pWVTData=%x\n", hWnd, pgActionID, pWVTData);
ret = (*pWinVerifyTrust)(hWnd, pgActionID, pWVTData);
OutTraceD("WinVerifyTrust: ret=%x\n", ret);
OutTraceDW("WinVerifyTrust: ret=%x\n", ret);
return ret;
}

6
dll/wndproc.cpp
View File

@ -32,7 +32,7 @@ void WhndStackPush(HWND hwnd, WNDPROC wndproc)
// wndproc values of 0xFFFFxxxx type seems to be error codes rather than valid callback addresses ....
// v2.02.36 using CallWindowProc you can pass WinProc handles, so you don't need to eliminate them!
//if (((DWORD)wndproc & 0xFFFF0000) == 0xFFFF0000) return;
//OutTraceD("DEBUG: WNDPROC STACK push hwnd=%x, wndproc=%x\n", hwnd, wndproc);
//OutTraceDW("DEBUG: WNDPROC STACK push hwnd=%x, wndproc=%x\n", hwnd, wndproc);
// try update first...
for(StackIdx=0; StackIdx<WhndTOS; StackIdx++)
if (WhndStack[StackIdx].hwnd==hwnd) {
@ -55,9 +55,9 @@ WNDPROC WhndGetWindowProc(HWND hwnd)
{
int StackIdx;
for(StackIdx=0; StackIdx<MAXWNDHSTACK; StackIdx++) if (WhndStack[StackIdx].hwnd==hwnd) {
//OutTraceD("DEBUG: WNDPROC STACK pop hwnd=%x, wndproc=%x\n", hwnd, WhndStack[StackIdx].wndproc);
//OutTraceDW("DEBUG: WNDPROC STACK pop hwnd=%x, wndproc=%x\n", hwnd, WhndStack[StackIdx].wndproc);
return WhndStack[StackIdx].wndproc;
}
//OutTraceD("DEBUG: WNDPROC STACK pop hwnd=%x, wndproc=NULL\n", hwnd);
//OutTraceDW("DEBUG: WNDPROC STACK pop hwnd=%x, wndproc=NULL\n", hwnd);
return NULL;
}

25
host/Resource.h
View File

@ -54,7 +54,6 @@
#define IDC_LOCKEDSURFACE 1010
#define IDC_EMULATESURFACE 1011
#define IDC_MODIFYMOUSE 1012
#define IDC_OUTTRACE 1013
#define IDC_HANDLEDC 1014
#define IDC_SAVELOAD 1015
#define IDC_INITX 1016
@ -76,9 +75,6 @@
#define IDC_USERGB565 1033
#define IDC_SUPPRESSDXERRORS 1034
#define IDC_PREVENTMAXIMIZE 1035
#define IDC_OUTWINMESSAGES 1036
#define IDC_OUTDXTRACE 1037
#define IDC_DXPROXED 1038
#define IDC_TITLE 1039
#define IDC_SLOW 1040
#define IDC_CLIPCURSOR 1041
@ -107,7 +103,6 @@
#define IDC_IMPORTTABLE 1064
#define IDC_HANDLEEXCEPTIONS 1065
#define IDC_BLITFROMBACKBUFFER 1066
#define IDC_OUTDEBUG 1067
#define IDC_SUPPRESSCLIPPING 1068
#define IDC_MODALSTYLE 1069
#define IDC_KEEPASPECTRATIO 1070
@ -156,7 +151,6 @@
#define IDC_HOOKDI 1112
#define IDC_EMULATEREGISTRY 1113
#define IDC_CDROMDRIVETYPE 1114
#define IDC_OUTREGISTRY 1115
#define IDC_NOWINDOWMOVE 1116
#define IDC_DISABLEHAL 1117
#define IDC_LOCKSYSCOLORS 1118
@ -191,6 +185,16 @@
#define IDC_ZBUFFERALWAYS 1147
#define IDC_ZBUFFER0CLEAN 1148
#define IDC_NOPOWER2FIX 1149
#define IDC_NOPERFCOUNTER 1150
#define IDC_OUTPROXYTRACE 1151
#define IDC_OUTD3DTRACE 1152
#define IDC_OUTDWTRACE 1153
#define IDC_DXPROXED 1154
#define IDC_OUTWINMESSAGES 1155
#define IDC_OUTDDRAWTRACE 1157
#define IDC_OUTDEBUG 1158
#define IDC_OUTREGISTRY 1159
#define IDC_ADDPROXYLIBS 1160
#define ID_MODIFY 32771
#define ID_DELETE 32772
#define ID_ADD 32773
@ -224,8 +228,6 @@
#define ID_VIEW_STATUS32813 32813
#define ID_VIEW_TIMESLIDER32814 32814
#define ID_VIEW_STATUS3 32815
#define ID_KILL_PAUSE 32816
#define ID_KILL_RESUME 32817
#define ID_KILL_KILL 32818
#define ID_TASK_RESUME 32819
#define ID_FILE_IMPORT 32820
@ -233,6 +235,11 @@
#define ID_PEXPORT 32822
#define ID_PKILL 32823
#define ID_VIEW_PALETTE 32825
#define ID_FILE_DESKTOPCOLORDEPTH 32826
#define ID_DESKTOPCOLORDEPTH_16BPP 32827
#define ID_DESKTOPCOLORDEPTH_24BPP 32828
#define ID_DESKTOPCOLORDEPTH_32BPP 32829
#define ID_DESKTOPCOLORDEPTH_8BPP 32830
// Next default values for new objects
//
@ -240,7 +247,7 @@
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_3D_CONTROLS 1
#define _APS_NEXT_RESOURCE_VALUE 159
#define _APS_NEXT_COMMAND_VALUE 32826
#define _APS_NEXT_COMMAND_VALUE 32830
#define _APS_NEXT_CONTROL_VALUE 1095
#define _APS_NEXT_SYMED_VALUE 101
#endif

1
host/TabCompat.cpp
View File

@ -40,6 +40,7 @@ void CTabCompat::DoDataExchange(CDataExchange* pDX)
DDX_Check(pDX, IDC_ZBUFFERCLEAN, cTarget->m_ZBufferClean);
DDX_Check(pDX, IDC_ZBUFFER0CLEAN, cTarget->m_ZBuffer0Clean);
DDX_Check(pDX, IDC_NOPOWER2FIX, cTarget->m_NoPower2Fix);
DDX_Check(pDX, IDC_NOPERFCOUNTER, cTarget->m_NoPerfCounter);
}
BEGIN_MESSAGE_MAP(CTabCompat, CDialog)

1
host/TabDirectX.cpp
View File

@ -43,6 +43,7 @@ void CTabDirectX::DoDataExchange(CDataExchange* pDX)
DDX_Check(pDX, IDC_NOPIXELFORMAT, cTarget->m_NoPixelFormat);
DDX_Check(pDX, IDC_NOALPHACHANNEL, cTarget->m_NoAlphaChannel);
DDX_Check(pDX, IDC_FIXREFCOUNTER, cTarget->m_FixRefCounter);
DDX_Check(pDX, IDC_ADDPROXYLIBS, cTarget->m_AddProxyLibs);
//DDX_Check(pDX, IDC_SAVECAPS, cTarget->m_SaveCaps);
}

6
host/TabLogs.cpp
View File

@ -36,12 +36,14 @@ void CTabLogs::DoDataExchange(CDataExchange* pDX)
CDialog::DoDataExchange(pDX);
CTargetDlg *cTarget = ((CTargetDlg *)(this->GetParent()->GetParent()));
//extern BOOL gbDebug;
DDX_Check(pDX, IDC_OUTTRACE, cTarget->m_OutTrace);
DDX_Check(pDX, IDC_OUTPROXYTRACE, cTarget->m_OutProxyTrace);
DDX_Check(pDX, IDC_OUTD3DTRACE, cTarget->m_OutD3DTrace);
DDX_Check(pDX, IDC_OUTDDRAWTRACE, cTarget->m_OutDDRAWTrace);
DDX_Check(pDX, IDC_OUTDEBUG, cTarget->m_OutDebug);
DDX_Check(pDX, IDC_CURSORTRACE, cTarget->m_CursorTrace);
DDX_Check(pDX, IDC_LOGENABLED, cTarget->m_LogEnabled);
DDX_Check(pDX, IDC_OUTWINMESSAGES, cTarget->m_OutWinMessages);
DDX_Check(pDX, IDC_OUTDXTRACE, cTarget->m_OutDXTrace);
DDX_Check(pDX, IDC_OUTDWTRACE, cTarget->m_OutDWTrace);
DDX_Check(pDX, IDC_IMPORTTABLE, cTarget->m_ImportTable);
DDX_Check(pDX, IDC_OUTREGISTRY, cTarget->m_RegistryOp);
DDX_Check(pDX, IDC_TRACEHOOKS, cTarget->m_TraceHooks);

8
host/TargetDlg.cpp
View File

@ -26,11 +26,13 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
m_DCEmulationMode = 0; // default: no emulation
m_HookDI = FALSE;
m_ModifyMouse = TRUE; // default true !!
m_OutTrace = FALSE;
m_OutProxyTrace = FALSE;
m_OutDebug = FALSE;
m_CursorTrace = FALSE;
m_OutWinMessages = FALSE;
m_OutDXTrace = FALSE;
m_OutDWTrace = FALSE;
m_OutD3DTrace = FALSE;
m_OutDDRAWTrace = FALSE;
m_DXProxed = FALSE;
m_HandleDC = FALSE;
m_HandleExceptions = FALSE;
@ -58,6 +60,8 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
m_ZBufferAlways = FALSE;
m_DisableFogging = FALSE;
m_NoPower2Fix = FALSE;
m_NoPerfCounter = FALSE;
m_AddProxyLibs = FALSE;
m_UnNotify = FALSE;
m_Windowize = TRUE; // default true !!
m_HookDLLs = TRUE; // default true !!

8
host/TargetDlg.h
View File

@ -29,12 +29,14 @@ public:
int m_DCEmulationMode;
BOOL m_HookDI;
BOOL m_ModifyMouse;
BOOL m_OutTrace;
BOOL m_OutProxyTrace;
BOOL m_OutDebug;
BOOL m_CursorTrace;
BOOL m_LogEnabled;
BOOL m_OutWinMessages;
BOOL m_OutDXTrace;
BOOL m_OutDWTrace;
BOOL m_OutD3DTrace;
BOOL m_OutDDRAWTrace;
BOOL m_DXProxed;
BOOL m_AssertDialog;
BOOL m_ImportTable;
@ -120,6 +122,8 @@ public:
BOOL m_ZBuffer0Clean;
BOOL m_ZBufferAlways;
BOOL m_NoPower2Fix;
BOOL m_NoPerfCounter;
BOOL m_AddProxyLibs;
BOOL m_DisableFogging;
BOOL m_SuppressIME;
BOOL m_SetCompatibility;

BIN
host/dxwndhost.aps
View File

Binary file not shown.

2
host/dxwndhost.cpp
View File

@ -213,4 +213,4 @@ char *GetTSCaption(int shift)
":6",":8",":12",":16"};
if (shift<-8 || shift>8) return "???";
return sTSCaption[shift+8];
}
}

31
host/dxwndhost.rc
View File

@ -95,6 +95,13 @@ BEGIN
MENUITEM "&Resume", ID_TASK_RESUME
MENUITEM "&Kill", ID_TASK_KILL
END
POPUP "Desktop color depth"
BEGIN
MENUITEM " 8 BPP", ID_DESKTOPCOLORDEPTH_8BPP
MENUITEM "16 BPP", ID_DESKTOPCOLORDEPTH_16BPP
MENUITEM "24 BPP", ID_DESKTOPCOLORDEPTH_24BPP
MENUITEM "32 BPP", ID_DESKTOPCOLORDEPTH_32BPP
END
MENUITEM "Move to Tray", ID_FILE_GOTOTRAYICON
MENUITEM "e&Xit", ID_DXAPP_EXIT
END
@ -285,16 +292,18 @@ IDD_TAB_LOG DIALOGEX 0, 0, 300, 240
STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
GROUPBOX "dxwnd.log logs",IDC_STATIC,7,3,129,145
GROUPBOX "dxwnd.log logs",IDC_STATIC,7,3,129,173
CONTROL "Enable Trace",IDC_LOGENABLED,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,25,73,12
CONTROL "DxWnd",IDC_OUTTRACE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,46,73,12
CONTROL "DirectX trace",IDC_OUTDXTRACE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,58,73,12
CONTROL "Win Events",IDC_OUTWINMESSAGES,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,70,73,12
CONTROL "Cursor/Mouse",IDC_CURSORTRACE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,82,73,12
CONTROL "Import Table",IDC_IMPORTTABLE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,94,73,12
CONTROL "Debug",IDC_OUTDEBUG,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,106,73,12
CONTROL "Registry op.",IDC_OUTREGISTRY,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,118,73,12
CONTROL "Hook op.",IDC_TRACEHOOKS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,130,73,12
CONTROL "DirectX full trace",IDC_OUTPROXYTRACE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,82,73,12
CONTROL "DxWnd hacks",IDC_OUTDWTRACE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,46,73,12
CONTROL "Win Events",IDC_OUTWINMESSAGES,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,94,73,12
CONTROL "Cursor/Mouse",IDC_CURSORTRACE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,106,73,12
CONTROL "Import Table",IDC_IMPORTTABLE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,118,73,12
CONTROL "Debug",IDC_OUTDEBUG,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,130,73,12
CONTROL "Registry op.",IDC_OUTREGISTRY,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,142,73,12
CONTROL "Hook op.",IDC_TRACEHOOKS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,154,73,12
CONTROL "Direct3D trace",IDC_OUTD3DTRACE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,70,73,12
CONTROL "DirectDraw Trace",IDC_OUTDDRAWTRACE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,58,73,12
END
IDD_TAB_DIRECTX DIALOGEX 0, 0, 300, 240
@ -316,7 +325,7 @@ BEGIN
GROUPBOX "DirectX Version Hook",IDC_STATIC,6,3,98,103,WS_GROUP
GROUPBOX "Emulation",IDC_STATIC,7,109,98,80,WS_GROUP
CONTROL "Auto Primary Surface Refresh",IDC_AUTOREFRESH,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,118,16,126,9
GROUPBOX "DirectDraw Surface handling",IDC_STATIC,112,3,181,186
GROUPBOX "DirectDraw Surface handling",IDC_STATIC,112,3,181,230
CONTROL "switch VIDEO to SYSTEM on fail",IDC_VIDEOTOSYSTEMMEM,
"Button",BS_AUTOCHECKBOX | BS_MULTILINE | WS_TABSTOP,118,28,126,9
CONTROL "Suppress DX common errors",IDC_SUPPRESSDXERRORS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,118,40,127,10
@ -332,6 +341,7 @@ BEGIN
CONTROL "by default set no ALPHACHANNEL",IDC_NOALPHACHANNEL,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,118,160,123,12
CONTROL "Fix ddraw ref counter",IDC_FIXREFCOUNTER,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,118,172,123,12
CONTROL "Add proxy libs",IDC_ADDPROXYLIBS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,118,184,123,12
END
IDD_TAB_INPUT DIALOGEX 0, 0, 300, 240
@ -445,6 +455,7 @@ BEGIN
CONTROL "Clean ZBUFFER @1.0 fix",IDC_ZBUFFERCLEAN,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,116,109,12
CONTROL "Clean ZBUFFER @0.0 fix",IDC_ZBUFFER0CLEAN,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,104,109,12
CONTROL "Textures not power of 2 fix",IDC_NOPOWER2FIX,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,92,109,12
CONTROL "Disable performance counter",IDC_NOPERFCOUNTER,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,80,109,12
END
IDD_TAB_SYSLIBS DIALOGEX 0, 0, 300, 240

BIN
host/dxwndhost.vs2008.suo
View File

Binary file not shown.

86
host/dxwndhostView.cpp
View File

@ -65,6 +65,10 @@ BEGIN_MESSAGE_MAP(CDxwndhostView, CListView)
ON_COMMAND(ID_VIEW_STATUS, OnViewStatus)
ON_COMMAND(ID_VIEW_PALETTE, OnViewPalette)
ON_COMMAND(ID_VIEW_TIMESLIDER, OnViewTimeSlider)
ON_COMMAND(ID_DESKTOPCOLORDEPTH_8BPP, OnDesktopcolordepth8bpp)
ON_COMMAND(ID_DESKTOPCOLORDEPTH_16BPP, OnDesktopcolordepth16bpp)
ON_COMMAND(ID_DESKTOPCOLORDEPTH_24BPP, OnDesktopcolordepth24bpp)
ON_COMMAND(ID_DESKTOPCOLORDEPTH_32BPP, OnDesktopcolordepth32bpp)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
@ -137,12 +141,14 @@ static void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
}
if(dlg->m_HookDI) t->flags |= HOOKDI;
if(dlg->m_ModifyMouse) t->flags |= MODIFYMOUSE;
if(dlg->m_OutTrace) t->tflags |= OUTDDRAWTRACE;
if(dlg->m_OutProxyTrace) t->tflags |= OUTPROXYTRACE;
if(dlg->m_OutDebug) t->tflags |= OUTDEBUG;
if(dlg->m_CursorTrace) t->tflags |= OUTCURSORTRACE;
if(dlg->m_LogEnabled) t->tflags |= OUTTRACE;
if(dlg->m_OutWinMessages) t->tflags |= OUTWINMESSAGES;
if(dlg->m_OutDXTrace) t->tflags |= OUTPROXYTRACE;
if(dlg->m_OutDWTrace) t->tflags |= OUTDXWINTRACE;
if(dlg->m_OutDDRAWTrace) t->tflags |= OUTDDRAWTRACE;
if(dlg->m_OutD3DTrace) t->tflags |= OUTD3DTRACE;
if(dlg->m_DXProxed) t->tflags |= DXPROXED;
if(dlg->m_AssertDialog) t->tflags |= ASSERTDIALOG;
if(dlg->m_ImportTable) t->tflags |= OUTIMPORTTABLE;
@ -158,6 +164,8 @@ static void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
if(dlg->m_ZBuffer0Clean) t->flags4 |= ZBUFFER0CLEAN;
if(dlg->m_ZBufferAlways) t->flags4 |= ZBUFFERALWAYS;
if(dlg->m_NoPower2Fix) t->flags4 |= NOPOWER2FIX;
if(dlg->m_NoPerfCounter) t->flags4 |= NOPERFCOUNTER;
if(dlg->m_AddProxyLibs) t->flags4 |= ADDPROXYLIBS;
if(dlg->m_DisableFogging) t->flags4 |= DISABLEFOGGING;
if(dlg->m_SuppressIME) t->flags2 |= SUPPRESSIME;
if(dlg->m_SuppressD3DExt) t->flags3 |= SUPPRESSD3DEXT;
@ -281,12 +289,14 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
dlg->m_HookDI = t->flags & HOOKDI ? 1 : 0;
dlg->m_ModifyMouse = t->flags & MODIFYMOUSE ? 1 : 0;
dlg->m_OutTrace = t->tflags & OUTDDRAWTRACE ? 1 : 0;
dlg->m_OutProxyTrace = t->tflags & OUTPROXYTRACE ? 1 : 0;
dlg->m_OutDebug = t->tflags & OUTDEBUG ? 1 : 0;
dlg->m_CursorTrace = t->tflags & OUTCURSORTRACE ? 1 : 0;
dlg->m_LogEnabled = t->tflags & OUTTRACE ? 1 : 0;
dlg->m_OutWinMessages = t->tflags & OUTWINMESSAGES ? 1 : 0;
dlg->m_OutDXTrace = t->tflags & OUTPROXYTRACE ? 1 : 0;
dlg->m_OutDWTrace = t->tflags & OUTDXWINTRACE ? 1 : 0;
dlg->m_OutD3DTrace = t->tflags & OUTD3DTRACE ? 1 : 0;
dlg->m_OutDDRAWTrace = t->tflags & OUTDDRAWTRACE ? 1 : 0;
dlg->m_DXProxed = t->tflags & DXPROXED ? 1 : 0;
dlg->m_AssertDialog = t->tflags & ASSERTDIALOG ? 1 : 0;
dlg->m_ImportTable = t->tflags & OUTIMPORTTABLE ? 1 : 0;
@ -317,6 +327,8 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
dlg->m_ZBuffer0Clean = t->flags4 & ZBUFFER0CLEAN ? 1 : 0;
dlg->m_ZBufferAlways = t->flags4 & ZBUFFERALWAYS ? 1 : 0;
dlg->m_NoPower2Fix = t->flags4 & NOPOWER2FIX ? 1 : 0;
dlg->m_NoPerfCounter = t->flags4 & NOPERFCOUNTER ? 1 : 0;
dlg->m_AddProxyLibs = t->flags4 & ADDPROXYLIBS ? 1 : 0;
dlg->m_DisableFogging = t->flags4 & DISABLEFOGGING ? 1 : 0;
dlg->m_SaveLoad = t->flags & SAVELOAD ? 1 : 0;
dlg->m_SlowDown = t->flags & SLOWDOWN ? 1 : 0;
@ -1423,6 +1435,18 @@ void CDxwndhostView::OnRButtonDown(UINT nFlags, CPoint point)
case ID_FILE_IMPORT:
OnImport();
break;
case ID_DESKTOPCOLORDEPTH_8BPP:
OnDesktopcolordepth8bpp();
break;
case ID_DESKTOPCOLORDEPTH_16BPP:
OnDesktopcolordepth16bpp();
break;
case ID_DESKTOPCOLORDEPTH_24BPP:
OnDesktopcolordepth24bpp();
break;
case ID_DESKTOPCOLORDEPTH_32BPP:
OnDesktopcolordepth32bpp();
break;
}
CListView::OnRButtonDown(nFlags, point);
}
@ -1555,3 +1579,57 @@ void CDxwndhostView::OnRun()
CreateProcess(NULL, TargetMaps[i].path, 0, 0, false, CREATE_DEFAULT_ERROR_MODE, NULL, path, &sinfo, &pinfo);
}
}
void SwitchToColorDepth(int bpp)
{
DEVMODE CurrentDevMode;
BOOL res;
char MsgBuf[256+1];
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &CurrentDevMode);
sprintf(MsgBuf, "ChangeDisplaySettings: color depth %d -> %d BPP\n", CurrentDevMode.dmBitsPerPel, bpp);
if(MessageBoxEx(0, MsgBuf, "Warning", MB_OKCANCEL | MB_ICONQUESTION, NULL)!=IDOK) return;
//OutTraceDW("ChangeDisplaySettings: CURRENT wxh=(%dx%d) BitsPerPel=%d -> 16\n",
// CurrentDevMode.dmPelsWidth, CurrentDevMode.dmPelsHeight, CurrentDevMode.dmBitsPerPel);
CurrentDevMode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
CurrentDevMode.dmBitsPerPel = bpp;
res=ChangeDisplaySettings(&CurrentDevMode, CDS_UPDATEREGISTRY);
if(res!=DISP_CHANGE_SUCCESSFUL) {
char *err;
switch(res){
case DISP_CHANGE_BADDUALVIEW: err="BADDUALVIEW"; break;
case DISP_CHANGE_BADFLAGS: err="BADFLAGS"; break;
case DISP_CHANGE_BADMODE: err="BADMODE"; break;
case DISP_CHANGE_BADPARAM: err="BADPARAM"; break;
case DISP_CHANGE_FAILED: err="FAILED"; break;
case DISP_CHANGE_NOTUPDATED: err="NOTUPDATED"; break;
case DISP_CHANGE_RESTART: err="RESTART"; break;
default: err="???"; break;
}
sprintf(MsgBuf, "ChangeDisplaySettings ERROR res=%s err=%d\n", err, GetLastError());
MessageBoxEx(0, MsgBuf, "Error", MB_OKCANCEL | MB_ICONQUESTION, NULL);
}
}
void CDxwndhostView::OnDesktopcolordepth8bpp()
{
// TODO: Add your command handler code here
SwitchToColorDepth(8);
}
void CDxwndhostView::OnDesktopcolordepth16bpp()
{
// TODO: Add your command handler code here
SwitchToColorDepth(16);
}
void CDxwndhostView::OnDesktopcolordepth24bpp()
{
// TODO: Add your command handler code here
SwitchToColorDepth(24);
}
void CDxwndhostView::OnDesktopcolordepth32bpp()
{
// TODO: Add your command handler code here
SwitchToColorDepth(32);
}

4
host/dxwndhostView.h
View File

@ -86,6 +86,10 @@ protected:
afx_msg void OnViewPalette();
afx_msg void OnViewTimeSlider();
afx_msg void OnExit();
afx_msg void OnDesktopcolordepth8bpp();
afx_msg void OnDesktopcolordepth16bpp();
afx_msg void OnDesktopcolordepth24bpp();
afx_msg void OnDesktopcolordepth32bpp();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};